mirror of
https://github.com/RetroShare/RetroShare.git
synced 2024-12-11 08:54:34 -05:00
da4c1e0f7f
- Added GxsChannels - Added New Common Comments GUI elements. - Moved Posted over to use Comments. Lots done, but lots to do! git-svn-id: http://svn.code.sf.net/p/retroshare/code/trunk@6212 b45a01b8-16f6-495d-af2f-9b41ad6348cc
1093 lines
28 KiB
C++
1093 lines
28 KiB
C++
/****************************************************************
|
|
* RetroShare is distributed under the following license:
|
|
*
|
|
* Copyright (C) 2008 Robert Fernie
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License
|
|
* as published by the Free Software Foundation; either version 2
|
|
* of the License, or (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor,
|
|
* Boston, MA 02110-1301, USA.
|
|
****************************************************************/
|
|
|
|
#include <QMenu>
|
|
#include <QTimer>
|
|
#include <QStandardItemModel>
|
|
#include <QMessageBox>
|
|
|
|
#include <iostream>
|
|
#include <algorithm>
|
|
#include <set>
|
|
#include <map>
|
|
|
|
#include "GxsChannelDialog.h"
|
|
|
|
//#include "../feeds/ChanMsgItem.h"
|
|
#include "../feeds/GxsChannelPostItem.h"
|
|
|
|
#include "../common/PopularityDefs.h"
|
|
#include "../settings/rsharesettings.h"
|
|
|
|
#include "gui/gxschannels/GxsChannelGroupDialog.h"
|
|
#include "gui/gxschannels/CreateGxsChannelMsg.h"
|
|
|
|
//#include "../channels/ChannelDetails.h"
|
|
//#include "../channels/EditChanDetails.h"
|
|
#include "../channels/ShareKey.h"
|
|
#include "../channels/ChannelUserNotify.h"
|
|
|
|
|
|
#include "../notifyqt.h"
|
|
#include "../RetroShareLink.h"
|
|
|
|
#define CHAN_DEFAULT_IMAGE ":/images/channels.png"
|
|
|
|
#define WARNING_LIMIT 3600*24*2
|
|
|
|
/* Images for TreeWidget */
|
|
#define IMAGE_CHANNELBLUE ":/images/channelsblue.png"
|
|
#define IMAGE_CHANNELGREEN ":/images/channelsgreen.png"
|
|
#define IMAGE_CHANNELRED ":/images/channelsred.png"
|
|
#define IMAGE_CHANNELYELLOW ":/images/channelsyellow.png"
|
|
|
|
/****
|
|
* #define CHAN_DEBUG
|
|
***/
|
|
|
|
#define USE_THREAD
|
|
|
|
/** Constructor */
|
|
GxsChannelDialog::GxsChannelDialog(QWidget *parent)
|
|
: RsAutoUpdatePage(1000,parent), GxsServiceDialog(dynamic_cast<GxsCommentContainer *>(parent))
|
|
{
|
|
/* Invoke the Qt Designer generated object setup routine */
|
|
ui.setupUi(this);
|
|
|
|
mChannelQueue = new TokenQueue(rsGxsChannels->getTokenService(), this);
|
|
|
|
connect(ui.newChannelButton, SIGNAL(clicked()), this, SLOT(createChannel()));
|
|
connect(ui.postButton, SIGNAL(clicked()), this, SLOT(createMsg()));
|
|
connect(NotifyQt::getInstance(), SIGNAL(channelMsgReadSatusChanged(QString,QString,int)), this, SLOT(channelMsgReadSatusChanged(QString,QString,int)));
|
|
|
|
connect(ui.refreshButton, SIGNAL(clicked()), this, SLOT(forceUpdateDisplay()));
|
|
|
|
|
|
/*************** Setup Left Hand Side (List of Channels) ****************/
|
|
|
|
connect(ui.treeWidget, SIGNAL(treeCustomContextMenuRequested(QPoint)), this, SLOT( channelListCustomPopupMenu( QPoint ) ) );
|
|
connect(ui.treeWidget, SIGNAL(treeCurrentItemChanged(QString)), this, SLOT(selectChannel(QString)));
|
|
|
|
mChannelId.clear();
|
|
|
|
/* Set initial size the splitter */
|
|
QList<int> sizes;
|
|
sizes << 300 << width(); // Qt calculates the right sizes
|
|
ui.splitter->setSizes(sizes);
|
|
|
|
/* Initialize group tree */
|
|
ui.treeWidget->initDisplayMenu(ui.displayButton);
|
|
|
|
ownChannels = ui.treeWidget->addCategoryItem(tr("My Channels"), QIcon(IMAGE_CHANNELBLUE), true);
|
|
subcribedChannels = ui.treeWidget->addCategoryItem(tr("Subscribed Channels"), QIcon(IMAGE_CHANNELRED), true);
|
|
popularChannels = ui.treeWidget->addCategoryItem(tr("Popular Channels"), QIcon(IMAGE_CHANNELGREEN ), false);
|
|
otherChannels = ui.treeWidget->addCategoryItem(tr("Other Channels"), QIcon(IMAGE_CHANNELYELLOW), false);
|
|
|
|
ui.progressLabel->hide();
|
|
ui.progressBar->hide();
|
|
|
|
fillThread = NULL;
|
|
|
|
//added from ahead
|
|
//updateChannelList();
|
|
forceUpdateDisplay();
|
|
|
|
ui.nameLabel->setMinimumWidth(20);
|
|
|
|
/* load settings */
|
|
processSettings(true);
|
|
|
|
//updateChannelMsgs();
|
|
}
|
|
|
|
GxsChannelDialog::~GxsChannelDialog()
|
|
{
|
|
if (fillThread) {
|
|
fillThread->stop();
|
|
delete(fillThread);
|
|
fillThread = NULL;
|
|
}
|
|
|
|
// save settings
|
|
processSettings(false);
|
|
}
|
|
|
|
|
|
// Callback from Widget->FeedHolder->ServiceDialog->CommentContainer->CommentDialog,
|
|
void GxsChannelDialog::openComments(uint32_t type, const RsGxsGroupId &groupId, const RsGxsMessageId &msgId)
|
|
{
|
|
commentLoad(groupId, msgId);
|
|
}
|
|
|
|
|
|
UserNotify *GxsChannelDialog::getUserNotify(QObject *parent)
|
|
{
|
|
return new ChannelUserNotify(parent);
|
|
return NULL;
|
|
}
|
|
|
|
void GxsChannelDialog::processSettings(bool load)
|
|
{
|
|
Settings->beginGroup(QString("GxsChannelDialog"));
|
|
|
|
if (load) {
|
|
// load settings
|
|
|
|
// state of splitter
|
|
ui.splitter->restoreState(Settings->value("Splitter").toByteArray());
|
|
} else {
|
|
// save settings
|
|
|
|
// state of splitter
|
|
Settings->setValue("Splitter", ui.splitter->saveState());
|
|
}
|
|
|
|
ui.treeWidget->processSettings(Settings, load);
|
|
|
|
Settings->endGroup();
|
|
}
|
|
|
|
void GxsChannelDialog::channelListCustomPopupMenu( QPoint /*point*/ )
|
|
{
|
|
ChannelInfo ci;
|
|
if (!rsChannels->getChannelInfo(mChannelId, ci)) {
|
|
return;
|
|
}
|
|
|
|
QMenu contextMnu(this);
|
|
|
|
QAction *postchannelAct = new QAction(QIcon(":/images/mail_reply.png"), tr( "Post to Channel" ), &contextMnu);
|
|
connect( postchannelAct , SIGNAL( triggered() ), this, SLOT( createMsg() ) );
|
|
|
|
QAction *subscribechannelAct = new QAction(QIcon(":/images/edit_add24.png"), tr( "Subscribe to Channel" ), &contextMnu);
|
|
connect( subscribechannelAct , SIGNAL( triggered() ), this, SLOT( subscribeChannel() ) );
|
|
|
|
QAction *unsubscribechannelAct = new QAction(QIcon(":/images/cancel.png"), tr( "Unsubscribe to Channel" ), &contextMnu);
|
|
connect( unsubscribechannelAct , SIGNAL( triggered() ), this, SLOT( unsubscribeChannel() ) );
|
|
|
|
QAction *setallasreadchannelAct = new QAction(QIcon(":/images/message-mail-read.png"), tr( "Set all as read" ), &contextMnu);
|
|
connect( setallasreadchannelAct , SIGNAL( triggered() ), this, SLOT( setAllAsReadClicked() ) );
|
|
|
|
bool autoDl = false;
|
|
rsChannels->channelGetAutoDl(mChannelId, autoDl);
|
|
|
|
QAction *autochannelAct = autoDl? (new QAction(QIcon(":/images/redled.png"), tr( "Disable Auto-Download" ), &contextMnu))
|
|
: (new QAction(QIcon(":/images/start.png"),tr( "Enable Auto-Download" ), &contextMnu)) ;
|
|
|
|
connect( autochannelAct , SIGNAL( triggered() ), this, SLOT( toggleAutoDownload() ) );
|
|
|
|
QAction *channeldetailsAct = new QAction(QIcon(":/images/info16.png"), tr( "Show Channel Details" ), &contextMnu);
|
|
connect( channeldetailsAct , SIGNAL( triggered() ), this, SLOT( showChannelDetails() ) );
|
|
|
|
QAction *restoreKeysAct = new QAction(QIcon(":/images/settings16.png"), tr("Restore Publish Rights for Channel" ), &contextMnu);
|
|
connect( restoreKeysAct , SIGNAL( triggered() ), this, SLOT( restoreChannelKeys() ) );
|
|
|
|
QAction *editChannelDetailAct = new QAction(QIcon(":/images/edit_16.png"), tr("Edit Channel Details"), &contextMnu);
|
|
connect( editChannelDetailAct, SIGNAL( triggered() ), this, SLOT( editChannelDetail() ) );
|
|
|
|
QAction *shareKeyAct = new QAction(QIcon(":/images/gpgp_key_generate.png"), tr("Share Channel"), &contextMnu);
|
|
connect( shareKeyAct, SIGNAL( triggered() ), this, SLOT( shareKey() ) );
|
|
|
|
if((ci.channelFlags & RS_DISTRIB_ADMIN) && (ci.channelFlags & RS_DISTRIB_SUBSCRIBED))
|
|
contextMnu.addAction( editChannelDetailAct);
|
|
else
|
|
contextMnu.addAction( channeldetailsAct );
|
|
|
|
if((ci.channelFlags & RS_DISTRIB_PUBLISH) && (ci.channelFlags & RS_DISTRIB_SUBSCRIBED))
|
|
{
|
|
contextMnu.addAction( postchannelAct );
|
|
contextMnu.addAction( shareKeyAct );
|
|
}
|
|
|
|
if(ci.channelFlags & RS_DISTRIB_SUBSCRIBED)
|
|
{
|
|
contextMnu.addAction( unsubscribechannelAct );
|
|
contextMnu.addAction( restoreKeysAct );
|
|
contextMnu.addSeparator();
|
|
contextMnu.addAction( autochannelAct );
|
|
contextMnu.addAction( setallasreadchannelAct );
|
|
}
|
|
else
|
|
contextMnu.addAction( subscribechannelAct );
|
|
|
|
contextMnu.addSeparator();
|
|
QAction *action = contextMnu.addAction(QIcon(":/images/copyrslink.png"), tr("Copy RetroShare Link"), this, SLOT(copyChannelLink()));
|
|
action->setEnabled(!mChannelId.empty());
|
|
|
|
#ifdef CHAN_DEBUG
|
|
contextMnu.addSeparator();
|
|
action = contextMnu.addAction("Generate mass data", this, SLOT(generateMassData()));
|
|
action->setEnabled (!mChannelId.empty() && (ci.channelFlags & RS_DISTRIB_PUBLISH));
|
|
#endif
|
|
|
|
contextMnu.exec(QCursor::pos());
|
|
}
|
|
|
|
void GxsChannelDialog::createChannel()
|
|
{
|
|
GxsChannelGroupDialog cc(mChannelQueue, this);
|
|
cc.exec();
|
|
}
|
|
|
|
/*************************************************************************************/
|
|
/*************************************************************************************/
|
|
/*************************************************************************************/
|
|
|
|
QScrollArea *GxsChannelDialog::getScrollArea()
|
|
{
|
|
return ui.scrollArea;
|
|
}
|
|
|
|
void GxsChannelDialog::deleteFeedItem(QWidget * /*item*/, uint32_t /*type*/)
|
|
{
|
|
}
|
|
|
|
void GxsChannelDialog::openChat(std::string /*peerId*/)
|
|
{
|
|
|
|
}
|
|
|
|
void GxsChannelDialog::editChannelDetail()
|
|
{
|
|
#if 0
|
|
EditChanDetails editUi(this, mChannelId);
|
|
editUi.exec();
|
|
#endif
|
|
}
|
|
|
|
void GxsChannelDialog::shareKey()
|
|
{
|
|
#if 0
|
|
ShareKey shareUi(this, mChannelId, CHANNEL_KEY_SHARE);
|
|
shareUi.exec();
|
|
#endif
|
|
|
|
}
|
|
|
|
void GxsChannelDialog::copyChannelLink()
|
|
{
|
|
|
|
#if 0
|
|
if (mChannelId.empty()) {
|
|
return;
|
|
}
|
|
|
|
ChannelInfo ci;
|
|
if (rsChannels->getChannelInfo(mChannelId, ci)) {
|
|
RetroShareLink link;
|
|
if (link.createChannel(ci.channelId, "")) {
|
|
QList<RetroShareLink> urls;
|
|
urls.push_back(link);
|
|
RSLinkClipboard::copyLinks(urls);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
}
|
|
|
|
void GxsChannelDialog::createMsg()
|
|
{
|
|
if (mChannelId.empty()) {
|
|
return;
|
|
}
|
|
|
|
CreateGxsChannelMsg *msgDialog = new CreateGxsChannelMsg(mChannelId);
|
|
msgDialog->show();
|
|
}
|
|
|
|
void GxsChannelDialog::restoreChannelKeys()
|
|
{
|
|
|
|
#if 0
|
|
if(rsChannels->channelRestoreKeys(mChannelId))
|
|
QMessageBox::information(NULL,tr("Publish rights restored."),tr("Publish rights have been restored for this channel.")) ;
|
|
else
|
|
QMessageBox::warning(NULL,tr("Publish not restored."),tr("Publish rights can't be restored for this channel.<br/>You're not the creator of this channel.")) ;
|
|
#endif
|
|
|
|
}
|
|
|
|
void GxsChannelDialog::selectChannel(const QString &id)
|
|
{
|
|
mChannelId = id.toStdString();
|
|
|
|
#if 0
|
|
bool autoDl = false;
|
|
rsChannels->channelGetAutoDl(mChannelId, autoDl);
|
|
|
|
setAutoDownloadButton(autoDl);
|
|
#endif
|
|
|
|
requestPosts(mChannelId);
|
|
//updateChannelMsgs();
|
|
}
|
|
|
|
void GxsChannelDialog::updateDisplay()
|
|
{
|
|
if (!rsGxsChannels) {
|
|
return;
|
|
}
|
|
|
|
if (rsGxsChannels->updated())
|
|
{
|
|
insertChannels();
|
|
}
|
|
}
|
|
|
|
void GxsChannelDialog::forceUpdateDisplay()
|
|
{
|
|
std::cerr << "GxsChannelDialog::forceUpdateDisplay()";
|
|
std::cerr << std::endl;
|
|
|
|
insertChannels();
|
|
}
|
|
|
|
static void channelInfoToGroupItemInfo(const RsGroupMetaData &channelInfo, GroupItemInfo &groupItemInfo)
|
|
{
|
|
groupItemInfo.id = QString::fromStdString(channelInfo.mGroupId);
|
|
groupItemInfo.name = QString::fromUtf8(channelInfo.mGroupName.c_str());
|
|
groupItemInfo.popularity = channelInfo.mPop;
|
|
groupItemInfo.lastpost = QDateTime::fromTime_t(channelInfo.mLastPost);
|
|
groupItemInfo.subscribeFlags = channelInfo.mSubscribeFlags;
|
|
|
|
QPixmap chanImage = QPixmap(CHAN_DEFAULT_IMAGE);
|
|
groupItemInfo.icon = QIcon(chanImage);
|
|
}
|
|
|
|
void GxsChannelDialog::insertChannelData(const std::list<RsGroupMetaData> &channelList)
|
|
{
|
|
std::list<RsGroupMetaData>::const_iterator it;
|
|
|
|
QList<GroupItemInfo> adminList;
|
|
QList<GroupItemInfo> subList;
|
|
QList<GroupItemInfo> popList;
|
|
QList<GroupItemInfo> otherList;
|
|
std::multimap<uint32_t, GroupItemInfo> popMap;
|
|
|
|
for(it = channelList.begin(); it != channelList.end(); it++) {
|
|
/* sort it into Publish (Own), Subscribed, Popular and Other */
|
|
uint32_t flags = it->mSubscribeFlags;
|
|
|
|
GroupItemInfo groupItemInfo;
|
|
channelInfoToGroupItemInfo(*it, groupItemInfo);
|
|
|
|
if (IS_GROUP_ADMIN(flags)) {
|
|
adminList.push_back(groupItemInfo);
|
|
} else if (IS_GROUP_SUBSCRIBED(flags)) {
|
|
/* subscribed forum */
|
|
subList.push_back(groupItemInfo);
|
|
} else {
|
|
/* rate the others by popularity */
|
|
popMap.insert(std::make_pair(it->mPop, groupItemInfo));
|
|
}
|
|
}
|
|
|
|
/* iterate backwards through popMap - take the top 5 or 10% of list */
|
|
uint32_t popCount = 5;
|
|
if (popCount < popMap.size() / 10)
|
|
{
|
|
popCount = popMap.size() / 10;
|
|
}
|
|
|
|
uint32_t i = 0;
|
|
std::multimap<uint32_t, GroupItemInfo>::reverse_iterator rit;
|
|
for (rit = popMap.rbegin(); rit != popMap.rend(); rit++)
|
|
{
|
|
if (i < popCount)
|
|
{
|
|
popList.push_back(rit->second);
|
|
i++;
|
|
}
|
|
else
|
|
{
|
|
otherList.push_back(rit->second);
|
|
}
|
|
}
|
|
|
|
/* now we have our lists ---> update entries */
|
|
|
|
ui.treeWidget->fillGroupItems(ownChannels, adminList);
|
|
ui.treeWidget->fillGroupItems(subcribedChannels, subList);
|
|
ui.treeWidget->fillGroupItems(popularChannels, popList);
|
|
ui.treeWidget->fillGroupItems(otherChannels, otherList);
|
|
|
|
updateMessageSummaryList("");
|
|
}
|
|
|
|
|
|
void GxsChannelDialog::channelMsgReadSatusChanged(const QString& channelId, const QString& /*msgId*/, int /*status*/)
|
|
{
|
|
updateMessageSummaryList(channelId.toStdString());
|
|
}
|
|
|
|
void GxsChannelDialog::updateMessageSummaryList(const std::string &channelId)
|
|
{
|
|
QTreeWidgetItem *items[2] = { ownChannels, subcribedChannels };
|
|
|
|
for (int item = 0; item < 2; item++) {
|
|
int child;
|
|
int childCount = items[item]->childCount();
|
|
for (child = 0; child < childCount; child++) {
|
|
QTreeWidgetItem *childItem = items[item]->child(child);
|
|
std::string childId = ui.treeWidget->itemId(childItem).toStdString();
|
|
if (childId.empty()) {
|
|
continue;
|
|
}
|
|
|
|
if (channelId.empty() || childId == channelId) {
|
|
/* Calculate unread messages */
|
|
unsigned int newMessageCount = 0;
|
|
unsigned int unreadMessageCount = 0;
|
|
rsChannels->getMessageCount(childId, newMessageCount, unreadMessageCount);
|
|
|
|
ui.treeWidget->setUnreadCount(childItem, unreadMessageCount);
|
|
|
|
if (channelId.empty() == false) {
|
|
/* Calculate only this channel */
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static bool sortChannelMsgSummary(const ChannelMsgSummary &msg1, const ChannelMsgSummary &msg2)
|
|
{
|
|
return (msg1.ts > msg2.ts);
|
|
}
|
|
|
|
#if 0
|
|
void GxsChannelDialog::updateChannelMsgs()
|
|
{
|
|
if (fillThread) {
|
|
#ifdef CHAN_DEBUG
|
|
std::cerr << "GxsChannelDialog::updateChannelMsgs() stop current fill thread" << std::endl;
|
|
#endif
|
|
// stop current fill thread
|
|
GxsChannelFillThread *thread = fillThread;
|
|
fillThread = NULL;
|
|
thread->stop();
|
|
delete(thread);
|
|
|
|
progressLabel->hide();
|
|
progressBar->hide();
|
|
}
|
|
|
|
if (!rsChannels) {
|
|
return;
|
|
}
|
|
|
|
/* replace all the messages with new ones */
|
|
QList<ChanMsgItem *>::iterator mit;
|
|
for (mit = mChanMsgItems.begin(); mit != mChanMsgItems.end(); mit++) {
|
|
delete (*mit);
|
|
}
|
|
mChanMsgItems.clear();
|
|
|
|
ChannelInfo ci;
|
|
if (!rsChannels->getChannelInfo(mChannelId, ci)) {
|
|
postButton->setEnabled(false);
|
|
nameLabel->setText(tr("No Channel Selected"));
|
|
logoLabel->setPixmap(QPixmap(":/images/channels.png"));
|
|
logoLabel->setEnabled(false);
|
|
return;
|
|
}
|
|
|
|
QPixmap chanImage;
|
|
if (ci.pngImageLen != 0) {
|
|
chanImage.loadFromData(ci.pngChanImage, ci.pngImageLen, "PNG");
|
|
} else {
|
|
chanImage = QPixmap(CHAN_DEFAULT_IMAGE);
|
|
}
|
|
logoLabel->setPixmap(chanImage);
|
|
logoLabel->setEnabled(true);
|
|
|
|
/* set Channel name */
|
|
nameLabel->setText(QString::fromStdWString(ci.channelName));
|
|
|
|
if (ci.channelFlags & RS_DISTRIB_PUBLISH) {
|
|
postButton->setEnabled(true);
|
|
} else {
|
|
postButton->setEnabled(false);
|
|
}
|
|
|
|
if (!(ci.channelFlags & RS_DISTRIB_ADMIN) &&
|
|
(ci.channelFlags & RS_DISTRIB_SUBSCRIBED)) {
|
|
actionEnable_Auto_Download->setEnabled(true);
|
|
} else {
|
|
actionEnable_Auto_Download->setEnabled(false);
|
|
}
|
|
|
|
#ifdef USE_THREAD
|
|
progressLabel->show();
|
|
progressBar->reset();
|
|
progressBar->show();
|
|
|
|
// create fill thread
|
|
fillThread = new GxsChannelFillThread(this, mChannelId);
|
|
|
|
// connect thread
|
|
connect(fillThread, SIGNAL(finished()), this, SLOT(fillThreadFinished()), Qt::BlockingQueuedConnection);
|
|
connect(fillThread, SIGNAL(addMsg(QString,QString,int,int)), this, SLOT(fillThreadAddMsg(QString,QString,int,int)), Qt::BlockingQueuedConnection);
|
|
|
|
#ifdef CHAN_DEBUG
|
|
std::cerr << "GxsChannelDialog::updateChannelMsgs() Start fill thread" << std::endl;
|
|
#endif
|
|
|
|
// start thread
|
|
fillThread->start();
|
|
#else
|
|
std::list<ChannelMsgSummary> msgs;
|
|
std::list<ChannelMsgSummary>::iterator it;
|
|
rsChannels->getChannelMsgList(mChannelId, msgs);
|
|
|
|
msgs.sort(sortChannelMsgSummary);
|
|
|
|
for (it = msgs.begin(); it != msgs.end(); it++) {
|
|
ChanMsgItem *cmi = new ChanMsgItem(this, 0, mChannelId, it->msgId, true);
|
|
mChanMsgItems.push_back(cmi);
|
|
verticalLayout_2->addWidget(cmi);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
void GxsChannelDialog::fillThreadFinished()
|
|
{
|
|
#ifdef CHAN_DEBUG
|
|
std::cerr << "GxsChannelDialog::fillThreadFinished()" << std::endl;
|
|
#endif
|
|
|
|
// thread has finished
|
|
GxsChannelFillThread *thread = dynamic_cast<GxsChannelFillThread*>(sender());
|
|
if (thread) {
|
|
if (thread == fillThread) {
|
|
// current thread has finished, hide progressbar and release thread
|
|
progressBar->hide();
|
|
progressLabel->hide();
|
|
fillThread = NULL;
|
|
}
|
|
|
|
#ifdef CHAN_DEBUG
|
|
if (thread->wasStopped()) {
|
|
// thread was stopped
|
|
std::cerr << "GxsChannelDialog::fillThreadFinished() Thread was stopped" << std::endl;
|
|
}
|
|
#endif
|
|
|
|
#ifdef CHAN_DEBUG
|
|
std::cerr << "GxsChannelDialog::fillThreadFinished() Delete thread" << std::endl;
|
|
#endif
|
|
|
|
thread->deleteLater();
|
|
thread = NULL;
|
|
}
|
|
|
|
#ifdef CHAN_DEBUG
|
|
std::cerr << "GxsChannelDialog::fillThreadFinished done()" << std::endl;
|
|
#endif
|
|
}
|
|
|
|
void GxsChannelDialog::fillThreadAddMsg(const QString &channelId, const QString &channelMsgId, int current, int count)
|
|
{
|
|
if (sender() == fillThread) {
|
|
// show fill progress
|
|
if (count) {
|
|
progressBar->setValue(current * progressBar->maximum() / count);
|
|
}
|
|
|
|
lockLayout(NULL, true);
|
|
|
|
ChanMsgItem *cmi = new ChanMsgItem(this, 0, channelId.toStdString(), channelMsgId.toStdString(), true);
|
|
mChanMsgItems.push_back(cmi);
|
|
verticalLayout->addWidget(cmi);
|
|
cmi->show();
|
|
|
|
lockLayout(cmi, false);
|
|
}
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
void GxsChannelDialog::unsubscribeChannel()
|
|
{
|
|
#ifdef CHAN_DEBUG
|
|
std::cerr << "GxsChannelDialog::unsubscribeChannel()";
|
|
std::cerr << std::endl;
|
|
#endif
|
|
|
|
#if 0
|
|
if (rsChannels) {
|
|
rsChannels->channelSubscribe(mChannelId, false, false);
|
|
}
|
|
|
|
updateChannelMsgs();
|
|
#endif
|
|
}
|
|
|
|
|
|
void GxsChannelDialog::subscribeChannel()
|
|
{
|
|
#ifdef CHAN_DEBUG
|
|
std::cerr << "GxsChannelDialog::subscribeChannel()";
|
|
std::cerr << std::endl;
|
|
#endif
|
|
|
|
#if 0
|
|
if (rsChannels) {
|
|
rsChannels->channelSubscribe(mChannelId, true, false);
|
|
}
|
|
|
|
updateChannelMsgs();
|
|
#endif
|
|
|
|
}
|
|
|
|
void GxsChannelDialog::showChannelDetails()
|
|
{
|
|
#if 0
|
|
if (mChannelId.empty()) {
|
|
return;
|
|
}
|
|
|
|
if (!rsChannels) {
|
|
return;
|
|
}
|
|
|
|
ChannelDetails channelui (this);
|
|
|
|
channelui.showDetails(mChannelId);
|
|
channelui.exec();
|
|
#endif
|
|
|
|
}
|
|
|
|
void GxsChannelDialog::setAllAsReadClicked()
|
|
{
|
|
#if 0
|
|
if (mChannelId.empty()) {
|
|
return;
|
|
}
|
|
|
|
if (!rsChannels) {
|
|
return;
|
|
}
|
|
|
|
ChannelInfo ci;
|
|
if (rsChannels->getChannelInfo(mChannelId, ci) == false) {
|
|
return;
|
|
}
|
|
|
|
if (ci.channelFlags & RS_DISTRIB_SUBSCRIBED) {
|
|
std::list<ChannelMsgSummary> msgs;
|
|
std::list<ChannelMsgSummary>::iterator it;
|
|
|
|
rsChannels->getChannelMsgList(mChannelId, msgs);
|
|
|
|
for(it = msgs.begin(); it != msgs.end(); it++) {
|
|
rsChannels->setMessageStatus(mChannelId, it->msgId, CHANNEL_MSG_STATUS_READ, CHANNEL_MSG_STATUS_READ | CHANNEL_MSG_STATUS_UNREAD_BY_USER);
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
void GxsChannelDialog::toggleAutoDownload()
|
|
{
|
|
#if 0
|
|
|
|
if(mChannelId.empty())
|
|
return;
|
|
|
|
bool autoDl = true;
|
|
|
|
if(rsChannels->channelGetAutoDl(mChannelId, autoDl)){
|
|
|
|
// if auto dl is set true, then set false
|
|
if(autoDl){
|
|
rsChannels->channelSetAutoDl(mChannelId, false);
|
|
}else{
|
|
rsChannels->channelSetAutoDl(mChannelId, true);
|
|
}
|
|
setAutoDownloadButton(!autoDl);
|
|
}
|
|
else{
|
|
std::cerr << "Auto Download failed to set"
|
|
<< std::endl;
|
|
}
|
|
#endif
|
|
}
|
|
|
|
bool GxsChannelDialog::navigate(const std::string& channelId, const std::string& msgId)
|
|
{
|
|
|
|
#if 0
|
|
if (channelId.empty()) {
|
|
return false;
|
|
}
|
|
|
|
if (treeWidget->activateId(QString::fromStdString(channelId), msgId.empty()) == NULL) {
|
|
return false;
|
|
}
|
|
|
|
/* Messages are filled in selectChannel */
|
|
if (mChannelId != channelId) {
|
|
return false;
|
|
}
|
|
|
|
if (msgId.empty()) {
|
|
return true;
|
|
}
|
|
|
|
/* Search exisiting item */
|
|
QList<ChanMsgItem*>::iterator mit;
|
|
for (mit = mChanMsgItems.begin(); mit != mChanMsgItems.end(); mit++) {
|
|
ChanMsgItem *item = *mit;
|
|
if (item->msgId() == msgId) {
|
|
// the next two lines are necessary to calculate the layout of the widgets in the scroll area (maybe there is a better solution)
|
|
item->show();
|
|
QCoreApplication::processEvents();
|
|
|
|
scrollArea->ensureWidgetVisible(item, 0, 0);
|
|
return true;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
return false;
|
|
}
|
|
|
|
void GxsChannelDialog::setAutoDownloadButton(bool autoDl)
|
|
{
|
|
#if 0
|
|
if (autoDl) {
|
|
actionEnable_Auto_Download->setText(tr("Disable Auto-Download"));
|
|
}else{
|
|
actionEnable_Auto_Download->setText(tr("Enable Auto-Download"));
|
|
}
|
|
#endif
|
|
}
|
|
|
|
|
|
|
|
// ForumsFillThread
|
|
GxsChannelFillThread::GxsChannelFillThread(GxsChannelDialog *parent, const std::string &channelId)
|
|
: QThread(parent)
|
|
{
|
|
stopped = false;
|
|
this->channelId = channelId;
|
|
}
|
|
|
|
GxsChannelFillThread::~GxsChannelFillThread()
|
|
{
|
|
#ifdef CHAN_DEBUG
|
|
std::cerr << "GxsChannelFillThread::~GxsChannelFillThread" << std::endl;
|
|
#endif
|
|
}
|
|
|
|
void GxsChannelFillThread::stop()
|
|
{
|
|
disconnect();
|
|
stopped = true;
|
|
QApplication::processEvents();
|
|
wait();
|
|
}
|
|
|
|
void GxsChannelFillThread::run()
|
|
{
|
|
#ifdef CHAN_DEBUG
|
|
std::cerr << "GxsChannelFillThread::run()" << std::endl;
|
|
#endif
|
|
|
|
std::list<ChannelMsgSummary> msgs;
|
|
std::list<ChannelMsgSummary>::iterator it;
|
|
rsChannels->getChannelMsgList(channelId, msgs);
|
|
|
|
msgs.sort(sortChannelMsgSummary);
|
|
|
|
int count = msgs.size();
|
|
int pos = 0;
|
|
|
|
for (it = msgs.begin(); it != msgs.end(); it++) {
|
|
if (stopped) {
|
|
break;
|
|
}
|
|
|
|
emit addMsg(QString::fromStdString(channelId), QString::fromStdString(it->msgId), ++pos, count);
|
|
}
|
|
|
|
#ifdef CHAN_DEBUG
|
|
std::cerr << "GxsChannelFillThread::run() stopped: " << (wasStopped() ? "yes" : "no") << std::endl;
|
|
#endif
|
|
}
|
|
|
|
|
|
|
|
/**********************************************************************************************
|
|
* New Stuff here.
|
|
*
|
|
*
|
|
*
|
|
*************/
|
|
|
|
/*********************** **** **** **** ***********************/
|
|
/** Request / Response of Data ********************************/
|
|
/*********************** **** **** **** ***********************/
|
|
|
|
#define TOKEN_TYPE_LISTING 1
|
|
#define TOKEN_TYPE_GROUP_DATA 2
|
|
#define TOKEN_TYPE_POSTS 3
|
|
|
|
void GxsChannelDialog::insertChannels()
|
|
{
|
|
requestGroupSummary();
|
|
}
|
|
|
|
void GxsChannelDialog::requestGroupSummary()
|
|
{
|
|
std::cerr << "GxsChannelDialog::requestGroupSummary()";
|
|
std::cerr << std::endl;
|
|
|
|
std::list<uint32_t> tokens;
|
|
mChannelQueue->activeRequestTokens(TOKEN_TYPE_LISTING, tokens);
|
|
if (!tokens.empty()) {
|
|
std::list<uint32_t>::iterator tokenIt;
|
|
for (tokenIt = tokens.begin(); tokenIt != tokens.end(); ++tokenIt) {
|
|
std::cerr << "GxsChannelDialog::requestGroupSummary() Canceling Request: " << *tokenIt;
|
|
std::cerr << std::endl;
|
|
|
|
mChannelQueue->cancelRequest(*tokenIt);
|
|
}
|
|
}
|
|
|
|
RsTokReqOptions opts;
|
|
opts.mReqType = GXS_REQUEST_TYPE_GROUP_META;
|
|
|
|
uint32_t token;
|
|
mChannelQueue->requestGroupInfo(token, RS_TOKREQ_ANSTYPE_SUMMARY, opts, TOKEN_TYPE_LISTING);
|
|
}
|
|
|
|
void GxsChannelDialog::loadGroupSummary(const uint32_t &token)
|
|
{
|
|
std::cerr << "GxsChannelDialog::loadGroupSummary()";
|
|
std::cerr << std::endl;
|
|
|
|
std::list<RsGroupMetaData> groupInfo;
|
|
rsGxsChannels->getGroupSummary(token, groupInfo);
|
|
|
|
if (groupInfo.size() > 0)
|
|
{
|
|
insertChannelData(groupInfo);
|
|
}
|
|
else
|
|
{
|
|
std::cerr << "GxsChannelDialog::loadGroupSummary() ERROR No Groups...";
|
|
std::cerr << std::endl;
|
|
}
|
|
}
|
|
|
|
|
|
void GxsChannelDialog::requestGroupData(const RsGxsGroupId &grpId)
|
|
{
|
|
std::cerr << "GxsChannelDialog::requestGroupData()";
|
|
std::cerr << std::endl;
|
|
|
|
std::list<uint32_t> tokens;
|
|
mChannelQueue->activeRequestTokens(TOKEN_TYPE_GROUP_DATA, tokens);
|
|
if (!tokens.empty()) {
|
|
std::list<uint32_t>::iterator tokenIt;
|
|
for (tokenIt = tokens.begin(); tokenIt != tokens.end(); ++tokenIt) {
|
|
std::cerr << "GxsChannelDialog::requestGroupData() Canceling Request: " << *tokenIt;
|
|
std::cerr << std::endl;
|
|
|
|
mChannelQueue->cancelRequest(*tokenIt);
|
|
}
|
|
}
|
|
|
|
std::list<RsGxsGroupId> groupIds;
|
|
groupIds.push_back(grpId);
|
|
|
|
RsTokReqOptions opts;
|
|
opts.mReqType = GXS_REQUEST_TYPE_GROUP_DATA;
|
|
|
|
uint32_t token;
|
|
mChannelQueue->requestGroupInfo(token, RS_TOKREQ_ANSTYPE_DATA, opts, groupIds, TOKEN_TYPE_GROUP_DATA);
|
|
|
|
}
|
|
|
|
void GxsChannelDialog::loadGroupData(const uint32_t &token)
|
|
{
|
|
std::cerr << "GxsChannelDialog::loadGroupData()";
|
|
std::cerr << std::endl;
|
|
|
|
std::vector<RsGxsChannelGroup> groups;
|
|
rsGxsChannels->getGroupData(token, groups);
|
|
|
|
if (groups.size() == 1)
|
|
{
|
|
insertChannelDetails(groups[0]);
|
|
}
|
|
else
|
|
{
|
|
std::cerr << "GxsChannelDialog::loadGroupData() ERROR Not just one Group";
|
|
std::cerr << std::endl;
|
|
}
|
|
}
|
|
|
|
|
|
void GxsChannelDialog::requestPosts(const RsGxsGroupId &grpId)
|
|
{
|
|
std::cerr << "GxsChannelDialog::requestPosts()";
|
|
std::cerr << std::endl;
|
|
|
|
std::list<uint32_t> tokens;
|
|
mChannelQueue->activeRequestTokens(TOKEN_TYPE_POSTS, tokens);
|
|
if (!tokens.empty()) {
|
|
std::list<uint32_t>::iterator tokenIt;
|
|
for (tokenIt = tokens.begin(); tokenIt != tokens.end(); ++tokenIt) {
|
|
std::cerr << "GxsChannelDialog::requestPosts() Canceling Request: " << *tokenIt;
|
|
std::cerr << std::endl;
|
|
|
|
mChannelQueue->cancelRequest(*tokenIt);
|
|
}
|
|
}
|
|
|
|
std::list<RsGxsGroupId> groupIds;
|
|
groupIds.push_back(grpId);
|
|
|
|
RsTokReqOptions opts;
|
|
opts.mReqType = GXS_REQUEST_TYPE_MSG_DATA;
|
|
|
|
uint32_t token;
|
|
mChannelQueue->requestMsgInfo(token, RS_TOKREQ_ANSTYPE_DATA, opts, groupIds, TOKEN_TYPE_POSTS);
|
|
}
|
|
|
|
void GxsChannelDialog::loadPosts(const uint32_t &token)
|
|
{
|
|
std::cerr << "GxsChannelDialog::loadPosts()";
|
|
std::cerr << std::endl;
|
|
|
|
std::vector<RsGxsChannelPost> posts;
|
|
rsGxsChannels->getPostData(token, posts);
|
|
|
|
insertChannelPosts(posts);
|
|
}
|
|
|
|
|
|
void GxsChannelDialog::loadRequest(const TokenQueue *queue, const TokenRequest &req)
|
|
{
|
|
std::cerr << "GxsChannelDialog::loadRequest() UserType: " << req.mUserType;
|
|
std::cerr << std::endl;
|
|
|
|
if (queue == mChannelQueue)
|
|
{
|
|
/* now switch on req */
|
|
switch(req.mUserType)
|
|
{
|
|
case TOKEN_TYPE_LISTING:
|
|
loadGroupSummary(req.mToken);
|
|
break;
|
|
case TOKEN_TYPE_GROUP_DATA:
|
|
loadGroupData(req.mToken);
|
|
break;
|
|
case TOKEN_TYPE_POSTS:
|
|
loadPosts(req.mToken);
|
|
break;
|
|
default:
|
|
std::cerr << "GxsChannelDialog::loadRequest() ERROR: INVALID TYPE";
|
|
std::cerr << std::endl;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void GxsChannelDialog::insertChannelDetails(const RsGxsChannelGroup &group)
|
|
{
|
|
/* replace all the messages with new ones */
|
|
QList<GxsChannelPostItem *>::iterator mit;
|
|
for (mit = mChannelPostItems.begin(); mit != mChannelPostItems.end(); mit++) {
|
|
delete (*mit);
|
|
}
|
|
|
|
mChannelPostItems.clear();
|
|
|
|
/* IMAGE - TODO. */
|
|
#if 0
|
|
QPixmap chanImage;
|
|
if (ci.pngImageLen != 0) {
|
|
chanImage.loadFromData(ci.pngChanImage, ci.pngImageLen, "PNG");
|
|
} else {
|
|
chanImage = QPixmap(CHAN_DEFAULT_IMAGE);
|
|
}
|
|
logoLabel->setPixmap(chanImage);
|
|
logoLabel->setEnabled(true);
|
|
#endif
|
|
|
|
/* set Channel name */
|
|
ui.nameLabel->setText(QString::fromUtf8(group.mMeta.mGroupName.c_str()));
|
|
|
|
#if 0
|
|
if (group.mMeta.channelFlags & RS_DISTRIB_PUBLISH)
|
|
{
|
|
postButton->setEnabled(true);
|
|
}
|
|
else
|
|
{
|
|
postButton->setEnabled(false);
|
|
}
|
|
|
|
if (!(ci.channelFlags & RS_DISTRIB_ADMIN) &&
|
|
(ci.channelFlags & RS_DISTRIB_SUBSCRIBED))
|
|
{
|
|
actionEnable_Auto_Download->setEnabled(true);
|
|
}
|
|
else
|
|
{
|
|
actionEnable_Auto_Download->setEnabled(false);
|
|
}
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
void GxsChannelDialog::insertChannelPosts(const std::vector<RsGxsChannelPost> &posts)
|
|
{
|
|
std::vector<RsGxsChannelPost>::const_iterator it;
|
|
|
|
// Do these need sorting? probably.
|
|
// can we add that into the request?
|
|
//msgs.sort(sortChannelMsgSummary);
|
|
|
|
uint32_t subscribeFlags = 0xffffffff;
|
|
|
|
for (it = posts.begin(); it != posts.end(); it++)
|
|
{
|
|
GxsChannelPostItem *item = new GxsChannelPostItem(this, 0, *it, subscribeFlags, true);
|
|
mChannelPostItems.push_back(item);
|
|
ui.verticalLayout->addWidget(item);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|