Git-Mirrors/RetroShare
1
0
Fork 0
mirror of https://github.com/RetroShare/RetroShare.git synced 2024-10-01 02:35:48 -04:00
Code Issues Actions Packages Projects Releases Wiki Activity

removed old code

Browse Source
This commit is contained in:
csoler 2018-12-02 16:39:33 +01:00
parent 91321725e6
commit 73c06006da
No known key found for this signature in database
GPG Key ID: 7BCA522266C0804C
5 changed files with 0 additions and 2144 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1477
retroshare-gui/src/gui/gxsforums/GxsForumThreadWidget.cpp
View File

File diff suppressed because it is too large Load Diff

33
retroshare-gui/src/gui/gxsforums/GxsForumThreadWidget.h
View File

@ -142,12 +142,6 @@ private slots:
void filterColumnChanged(int column);
void filterItems(const QString &text);
#ifdef TO_REMOVE
void fillThreadFinished();
void fillThreadProgress(int current, int count);
void fillThreadStatus(QString text);
#endif
private:
void insertMessageData(const RsGxsForumMsg &msg);
bool getCurrentPost(ForumModelPostEntry& fmpe) const ;
@ -172,20 +166,6 @@ private:
void updateMessageData(const RsGxsMessageId& msgId);
#ifdef TO_REMOVE
void requestMsgData_ReplyWithPrivateMessage(const RsGxsGrpMsgIdPair &msgId);
void requestMsgData_ShowAuthorInPeople(const RsGxsGrpMsgIdPair &msgId);
void requestMsgData_ReplyForumMessage(const RsGxsGrpMsgIdPair &msgId);
void requestMsgData_EditForumMessage(const RsGxsGrpMsgIdPair &msgId);
void loadMessageData(const uint32_t &token);
void loadMsgData_ReplyMessage(const uint32_t &token);
void loadMsgData_ReplyForumMessage(const uint32_t &token);
void loadMsgData_EditForumMessage(const uint32_t &token);
void loadMsgData_ShowAuthorInPeople(const uint32_t &token);
void loadMsgData_SetAuthorOpinion(const uint32_t &token, RsReputations::Opinion opinion);
#endif
private:
RsGxsGroupId mLastForumID;
RsGxsMessageId mThreadId;
@ -202,19 +182,6 @@ private:
unsigned int mUnreadCount;
unsigned int mNewCount;
#ifdef TO_REMOVE
uint32_t mTokenTypeGroupData;
uint32_t mTokenTypeInsertThreads;
uint32_t mTokenTypeMessageData;
uint32_t mTokenTypeReplyMessage;
uint32_t mTokenTypeReplyForumMessage;
uint32_t mTokenTypeEditForumMessage;
uint32_t mTokenTypeShowAuthorInPeople;
uint32_t mTokenTypeNegativeAuthor;
uint32_t mTokenTypePositiveAuthor;
uint32_t mTokenTypeNeutralAuthor;
#endif
/* Color definitions (for standard see qss.default) */
QColor mTextColorRead;
QColor mTextColorUnread;

558
retroshare-gui/src/gui/gxsforums/GxsForumsFillThread.cpp
View File

@ -1,558 +0,0 @@
/*******************************************************************************
* retroshare-gui/src/gui/gxsforums/GxsForumsFillThread.cpp *
* *
* Copyright 2012 Retroshare Team <retroshare.project@gmail.com> *
* *
* 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 <QApplication>
#include <QTreeWidgetItem>
#include "GxsForumsFillThread.h"
#include "GxsForumThreadWidget.h"
#include "GxsForumModel.h"
#include "retroshare/rsgxsflags.h"
#include "retroshare/rsgxsforums.h"
#include <iostream>
#include <algorithm>
//#define DEBUG_FORUMS
#ifdef TO_REMOVE
#define PROGRESSBAR_MAX 100
GxsForumsFillThread::GxsForumsFillThread(GxsForumThreadWidget *parent)
: QThread(parent), mParent(parent)
{
mStopped = false;
mCompareRole = NULL;
mExpandNewMessages = true;
mFillComplete = false;
mFilterColumn = 0;
mViewType = 0;
mFlatView = false;
mUseChildTS = false;
}
GxsForumsFillThread::~GxsForumsFillThread()
{
#ifdef DEBUG_FORUMS
std::cerr << "GxsForumsFillThread::~GxsForumsFillThread" << std::endl;
#endif
// remove all items (when items are available, the thread was terminated)
QList<QTreeWidgetItem *>::iterator item;
for (item = mItems.begin (); item != mItems.end (); ++item) {
if (*item) {
delete (*item);
}
}
mItems.clear();
mItemToExpand.clear();
}
void GxsForumsFillThread::stop()
{
disconnect();
mStopped = true;
QApplication::processEvents();
}
void GxsForumsFillThread::calculateExpand(const RsGxsForumMsg &msg, QTreeWidgetItem *item)
{
if (mFillComplete && mExpandNewMessages && IS_MSG_UNREAD(msg.mMeta.mMsgStatus)) {
QTreeWidgetItem *parentItem = item;
while ((parentItem = parentItem->parent()) != NULL) {
if (std::find(mItemToExpand.begin(), mItemToExpand.end(), parentItem) == mItemToExpand.end()) {
mItemToExpand.push_back(parentItem);
}
}
}
}
static bool decreasing_time_comp(const QPair<time_t,RsGxsMessageId>& e1,const QPair<time_t,RsGxsMessageId>& e2) { return e2.first < e1.first ; }
void GxsForumsFillThread::run()
{
RsTokenService *service = rsGxsForums->getTokenService();
uint32_t msg_token;
uint32_t grp_token;
emit status(tr("Waiting"));
{
/* get all messages of the forum */
RsTokReqOptions opts;
opts.mReqType = GXS_REQUEST_TYPE_MSG_DATA;
std::list<RsGxsGroupId> grpIds;
grpIds.push_back(mForumId);
#ifdef DEBUG_FORUMS
std::cerr << "GxsForumsFillThread::run() forum id " << mForumId << std::endl;
#endif
service->requestMsgInfo(msg_token, RS_TOKREQ_ANSTYPE_DATA, opts, grpIds);
/* wait for the answer */
uint32_t requestStatus = RsTokenService::PENDING;
while (!wasStopped()) {
requestStatus = service->requestStatus(msg_token);
if (requestStatus == RsTokenService::FAILED ||
requestStatus == RsTokenService::COMPLETE) {
break;
}
msleep(200);
}
if (requestStatus == RsTokenService::FAILED)
{
deleteLater();
return;
}
}
// also get the forum meta data.
{
RsTokReqOptions opts;
opts.mReqType = GXS_REQUEST_TYPE_GROUP_DATA;
std::list<RsGxsGroupId> grpIds;
grpIds.push_back(mForumId);
#ifdef DEBUG_FORUMS
std::cerr << "GxsForumsFillThread::run() forum id " << mForumId << std::endl;
#endif
service->requestGroupInfo(grp_token, RS_TOKREQ_ANSTYPE_DATA, opts, grpIds);
/* wait for the answer */
uint32_t requestStatus = RsTokenService::PENDING;
while (!wasStopped()) {
requestStatus = service->requestStatus(grp_token);
if (requestStatus == RsTokenService::FAILED ||
requestStatus == RsTokenService::COMPLETE) {
break;
}
msleep(200);
}
if (requestStatus == RsTokenService::FAILED)
{
deleteLater();
return;
}
}
if (wasStopped())
{
#ifdef DEBUG_FORUMS
std::cerr << "GxsForumsFillThread::run() thread stopped, cancel request" << std::endl;
#endif
/* cancel request */
service->cancelRequest(msg_token);
service->cancelRequest(grp_token);
deleteLater();
return;
}
emit status(tr("Retrieving"));
std::vector<RsGxsForumGroup> forum_groups;
if (!rsGxsForums->getGroupData(grp_token, forum_groups) || forum_groups.size() != 1)
{
deleteLater();
return;
}
RsGxsForumGroup forum_group = *forum_groups.begin();
//#ifdef DEBUG_FORUMS
std::cerr << "Retrieved group data: " << std::endl;
std::cerr << " Group ID: " << forum_group.mMeta.mGroupId << std::endl;
std::cerr << " Admin lst: " << forum_group.mAdminList.ids.size() << " elements." << std::endl;
for(auto it(forum_group.mAdminList.ids.begin());it!=forum_group.mAdminList.ids.end();++it)
std::cerr << " " << *it << std::endl;
std::cerr << " Pinned Post: " << forum_group.mPinnedPosts.ids.size() << " messages." << std::endl;
for(auto it(forum_group.mPinnedPosts.ids.begin());it!=forum_group.mPinnedPosts.ids.end();++it)
std::cerr << " " << *it << std::endl;
//#endif
/* get messages */
std::map<RsGxsMessageId,RsGxsForumMsg> msgs;
{ // This forces to delete msgs_array after the conversion to std::map.
std::vector<RsGxsForumMsg> msgs_array;
if (!rsGxsForums->getMsgData(msg_token, msgs_array))
{
deleteLater();
return;
}
// now put everything into a map in order to make search log(n)
for(uint32_t i=0;i<msgs_array.size();++i)
{
#ifdef DEBUG_FORUMS
std::cerr << "Adding message " << msgs_array[i].mMeta.mMsgId << " with parent " << msgs_array[i].mMeta.mParentId << " to message map" << std::endl;
#endif
msgs[msgs_array[i].mMeta.mMsgId] = msgs_array[i] ;
}
}
emit status(tr("Loading"));
int count = msgs.size();
int pos = 0;
int steps = count / PROGRESSBAR_MAX;
int step = 0;
// ThreadList contains the list of parent threads. The algorithm below iterates through all messages
// and tries to establish parenthood relationships between them, given that we only know the
// immediate parent of a message and now its children. Some messages have a missing parent and for them
// a fake top level parent is generated.
// In order to be efficient, we first create a structure that lists the children of every mesage ID in the list.
// Then the hierarchy of message is build by attaching the kids to every message until all of them have been processed.
// The messages with missing parents will be the last ones remaining in the list.
std::list<std::pair< RsGxsMessageId, QTreeWidgetItem* > > threadStack;
std::map<RsGxsMessageId,std::list<RsGxsMessageId> > kids_array ;
std::set<RsGxsMessageId> missing_parents;
// First of all, remove all older versions of posts. This is done by first adding all posts into a hierarchy structure
// and then removing all posts which have a new versions available. The older versions are kept appart.
#ifdef DEBUG_FORUMS
std::cerr << "GxsForumsFillThread::run() Collecting post versions" << std::endl;
#endif
mPostVersions.clear();
std::list<RsGxsMessageId> msg_stack ;
for ( std::map<RsGxsMessageId,RsGxsForumMsg>::iterator msgIt = msgs.begin(); msgIt != msgs.end();++msgIt)
{
if(wasStopped())
{
deleteLater();
return;
}
if(!msgIt->second.mMeta.mOrigMsgId.isNull() && msgIt->second.mMeta.mOrigMsgId != msgIt->second.mMeta.mMsgId)
{
#ifdef DEBUG_FORUMS
std::cerr << " Post " << msgIt->second.mMeta.mMsgId << " is a new version of " << msgIt->second.mMeta.mOrigMsgId << std::endl;
#endif
std::map<RsGxsMessageId,RsGxsForumMsg>::iterator msgIt2 = msgs.find(msgIt->second.mMeta.mOrigMsgId);
// Ensuring that the post exists allows to only collect the existing data.
if(msgIt2 == msgs.end())
continue ;
// Make sure that the author is the same than the original message, or is a moderator. This should always happen when messages are constructed using
// the UI but nothing can prevent a nasty user to craft a new version of a message with his own signature.
if(msgIt2->second.mMeta.mAuthorId != msgIt->second.mMeta.mAuthorId)
{
if( !IS_FORUM_MSG_MODERATION(msgIt->second.mMeta.mMsgFlags) ) // if authors are different the moderation flag needs to be set on the editing msg
continue ;
if( forum_group.mAdminList.ids.find(msgIt->second.mMeta.mAuthorId)==forum_group.mAdminList.ids.end()) // if author is not a moderator, continue
continue ;
}
// always add the post a self version
if(mPostVersions[msgIt->second.mMeta.mOrigMsgId].empty())
mPostVersions[msgIt->second.mMeta.mOrigMsgId].push_back(QPair<time_t,RsGxsMessageId>(msgIt2->second.mMeta.mPublishTs,msgIt2->second.mMeta.mMsgId)) ;
mPostVersions[msgIt->second.mMeta.mOrigMsgId].push_back(QPair<time_t,RsGxsMessageId>(msgIt->second.mMeta.mPublishTs,msgIt->second.mMeta.mMsgId)) ;
}
}
// The following code assembles all new versions of a given post into the same array, indexed by the oldest version of the post.
for(QMap<RsGxsMessageId,QVector<QPair<time_t,RsGxsMessageId> > >::iterator it(mPostVersions.begin());it!=mPostVersions.end();++it)
{
if(wasStopped())
{
deleteLater();
return;
}
QVector<QPair<time_t,RsGxsMessageId> >& v(*it) ;
for(int32_t i=0;i<v.size();++i)
{
if(wasStopped())
{
deleteLater();
return;
}
if(v[i].second != it.key())
{
RsGxsMessageId sub_msg_id = v[i].second ;
QMap<RsGxsMessageId,QVector<QPair<time_t,RsGxsMessageId> > >::iterator it2 = mPostVersions.find(sub_msg_id);
if(it2 != mPostVersions.end())
{
for(int32_t j=0;j<(*it2).size();++j)
if((*it2)[j].second != sub_msg_id) // dont copy it, since it is already present at slot i
v.append((*it2)[j]) ;
mPostVersions.erase(it2) ; // it2 is never equal to it
}
}
}
}
// Now remove from msg ids, all posts except the most recent one. And make the mPostVersion be indexed by the most recent version of the post,
// which corresponds to the item in the tree widget.
#ifdef DEBUG_FORUMS
std::cerr << "Final post versions: " << std::endl;
#endif
QMap<RsGxsMessageId,QVector<QPair<time_t,RsGxsMessageId> > > mTmp;
std::map<RsGxsMessageId,RsGxsMessageId> most_recent_versions ;
for(QMap<RsGxsMessageId,QVector<QPair<time_t,RsGxsMessageId> > >::iterator it(mPostVersions.begin());it!=mPostVersions.end();++it)
{
#ifdef DEBUG_FORUMS
std::cerr << "Original post: " << it.key() << std::endl;
#endif
if(wasStopped())
{
deleteLater();
return;
}
// Finally, sort the posts from newer to older
qSort((*it).begin(),(*it).end(),decreasing_time_comp) ;
#ifdef DEBUG_FORUMS
std::cerr << " most recent version " << (*it)[0].first << " " << (*it)[0].second << std::endl;
#endif
for(int32_t i=1;i<(*it).size();++i)
{
if(wasStopped())
{
deleteLater();
return;
}
msgs.erase((*it)[i].second) ;
#ifdef DEBUG_FORUMS
std::cerr << " older version " << (*it)[i].first << " " << (*it)[i].second << std::endl;
#endif
}
mTmp[(*it)[0].second] = *it ; // index the versions map by the ID of the most recent post.
// Now make sure that message parents are consistent. Indeed, an old post may have the old version of a post as parent. So we need to change that parent
// to the newest version. So we create a map of which is the most recent version of each message, so that parent messages can be searched in it.
for(int i=1;i<(*it).size();++i)
{
if(wasStopped())
{
deleteLater();
return;
}
most_recent_versions[(*it)[i].second] = (*it)[0].second ;
}
}
mPostVersions = mTmp ;
// The next step is to find the top level thread messages. These are defined as the messages without
// any parent message ID.
// this trick is needed because while we remove messages, the parents a given msg may already have been removed
// and wrongly understand as a missing parent.
std::map<RsGxsMessageId,RsGxsForumMsg> kept_msgs;
for ( std::map<RsGxsMessageId,RsGxsForumMsg>::iterator msgIt = msgs.begin(); msgIt != msgs.end();++msgIt)
{
if (wasStopped())
{
deleteLater();
return;
}
if(mFlatView || msgIt->second.mMeta.mParentId.isNull())
{
/* add all threads */
if (wasStopped())
{
deleteLater();
return;
}
const RsGxsForumMsg& msg = msgIt->second;
#ifdef DEBUG_FORUMS
std::cerr << "GxsForumsFillThread::run() Adding TopLevel Thread: mId: " << msg.mMeta.mMsgId << std::endl;
#endif
QTreeWidgetItem *item = mParent->convertMsgToThreadWidget(msg, mUseChildTS, mFilterColumn,NULL);
if (!mFlatView)
threadStack.push_back(std::make_pair(msg.mMeta.mMsgId,item)) ;
calculateExpand(msg, item);
mItems.append(item);
if (++step >= steps) {
step = 0;
emit progress(++pos, PROGRESSBAR_MAX);
}
}
else
{
#ifdef DEBUG_FORUMS
std::cerr << "GxsForumsFillThread::run() Storing kid " << msgIt->first << " of message " << msgIt->second.mMeta.mParentId << std::endl;
#endif
// The same missing parent may appear multiple times, so we first store them into a unique container.
RsGxsMessageId parent_msg = msgIt->second.mMeta.mParentId;
if(msgs.find(parent_msg) == msgs.end())
{
// also check that the message is not versionned
std::map<RsGxsMessageId,RsGxsMessageId>::const_iterator mrit = most_recent_versions.find(parent_msg) ;
if(mrit != most_recent_versions.end())
parent_msg = mrit->second ;
else
missing_parents.insert(parent_msg);
}
kids_array[parent_msg].push_back(msgIt->first) ;
kept_msgs.insert(*msgIt) ;
}
}
msgs = kept_msgs;
// Also create a list of posts by time, when they are new versions of existing posts. Only the last one will have an item created.
// Add a fake toplevel item for the parent IDs that we dont actually have.
for(std::set<RsGxsMessageId>::const_iterator it(missing_parents.begin());it!=missing_parents.end();++it)
{
// add dummy parent item
QTreeWidgetItem *parent = mParent->generateMissingItem(*it);
mItems.append( parent );
threadStack.push_back(std::make_pair(*it,parent)) ;
}
#ifdef DEBUG_FORUMS
std::cerr << "GxsForumsFillThread::run() Processing stack:" << std::endl;
#endif
// Now use a stack to go down the hierarchy
while (!threadStack.empty())
{
if (wasStopped())
{
deleteLater();
return;
}
std::pair<RsGxsMessageId, QTreeWidgetItem*> threadPair = threadStack.front();
threadStack.pop_front();
std::map<RsGxsMessageId, std::list<RsGxsMessageId> >::iterator it = kids_array.find(threadPair.first) ;
#ifdef DEBUG_FORUMS
std::cerr << "GxsForumsFillThread::run() Node: " << threadPair.first << std::endl;
#endif
if(it == kids_array.end())
continue ;
for(std::list<RsGxsMessageId>::const_iterator it2(it->second.begin());it2!=it->second.end();++it2)
{
if(wasStopped())
{
deleteLater();
return;
}
// We iterate through the top level thread items, and look for which message has the current item as parent.
// When found, the item is put in the thread list itself, as a potential new parent.
std::map<RsGxsMessageId,RsGxsForumMsg>::iterator mit = msgs.find(*it2) ;
if(mit == msgs.end())
{
std::cerr << "GxsForumsFillThread::run() Cannot find submessage " << *it2 << " !!!" << std::endl;
continue ;
}
const RsGxsForumMsg& msg(mit->second) ;
#ifdef DEBUG_FORUMS
std::cerr << "GxsForumsFillThread::run() adding sub_item " << msg.mMeta.mMsgId << std::endl;
#endif
QTreeWidgetItem *item = mParent->convertMsgToThreadWidget(msg, mUseChildTS, mFilterColumn, threadPair.second);
calculateExpand(msg, item);
/* add item to process list */
threadStack.push_back(std::make_pair(msg.mMeta.mMsgId, item));
if (++step >= steps) {
step = 0;
emit progress(++pos, PROGRESSBAR_MAX);
}
msgs.erase(mit);
}
#ifdef DEBUG_FORUMS
std::cerr << "GxsForumsFillThread::run() Erasing entry " << it->first << " from kids tab." << std::endl;
#endif
kids_array.erase(it) ; // This is not strictly needed, but it improves performance by reducing the search space.
}
#ifdef DEBUG_FORUMS
std::cerr << "Kids array now has " << kids_array.size() << " elements" << std::endl;
for(std::map<RsGxsMessageId,std::list<RsGxsMessageId> >::const_iterator it(kids_array.begin());it!=kids_array.end();++it)
{
std::cerr << "Node " << it->first << std::endl;
for(std::list<RsGxsMessageId>::const_iterator it2(it->second.begin());it2!=it->second.end();++it2)
std::cerr << " " << *it2 << std::endl;
}
std::cerr << "GxsForumsFillThread::run() stopped: " << (wasStopped() ? "yes" : "no") << std::endl;
#endif
if(wasStopped())
deleteLater();
}
#endif

74
retroshare-gui/src/gui/gxsforums/GxsForumsFillThread.h
View File

@ -1,74 +0,0 @@
/*******************************************************************************
* retroshare-gui/src/gui/gxsforums/GxsForumsFillThread.h *
* *
* Copyright 2012 Retroshare Team <retroshare.project@gmail.com> *
* *
* 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/>. *
* *
*******************************************************************************/
#ifndef GXSFORUMSFILLTHREAD_H
#define GXSFORUMSFILLTHREAD_H
#include <QThread>
#include <QMap>
#include <QPair>
#include "retroshare/rsgxsifacetypes.h"
class GxsForumThreadWidget;
class RsGxsForumMsg;
class RSTreeWidgetItemCompareRole;
class QTreeWidgetItem;
#ifdef TO_REMOVE
class GxsForumsFillThread : public QThread
{
Q_OBJECT
public:
GxsForumsFillThread(GxsForumThreadWidget *parent);
~GxsForumsFillThread();
void run();
void stop();
bool wasStopped() { return mStopped; }
signals:
void progress(int current, int count);
void status(QString text);
public:
RsGxsGroupId mForumId;
int mFilterColumn;
bool mFillComplete;
int mViewType;
bool mFlatView;
bool mUseChildTS;
bool mExpandNewMessages;
std::string mFocusMsgId;
RSTreeWidgetItemCompareRole *mCompareRole;
QList<QTreeWidgetItem*> mItems;
QList<QTreeWidgetItem*> mItemToExpand;
QMap<RsGxsMessageId,QVector<QPair<time_t,RsGxsMessageId> > > mPostVersions ;
private:
void calculateExpand(const RsGxsForumMsg &msg, QTreeWidgetItem *item);
GxsForumThreadWidget *mParent;
volatile bool mStopped;
};
#endif // GXSFORUMSFILLTHREAD_H
#endif // GXSFORUMSFILLTHREAD_H

2
retroshare-gui/src/retroshare-gui.pro
View File

@ -1230,7 +1230,6 @@ gxsforums {
gui/gxsforums/GxsForumGroupDialog.h \
gui/gxsforums/CreateGxsForumMsg.h \
gui/gxsforums/GxsForumThreadWidget.h \
gui/gxsforums/GxsForumsFillThread.h \
gui/gxsforums/GxsForumModel.h \
gui/gxsforums/GxsForumUserNotify.h \
gui/feeds/GxsForumGroupItem.h \
@ -1246,7 +1245,6 @@ gxsforums {
gui/gxsforums/CreateGxsForumMsg.cpp \
gui/gxsforums/GxsForumThreadWidget.cpp \
gui/gxsforums/GxsForumModel.cpp \
gui/gxsforums/GxsForumsFillThread.cpp \
gui/gxsforums/GxsForumUserNotify.cpp \
gui/feeds/GxsForumGroupItem.cpp \
gui/feeds/GxsForumMsgItem.cpp