void TopJCDialog::on_lineEdit_returnPressed()
{
RsGxsId gxsid = RsGxsId(ui->lineEdit->text().toStdString());
ui->idLabel->setId(gxsid);
lookupGxsId(gxsid);
}
void ChatLobbyDialog::participantsTreeWidgetCustomPopupMenu(QPoint)
{
QList<QTreeWidgetItem*> selectedItems = ui.participantsList->selectedItems();
QMenu contextMnu(this);
contextMnu.addAction(distantChatAct);
contextMnu.addAction(sendMessageAct);
contextMnu.addSeparator();
contextMnu.addAction(muteAct);
contextMnu.addSeparator();
contextMnu.addAction(actionSortByActivity);
contextMnu.addAction(actionSortByName);
muteAct->setCheckable(true);
muteAct->setEnabled(false);
muteAct->setChecked(false);
if (selectedItems.size())
{
RsGxsId nickName;
rsMsgs->getIdentityForChatLobby(lobbyId, nickName);
if(selectedItems.count()>1 || (RsGxsId(selectedItems.at(0)->text(COLUMN_ID).toStdString())!=nickName))
{
muteAct->setEnabled(true);
QList<QTreeWidgetItem*>::iterator item;
for (item = selectedItems.begin(); item != selectedItems.end(); ++item) {
RsGxsId gxsid ;
if ( dynamic_cast<GxsIdRSTreeWidgetItem*>(*item)->getId(gxsid) && isParticipantMuted(gxsid))
{
muteAct->setChecked(true);
break;
}
}
}
distantChatAct->setEnabled(selectedItems.count()==1 && RsGxsId(selectedItems.front()->text(COLUMN_ID).toStdString())!=nickName) ;
}
contextMnu.exec(QCursor::pos());
}
void CreateGxsForumMsg::newMsg()
{
/* clear all */
mParentMsgLoaded = false;
mForumMetaLoaded = false;
/* fill in the available OwnIds for signing */
//std::cerr << "Initing ID chooser. Sign flags = " << std::hex << mForumMeta.mSignFlags << std::dec << std::endl;
ui.idChooser->loadIds(IDCHOOSER_ID_REQUIRED, RsGxsId());
if (mForumId.isNull()) {
mStateHelper->setActive(CREATEGXSFORUMMSG_FORUMINFO, false);
mStateHelper->setActive(CREATEGXSFORUMMSG_PARENTMSG, false);
mStateHelper->clear(CREATEGXSFORUMMSG_FORUMINFO);
mStateHelper->clear(CREATEGXSFORUMMSG_PARENTMSG);
ui.forumName->setText(tr("No Forum"));
return;
}//if ( mForumId.isNull())
{/* request Data */
mStateHelper->setLoading(CREATEGXSFORUMMSG_FORUMINFO, true);
RsTokReqOptions opts;
opts.mReqType = GXS_REQUEST_TYPE_GROUP_META;
std::list<RsGxsGroupId> groupIds;
groupIds.push_back(mForumId);
//std::cerr << "ForumsV2Dialog::newMsg() Requesting Group Summary(" << mForumId << ")"<< std::endl;
uint32_t token;
mForumQueue->requestGroupInfo(token, RS_TOKREQ_ANSTYPE_SUMMARY, opts, groupIds, CREATEGXSFORUMMSG_FORUMINFO);
}/* request Data */
if (mParentId.isNull()) {
mStateHelper->setActive(CREATEGXSFORUMMSG_PARENTMSG, true);
mParentMsgLoaded = true;
} else {
mStateHelper->setLoading(CREATEGXSFORUMMSG_PARENTMSG, true);
RsTokReqOptions opts;
opts.mReqType = GXS_REQUEST_TYPE_MSG_DATA;
GxsMsgReq msgIds;
std::vector<RsGxsMessageId> &vect = msgIds[mForumId];
vect.push_back(mParentId);
//std::cerr << "ForumsV2Dialog::newMsg() Requesting Parent Summary(" << mParentId << ")";
//std::cerr << std::endl;
uint32_t token;
mForumQueue->requestMsgInfo(token, RS_TOKREQ_ANSTYPE_DATA, opts, msgIds, CREATEGXSFORUMMSG_PARENTMSG);
}//if (mParentId.isNull())
}
void GxsIdChooser::indexActivated(int index)
{
int type = itemData(index, ROLE_TYPE).toInt();
if (type == TYPE_CREATE_ID) {
IdEditDialog dlg(this);
dlg.setupNewId(false, !(mFlags & IDCHOOSER_NON_ANONYMOUS));
if (dlg.exec() == QDialog::Accepted) {
setDefaultId(RsGxsId(dlg.groupId()));
}
}
}
void IdEditDialog::setAvatar(const QPixmap &avatar)
{
mAvatar = avatar;
if (!mAvatar.isNull()) {
ui->avatarLabel->setPixmap(mAvatar);
} else {
// we need to use the default pixmap here, generated from the ID
ui->avatarLabel->setPixmap(QPixmap::fromImage(GxsIdDetails::makeDefaultIcon(RsGxsId(mEditGroup.mMeta.mGroupId))));
}
}
GxsCreateCommentDialog::GxsCreateCommentDialog(TokenQueue *tokQ, RsGxsCommentService *service,
const RsGxsGrpMsgIdPair &parentId, const RsGxsMessageId& threadId, QWidget *parent) :
QDialog(parent),
ui(new Ui::GxsCreateCommentDialog), mTokenQueue(tokQ), mCommentService(service), mParentId(parentId), mThreadId(threadId)
{
ui->setupUi(this);
connect(ui->buttonBox, SIGNAL(accepted()), this, SLOT(createComment()));
connect(ui->buttonBox, SIGNAL(rejected()), this, SLOT(close()));
/* fill in the available OwnIds for signing */
ui->idChooser->loadIds(IDCHOOSER_ID_REQUIRED, RsGxsId());
}
/** Constructor */
PostedListWidget::PostedListWidget(const RsGxsGroupId &postedId, QWidget *parent)
: GxsMessageFramePostWidget(rsPosted, parent),
ui(new Ui::PostedListWidget)
{
/* Invoke the Qt Designer generated object setup routine */
ui->setupUi(this);
/* Setup UI helper */
mStateHelper->addWidget(mTokenTypeAllPosts, ui->hotSortButton);
mStateHelper->addWidget(mTokenTypeAllPosts, ui->newSortButton);
mStateHelper->addWidget(mTokenTypeAllPosts, ui->topSortButton);
mStateHelper->addWidget(mTokenTypePosts, ui->hotSortButton);
mStateHelper->addWidget(mTokenTypePosts, ui->newSortButton);
mStateHelper->addWidget(mTokenTypePosts, ui->topSortButton);
mStateHelper->addWidget(mTokenTypeGroupData, ui->submitPostButton);
mStateHelper->addWidget(mTokenTypeGroupData, ui->subscribeToolButton);
connect(ui->hotSortButton, SIGNAL(clicked()), this, SLOT(getRankings()));
connect(ui->newSortButton, SIGNAL(clicked()), this, SLOT(getRankings()));
connect(ui->topSortButton, SIGNAL(clicked()), this, SLOT(getRankings()));
connect(ui->nextButton, SIGNAL(clicked()), this, SLOT(showNext()));
connect(ui->prevButton, SIGNAL(clicked()), this, SLOT(showPrev()));
connect(ui->subscribeToolButton, SIGNAL(subscribe(bool)), this, SLOT(subscribeGroup(bool)));
// default sort method.
mSortMethod = RsPosted::HotRankType;
mLastSortMethod = RsPosted::TopRankType; // to be different.
mPostIndex = 0;
mPostShow = POSTED_DEFAULT_LISTING_LENGTH;
mTokenTypeVote = nextTokenType();
ui->hotSortButton->setChecked(true);
/* fill in the available OwnIds for signing */
ui->idChooser->loadIds(IDCHOOSER_ID_REQUIRED, RsGxsId());
connect(ui->submitPostButton, SIGNAL(clicked()), this, SLOT(newPost()));
/* load settings */
processSettings(true);
/* Initialize GUI */
setGroupId(postedId);
}
PostedCreatePostDialog::PostedCreatePostDialog(TokenQueue* tokenQ, RsPosted *posted, const RsGxsGroupId& grpId, QWidget *parent):
QDialog(parent, Qt::WindowSystemMenuHint | Qt::WindowTitleHint | Qt::WindowCloseButtonHint),
mTokenQueue(tokenQ), mPosted(posted), mGrpId(grpId),
ui(new Ui::PostedCreatePostDialog)
{
ui->setupUi(this);
Settings->loadWidgetInformation(this);
connect(ui->submitButton, SIGNAL(clicked()), this, SLOT(createPost()));
connect(ui->buttonBox, SIGNAL(rejected()), this, SLOT(close()));
ui->headerFrame->setHeaderImage(QPixmap(":/images/posted_64.png"));
ui->headerFrame->setHeaderText(tr("Submit a new Post"));
setAttribute ( Qt::WA_DeleteOnClose, true );
/* fill in the available OwnIds for signing */
ui->idChooser->loadIds(IDCHOOSER_ID_REQUIRED, RsGxsId());
}
void GxsGroupDialog::init()
{
// connect up the buttons.
connect(ui.buttonBox, SIGNAL(accepted()), this, SLOT(submitGroup()));
connect(ui.buttonBox, SIGNAL(rejected()), this, SLOT(cancelDialog()));
connect(ui.pubKeyShare_cb, SIGNAL(clicked()), this, SLOT(setShareList()));
connect(ui.groupLogo, SIGNAL(clicked() ), this , SLOT(addGroupLogo()));
connect(ui.addLogoButton, SIGNAL(clicked() ), this , SLOT(addGroupLogo()));
ui.typePublic->setChecked(true);
ui.distributionValueLabel->setText(tr("Public"));
updateCircleOptions();
connect(ui.typePublic, SIGNAL(clicked()), this , SLOT(updateCircleOptions()));
connect(ui.typeGroup, SIGNAL(clicked()), this , SLOT(updateCircleOptions()));
connect(ui.typeLocal, SIGNAL(clicked()), this , SLOT(updateCircleOptions()));
if (!ui.pubKeyShare_cb->isChecked())
{
ui.contactsdockWidget->hide();
this->resize(this->size().width() - ui.contactsdockWidget->size().width(), this->size().height());
}
/* initialize key share list */
ui.keyShareList->setHeaderText(tr("Contacts:"));
ui.keyShareList->setModus(FriendSelectionWidget::MODUS_CHECK);
ui.keyShareList->start();
/* Setup Reasonable Defaults */
ui.idChooser->loadIds(0,RsGxsId());
ui.circleComboBox->loadCircles(GXS_CIRCLE_CHOOSER_EXTERNAL, RsGxsCircleId());
ui.localComboBox->loadCircles(GXS_CIRCLE_CHOOSER_PERSONAL, RsGxsCircleId());
ui.groupDesc->setPlaceholderText(tr("Set a descriptive description here"));
ui.personal_ifnopub->hide() ;
ui.personal_required->hide() ;
ui.personal_required->setChecked(true) ; // this is always true
initMode();
}
void IdentityWidget::updateData(const RsGxsIdGroup &gxs_group_info)
{
//if (_group_info != gxs_group_info) {
_group_info = gxs_group_info;
_haveGXSId = true;
m_myName = QString::fromUtf8(_group_info.mMeta.mGroupName.c_str());
ui->labelName->setText(m_myName);
if (_havePGPDetail) {
ui->labelName->setToolTip(tr("GXS name:").append(" "+m_myName).append("\n")
.append(tr("PGP name:").append(" "+_nickname)));
} else {//if (m_myName != _nickname)
ui->labelName->setToolTip(tr("GXS name:").append(" "+m_myName));
}//else (m_myName != _nickname)
_gxsId = QString::fromStdString(_group_info.mMeta.mGroupId.toStdString());
ui->labelGXSId->setText(_gxsId);
ui->labelGXSId->setToolTip(tr("GXS id:").append(" "+_gxsId));
if (!_havePGPDetail) {
QFont font = ui->labelName->font();
font.setItalic(false);
ui->labelName->setFont(font);
_keyId=QString::fromStdString(_group_info.mMeta.mGroupId.toStdString());
ui->labelKeyId->setText(_keyId);
ui->labelKeyId->setToolTip(tr("GXS id:").append(" "+_keyId));
ui->labelKeyId->setVisible(false);
/// (TODO) Get real ident icon
QImage image = GxsIdDetails::makeDefaultIcon(RsGxsId(_group_info.mMeta.mGroupId));
if (_avatar != image) {
_avatar = image;
_scene->clear();
_scene->addPixmap(QPixmap::fromImage(image.scaled(ui->graphicsView->width(),ui->graphicsView->height())));
emit imageUpdated();
}//if (_avatar != image)
}//if (!_havePGPDetail)
//}//if (_group_info != gxs_group_info)
}
void IdDialog::chatIdentity()
{
QTreeWidgetItem *item = ui->idTreeWidget->currentItem();
if (!item)
{
std::cerr << "IdDialog::editIdentity() Invalid item";
std::cerr << std::endl;
return;
}
std::string keyId = item->text(RSID_COL_KEYID).toStdString();
QAction *action = qobject_cast<QAction *>(QObject::sender());
if (!action)
return ;
RsGxsId from_gxs_id(action->data().toString().toStdString());
uint32_t error_code ;
if(!rsMsgs->initiateDistantChatConnexion(RsGxsId(keyId), from_gxs_id, error_code))
QMessageBox::information(NULL, tr("Distant chat cannot work"), QString("%1 %2: %3").arg(tr("Distant chat refused with this person.")).arg(tr("Error code")).arg(error_code)) ;
}
void IdDialog::sendMsg()
{
QTreeWidgetItem *item = ui->idTreeWidget->currentItem();
if (!item)
{
return;
}
MessageComposer *nMsgDialog = MessageComposer::newMsg();
if (nMsgDialog == NULL) {
return;
}
std::string keyId = item->text(RSID_COL_KEYID).toStdString();
nMsgDialog->addRecipient(MessageComposer::TO, RsGxsId(keyId));
nMsgDialog->show();
nMsgDialog->activateWindow();
/* window will destroy itself! */
}
void ImHistoryBrowser::fillItem(QListWidgetItem *itemWidget, HistoryMsg& msg)
{
unsigned int formatTextFlag = RSHTML_FORMATTEXT_EMBED_LINKS;
if (embedSmileys) {
formatTextFlag |= RSHTML_FORMATTEXT_EMBED_SMILEYS;
}
ChatStyle::enumFormatMessage type;
if (msg.incoming) {
type = ChatStyle::FORMATMSG_INCOMING;
} else {
type = ChatStyle::FORMATMSG_OUTGOING;
}
QString messageText = RsHtml().formatText(NULL, QString::fromUtf8(msg.message.c_str()), formatTextFlag);
QString name;
if (m_chatId.isLobbyId() || m_chatId.isGxsId()) {
RsIdentityDetails details;
if (rsIdentity->getIdDetails(RsGxsId(msg.peerName), details))
name = QString::fromUtf8(details.mNickname.c_str());
else
name = QString::fromUtf8(msg.peerName.c_str());
} else {
name = QString::fromUtf8(msg.peerName.c_str());
}
QString formatMsg = style.formatMessage(type, name, QDateTime::fromTime_t(msg.sendTime), messageText);
itemWidget->setData(Qt::DisplayRole, qVariantFromValue(IMHistoryItemPainter(formatMsg)));
itemWidget->setData(ROLE_MSGID, msg.msgId);
/* calculate plain text */
QTextDocument doc;
doc.setHtml(messageText);
itemWidget->setData(ROLE_PLAINTEXT, doc.toPlainText());
}
void IdDetailsDialog::sendInvite()
{
/* create a message */
MessageComposer *composer = MessageComposer::newMsg();
composer->setTitleText(tr("You have a friend invite"));
RsPeerId ownId = rsPeers->getOwnId();
RetroShareLink link = RetroShareLink::createCertificate(ownId);
RsGxsId keyId(ui->lineEdit_KeyId->text().toStdString());
QString sMsgText = inviteMessage();
sMsgText += "<br><br>";
sMsgText += tr("Respond now:") + "<br>";
sMsgText += link.toHtml() + "<br>";
sMsgText += "<br>";
sMsgText += tr("Thanks, <br>") + QString::fromUtf8(rsPeers->getGPGName(rsPeers->getGPGOwnId()).c_str());
composer->setMsgText(sMsgText);
composer->addRecipient(MessageComposer::TO, RsGxsId(keyId));
composer->show();
}
GxsIdChooser::ChosenId_Ret GxsIdChooser::getChosenId(RsGxsId &gxsId)
{
if (count() < 1) {
return None;
}
int idx = currentIndex();
QVariant var = itemData(idx);
gxsId = RsGxsId(var.toString().toStdString());
QVariant type = itemData(idx, ROLE_TYPE);
switch (type.toInt()) {
case TYPE_NO_ID:
return NoId;
case TYPE_FOUND_ID:
return KnowId;
case TYPE_UNKNOWN_ID:
return UnKnowId;
case TYPE_CREATE_ID:
break;
}
return None;
}
bool IdDialog::fillIdListItem(const RsGxsIdGroup& data, QTreeWidgetItem *&item, const RsPgpId &ownPgpId, int accept)
{
bool isLinkedToOwnNode = (data.mPgpKnown && (data.mPgpId == ownPgpId)) ;
bool isOwnId = (data.mMeta.mSubscribeFlags & GXS_SERV::GROUP_SUBSCRIBE_ADMIN);
uint32_t item_flags = 0 ;
/* do filtering */
bool ok = false;
if (data.mMeta.mGroupFlags & RSGXSID_GROUPFLAG_REALID)
{
if (isLinkedToOwnNode && (accept & RSID_FILTER_YOURSELF))
{
ok = true;
item_flags |= RSID_FILTER_YOURSELF ;
}
if (data.mPgpKnown && (accept & RSID_FILTER_FRIENDS))
{
ok = true;
item_flags |= RSID_FILTER_FRIENDS ;
}
if (accept & RSID_FILTER_OTHERS)
{
ok = true;
item_flags |= RSID_FILTER_OTHERS ;
}
}
else if (accept & RSID_FILTER_PSEUDONYMS)
{
ok = true;
item_flags |= RSID_FILTER_PSEUDONYMS ;
}
if (isOwnId && (accept & RSID_FILTER_OWNED_BY_YOU))
{
ok = true;
item_flags |= RSID_FILTER_OWNED_BY_YOU ;
}
if (!ok)
return false;
if (!item)
item = new QTreeWidgetItem();
item->setText(RSID_COL_NICKNAME, QString::fromUtf8(data.mMeta.mGroupName.c_str()).left(RSID_MAXIMUM_NICKNAME_SIZE));
item->setText(RSID_COL_KEYID, QString::fromStdString(data.mMeta.mGroupId.toStdString()));
item->setData(RSID_COL_KEYID, Qt::UserRole,QVariant(item_flags)) ;
if(isOwnId)
{
QFont font = item->font(RSID_COL_NICKNAME) ;
font.setBold(true) ;
item->setFont(RSID_COL_NICKNAME,font) ;
item->setFont(RSID_COL_IDTYPE,font) ;
item->setFont(RSID_COL_KEYID,font) ;
QString tooltip = tr("This identity is owned by you");
item->setToolTip(RSID_COL_NICKNAME, tooltip) ;
item->setToolTip(RSID_COL_KEYID, tooltip) ;
item->setToolTip(RSID_COL_IDTYPE, tooltip) ;
}
#ifdef ID_DEBUG
std::cerr << "Setting item image : " << pixmap.width() << " x " << pixmap.height() << std::endl;
#endif
QPixmap pixmap ;
if(data.mImage.mSize == 0 || !pixmap.loadFromData(data.mImage.mData, data.mImage.mSize, "PNG"))
pixmap = QPixmap::fromImage(GxsIdDetails::makeDefaultIcon(RsGxsId(data.mMeta.mGroupId))) ;
item->setIcon(RSID_COL_NICKNAME, QIcon(pixmap));
QString tooltip;
if (data.mMeta.mGroupFlags & RSGXSID_GROUPFLAG_REALID)
{
if (data.mPgpKnown)
{
RsPeerDetails details;
rsPeers->getGPGDetails(data.mPgpId, details);
item->setText(RSID_COL_IDTYPE, QString::fromUtf8(details.name.c_str()));
item->setToolTip(RSID_COL_IDTYPE,QString::fromStdString(data.mPgpId.toStdString())) ;
tooltip += tr("Node name:")+" " + QString::fromUtf8(details.name.c_str()) + "\n";
tooltip += tr("Node Id :")+" " + QString::fromStdString(data.mPgpId.toStdString()) ;
item->setToolTip(RSID_COL_KEYID,tooltip) ;
}
else
{
item->setText(RSID_COL_IDTYPE, tr("Unknown PGP key"));
item->setToolTip(RSID_COL_IDTYPE,tr("Unknown key ID")) ;
item->setToolTip(RSID_COL_KEYID,tr("Unknown key ID")) ;
}
}
else
{
item->setText(RSID_COL_IDTYPE, QString()) ;
item->setToolTip(RSID_COL_IDTYPE,QString()) ;
}
return true;
}
void IdDetailsDialog::insertIdDetails(uint32_t token)
{
mStateHelper->setLoading(IDDETAILSDIALOG_IDDETAILS, false);
/* get details from libretroshare */
std::vector<RsGxsIdGroup> datavector;
if (!rsIdentity->getGroupData(token, datavector))
{
mStateHelper->setActive(IDDETAILSDIALOG_IDDETAILS, false);
mStateHelper->clear(IDDETAILSDIALOG_REPLIST);
ui->lineEdit_KeyId->setText("ERROR GETTING KEY!");
return;
}
if (datavector.size() != 1)
{
#ifdef ID_DEBUG
std::cerr << "IdDetailsDialog::insertIdDetails() Invalid datavector size";
#endif
mStateHelper->setActive(IDDETAILSDIALOG_IDDETAILS, false);
mStateHelper->clear(IDDETAILSDIALOG_IDDETAILS);
ui->lineEdit_KeyId->setText("INVALID DV SIZE");
return;
}
mStateHelper->setActive(IDDETAILSDIALOG_IDDETAILS, true);
RsGxsIdGroup &data = datavector[0];
/* get GPG Details from rsPeers */
RsPgpId ownPgpId = rsPeers->getGPGOwnId();
ui->lineEdit_Nickname->setText(QString::fromUtf8(data.mMeta.mGroupName.c_str()));
ui->lineEdit_KeyId->setText(QString::fromStdString(data.mMeta.mGroupId.toStdString()));
if(data.mPgpKnown)
ui->lineEdit_GpgId->setText(QString::fromStdString(data.mPgpId.toStdString()));
else
ui->lineEdit_GpgId->setText(QString::fromStdString(data.mPgpId.toStdString()) + tr(" [unverified]"));
ui->autoBanIdentities_CB->setVisible(!data.mPgpId.isNull()) ;
ui->banoption_label->setVisible(!data.mPgpId.isNull()) ;
time_t now = time(NULL) ;
ui->lineEdit_LastUsed->setText(getHumanReadableDuration(now - data.mLastUsageTS)) ;
QPixmap pixmap;
if(data.mImage.mSize > 0 && pixmap.loadFromData(data.mImage.mData, data.mImage.mSize, "PNG"))
ui->avatarLabel->setPixmap(pixmap) ;
else
{
pixmap = QPixmap::fromImage(GxsIdDetails::makeDefaultIcon(RsGxsId(data.mMeta.mGroupId)) ) ;
ui->avatarLabel->setPixmap(pixmap) ; // we need to use the default pixmap here, generated from the ID
}
#ifdef ID_DEBUG
std::cerr << "Setting header frame image : " << pix.width() << " x " << pix.height() << std::endl;
#endif
if (data.mPgpKnown)
{
RsPeerDetails details;
rsPeers->getGPGDetails(data.mPgpId, details);
ui->lineEdit_GpgName->setText(QString::fromUtf8(details.name.c_str()));
}
else
{
if(data.mMeta.mGroupFlags & RSGXSID_GROUPFLAG_REALID_kept_for_compatibility)
{
ui->lineEdit_GpgName->setText(tr("Unknown real name"));
}
else
{
ui->lineEdit_GpgName->setText(tr("Anonymous Id"));
}
}
if(data.mPgpId.isNull())
{
ui->lineEdit_GpgId->hide() ;
ui->lineEdit_GpgName->hide() ;
ui->PgpId_LB->hide() ;
ui->PgpName_LB->hide() ;
}
else
{
ui->lineEdit_GpgId->show() ;
ui->lineEdit_GpgName->show() ;
ui->PgpId_LB->show() ;
ui->PgpName_LB->show() ;
}
bool isOwnId = (data.mPgpKnown && (data.mPgpId == ownPgpId)) || (data.mMeta.mSubscribeFlags & GXS_SERV::GROUP_SUBSCRIBE_ADMIN);
if (isOwnId)
{
if (data.mPgpKnown)
ui->lineEdit_Type->setText(tr("Identity owned by you, linked to your Retroshare node")) ;
else
ui->lineEdit_Type->setText(tr("Anonymous identity, owned by you")) ;
}
else if (data.mMeta.mGroupFlags & RSGXSID_GROUPFLAG_REALID_kept_for_compatibility)
{
if(data.mPgpKnown)
if (rsPeers->isGPGAccepted(data.mPgpId))
ui->lineEdit_Type->setText(tr("Owned by a friend Retroshare node")) ;
else
ui->lineEdit_Type->setText(tr("Owned by 2-hops Retroshare node")) ;
else
ui->lineEdit_Type->setText(tr("Owned by unknown Retroshare node")) ;
}
else
ui->lineEdit_Type->setText(tr("Anonymous identity")) ;
if (isOwnId)
{
mStateHelper->setWidgetEnabled(ui->ownOpinion_CB, false);
}
else
{
// No Reputation yet!
mStateHelper->setWidgetEnabled(ui->ownOpinion_CB, true);
}
ui->autoBanIdentities_CB->setChecked(rsReputations->isNodeBanned(data.mPgpId));
/* now fill in the reputation information */
#ifdef SUSPENDED
if (data.mPgpKnown)
{
ui->line_RatingImplicit->setText(tr("+50 Known PGP"));
}
else if (data.mMeta.mGroupFlags & RSGXSID_GROUPFLAG_REALID)
{
ui->line_RatingImplicit->setText(tr("+10 UnKnown PGP"));
}
else
{
ui->line_RatingImplicit->setText(tr("+5 Anon Id"));
}
{
QString rating = QString::number(data.mReputation.mIdScore);
ui->line_RatingImplicit->setText(rating);
}
#endif
RsReputations::ReputationInfo info ;
rsReputations->getReputationInfo(RsGxsId(data.mMeta.mGroupId),data.mPgpId,info) ;
#warning (csoler) Do we need to do this? This code is apparently not used.
QString frep_string ;
if(info.mFriendsPositiveVotes > 0) frep_string += QString::number(info.mFriendsPositiveVotes) + tr(" positive ") ;
if(info.mFriendsNegativeVotes > 0) frep_string += QString::number(info.mFriendsNegativeVotes) + tr(" negative ") ;
if(info.mFriendsPositiveVotes==0 && info.mFriendsNegativeVotes==0)
frep_string = tr("No votes from friends") ;
ui->neighborNodesOpinion_TF->setText(frep_string) ;
ui->label_positive->setText(QString::number(info.mFriendsPositiveVotes));
ui->label_negative->setText(QString::number(info.mFriendsNegativeVotes));
switch(info.mOverallReputationLevel)
{
case RsReputations::REPUTATION_LOCALLY_POSITIVE: ui->overallOpinion_TF->setText(tr("Positive")) ; break ;
case RsReputations::REPUTATION_LOCALLY_NEGATIVE: ui->overallOpinion_TF->setText(tr("Negative (Banned by you)")) ; break ;
case RsReputations::REPUTATION_REMOTELY_POSITIVE: ui->overallOpinion_TF->setText(tr("Positive (according to your friends)")) ; break ;
case RsReputations::REPUTATION_REMOTELY_NEGATIVE: ui->overallOpinion_TF->setText(tr("Negative (according to your friends)")) ; break ;
default:
case RsReputations::REPUTATION_NEUTRAL: ui->overallOpinion_TF->setText(tr("Neutral")) ; break ;
}
switch(info.mOwnOpinion)
{
case RsReputations::OPINION_NEGATIVE: ui->ownOpinion_CB->setCurrentIndex(0); break ;
case RsReputations::OPINION_NEUTRAL : ui->ownOpinion_CB->setCurrentIndex(1); break ;
case RsReputations::OPINION_POSITIVE: ui->ownOpinion_CB->setCurrentIndex(2); break ;
default:
std::cerr << "Unexpected value in own opinion: " << info.mOwnOpinion << std::endl;
}
}
/**
* Regenerate the QTreeWidget participant list of a Chat Lobby
*
* Show yellow icon for muted Participants
*/
void ChatLobbyDialog::updateParticipantsList()
{
ChatLobbyInfo linfo;
if(rsMsgs->getChatLobbyInfo(lobbyId,linfo))
{
ChatLobbyInfo cliInfo=linfo;
QList<QTreeWidgetItem*> qlOldParticipants=ui.participantsList->findItems("*",Qt::MatchWildcard,COLUMN_ID);
foreach(QTreeWidgetItem *qtwiCur,qlOldParticipants)
if(cliInfo.gxs_ids.find(RsGxsId((*qtwiCur).text(COLUMN_ID).toStdString())) == cliInfo.gxs_ids.end())
{
//Old Participant go out, remove it
int index = ui.participantsList->indexOfTopLevelItem(qtwiCur);
delete ui.participantsList->takeTopLevelItem(index);
}
for (std::map<RsGxsId,time_t>::const_iterator it2(linfo.gxs_ids.begin()); it2 != linfo.gxs_ids.end(); ++it2)
{
QString participant = QString::fromUtf8( (it2->first).toStdString().c_str() );
QList<QTreeWidgetItem*> qlFoundParticipants=ui.participantsList->findItems(participant,Qt::MatchExactly,COLUMN_ID);
GxsIdRSTreeWidgetItem *widgetitem;
if (qlFoundParticipants.count()==0)
{
// TE: Add Wigdet to participantsList with Checkbox, to mute Participant
widgetitem = new GxsIdRSTreeWidgetItem(mParticipantCompareRole,GxsIdDetails::ICON_TYPE_AVATAR);
widgetitem->setId(it2->first,COLUMN_NAME, true) ;
//widgetitem->setText(COLUMN_NAME, participant);
// set activity time to the oast so that the peer is marked as inactive
widgetitem->setText(COLUMN_ACTIVITY,QString::number(time(NULL) - timeToInactivity));
widgetitem->setText(COLUMN_ID,QString::fromStdString(it2->first.toStdString()));
ui.participantsList->addTopLevelItem(widgetitem);
}
else
widgetitem = dynamic_cast<GxsIdRSTreeWidgetItem*>(qlFoundParticipants.at(0));
if (isParticipantMuted(it2->first)) {
widgetitem->setTextColor(COLUMN_NAME,QColor(255,0,0));
} else {
widgetitem->setTextColor(COLUMN_NAME,ui.participantsList->palette().color(QPalette::Active, QPalette::Text));
}
time_t tLastAct=widgetitem->text(COLUMN_ACTIVITY).toInt();
time_t now = time(NULL);
widgetitem->setSizeHint(COLUMN_ICON, QSize(20,20));
if(isParticipantMuted(it2->first))
widgetitem->setIcon(COLUMN_ICON, QIcon(":/icons/bullet_red_128.png"));
else if (tLastAct + timeToInactivity < now)
widgetitem->setIcon(COLUMN_ICON, QIcon(":/icons/bullet_grey_128.png"));
else
widgetitem->setIcon(COLUMN_ICON, QIcon(":/icons/bullet_green_128.png"));
RsGxsId gxs_id;
rsMsgs->getIdentityForChatLobby(lobbyId, gxs_id);
if (RsGxsId(participant.toStdString()) == gxs_id) widgetitem->setIcon(COLUMN_ICON, QIcon(":/icons/bullet_yellow_128.png"));
QTime qtLastAct=QTime(0,0,0).addSecs(now-tLastAct);
widgetitem->setToolTip(COLUMN_ICON,tr("Right click to mute/unmute participants<br/>Double click to address this person<br/>")
+tr("This participant is not active since:")
+qtLastAct.toString()
+tr(" seconds")
);
}
}
void IdDetailsDialog::insertIdDetails(uint32_t token)
{
mStateHelper->setLoading(IDDETAILSDIALOG_IDDETAILS, false);
/* get details from libretroshare */
std::vector<RsGxsIdGroup> datavector;
if (!rsIdentity->getGroupData(token, datavector))
{
mStateHelper->setActive(IDDETAILSDIALOG_IDDETAILS, false);
mStateHelper->clear(IDDETAILSDIALOG_REPLIST);
ui->lineEdit_KeyId->setText("ERROR GETTING KEY!");
return;
}
if (datavector.size() != 1)
{
#ifdef ID_DEBUG
std::cerr << "IdDetailsDialog::insertIdDetails() Invalid datavector size";
#endif
mStateHelper->setActive(IDDETAILSDIALOG_IDDETAILS, false);
mStateHelper->clear(IDDETAILSDIALOG_IDDETAILS);
ui->lineEdit_KeyId->setText("INVALID DV SIZE");
return;
}
mStateHelper->setActive(IDDETAILSDIALOG_IDDETAILS, true);
RsGxsIdGroup &data = datavector[0];
/* get GPG Details from rsPeers */
RsPgpId ownPgpId = rsPeers->getGPGOwnId();
ui->lineEdit_Nickname->setText(QString::fromUtf8(data.mMeta.mGroupName.c_str()));
ui->lineEdit_KeyId->setText(QString::fromStdString(data.mMeta.mGroupId.toStdString()));
//ui->lineEdit_GpgHash->setText(QString::fromStdString(data.mPgpIdHash.toStdString()));
ui->lineEdit_GpgId->setText(QString::fromStdString(data.mPgpId.toStdString()));
time_t now = time(NULL) ;
ui->lineEdit_LastUsed->setText(getHumanReadableDuration(now - data.mLastUsageTS)) ;
QPixmap pixmap;
if(data.mImage.mSize > 0 && pixmap.loadFromData(data.mImage.mData, data.mImage.mSize, "PNG"))
ui->avatarLabel->setPixmap(pixmap);
else
pixmap = QPixmap::fromImage(GxsIdDetails::makeDefaultIcon(RsGxsId(data.mMeta.mGroupId))) ;
ui->avatarLabel->setPixmap(pixmap); // we need to use the default pixmap here, generated from the ID
#ifdef ID_DEBUG
std::cerr << "Setting header frame image : " << pix.width() << " x " << pix.height() << std::endl;
#endif
if (data.mPgpKnown)
{
RsPeerDetails details;
rsPeers->getGPGDetails(data.mPgpId, details);
ui->lineEdit_GpgName->setText(QString::fromUtf8(details.name.c_str()));
}
else
{
if (data.mMeta.mGroupFlags & RSGXSID_GROUPFLAG_REALID)
{
ui->lineEdit_GpgName->setText(tr("Unknown real name"));
}
else
{
ui->lineEdit_GpgName->setText(tr("Anonymous Id"));
}
}
if(data.mPgpId.isNull())
{
ui->lineEdit_GpgId->hide() ;
ui->lineEdit_GpgName->hide() ;
ui->PgpId_LB->hide() ;
ui->PgpName_LB->hide() ;
}
else
{
ui->lineEdit_GpgId->show() ;
ui->lineEdit_GpgName->show() ;
ui->PgpId_LB->show() ;
ui->PgpName_LB->show() ;
}
bool isOwnId = (data.mPgpKnown && (data.mPgpId == ownPgpId)) || (data.mMeta.mSubscribeFlags & GXS_SERV::GROUP_SUBSCRIBE_ADMIN);
if (isOwnId)
if (data.mPgpKnown)
ui->lineEdit_Type->setText(tr("Identity owned by you, linked to your Retroshare node")) ;
else
ui->lineEdit_Type->setText(tr("Anonymous identity, owned by you")) ;
else if (data.mMeta.mGroupFlags & RSGXSID_GROUPFLAG_REALID)
{
if (data.mPgpKnown)
if (rsPeers->isGPGAccepted(data.mPgpId))
ui->lineEdit_Type->setText(tr("Owned by a friend Retroshare node")) ;
else
ui->lineEdit_Type->setText(tr("Owned by 2-hops Retroshare node")) ;
else
ui->lineEdit_Type->setText(tr("Owned by unknown Retroshare node")) ;
}
else
ui->lineEdit_Type->setText(tr("Anonymous identity")) ;
if (isOwnId)
{
mStateHelper->setWidgetEnabled(ui->ownOpinion_CB, false);
}
else
{
// No Reputation yet!
mStateHelper->setWidgetEnabled(ui->ownOpinion_CB, true);
}
/* now fill in the reputation information */
#ifdef SUSPENDED
if (data.mPgpKnown)
{
ui->line_RatingImplicit->setText(tr("+50 Known PGP"));
}
else if (data.mMeta.mGroupFlags & RSGXSID_GROUPFLAG_REALID)
{
ui->line_RatingImplicit->setText(tr("+10 UnKnown PGP"));
}
else
{
ui->line_RatingImplicit->setText(tr("+5 Anon Id"));
}
{
QString rating = QString::number(data.mReputation.mIdScore);
ui->line_RatingImplicit->setText(rating);
}
#endif
RsReputations::ReputationInfo info ;
rsReputations->getReputationInfo(RsGxsId(data.mMeta.mGroupId),data.mPgpId,info) ;
ui->neighborNodesOpinion_TF->setText(QString::number(info.mOverallReputationScore-1.0f));
ui->overallOpinion_TF->setText(QString::number(info.mOverallReputationScore-1.0f) +" ("+
((info.mAssessment == RsReputations::ASSESSMENT_OK)? tr("OK") : tr("Banned")) +")" ) ;
switch(info.mOwnOpinion)
{
case RsReputations::OPINION_NEGATIVE: ui->ownOpinion_CB->setCurrentIndex(0); break ;
case RsReputations::OPINION_NEUTRAL : ui->ownOpinion_CB->setCurrentIndex(1); break ;
case RsReputations::OPINION_POSITIVE: ui->ownOpinion_CB->setCurrentIndex(2); break ;
default:
std::cerr << "Unexpected value in own opinion: " << info.mOwnOpinion << std::endl;
}
}
void CreateCircleDialog::loadIdentities(uint32_t token)
{
#ifdef DEBUG_CREATE_CIRCLE_DIALOG
std::cerr << "CreateCircleDialog::loadIdentities(" << token << ")";
std::cerr << std::endl;
#endif
QTreeWidget *tree = ui.treeWidget_IdList;
tree->clear();
bool acceptAnonymous = ui.radioButton_ListAll->isChecked();
bool acceptAllPGP = ui.radioButton_ListAllPGP->isChecked();
//bool acceptKnownPGP = ui.radioButton_ListKnownPGP->isChecked();
RsGxsIdGroup data;
std::vector<RsGxsIdGroup> datavector;
std::vector<RsGxsIdGroup>::iterator vit;
if (!rsIdentity->getGroupData(token, datavector)) {
std::cerr << "CreateCircleDialog::insertIdentities() Error getting GroupData";
std::cerr << std::endl;
return;
}
for(vit = datavector.begin(); vit != datavector.end(); ++vit)
{
data = (*vit);
/* do filtering */
bool ok = false;
if (acceptAnonymous)
ok = true;
else if (acceptAllPGP)
ok = data.mMeta.mGroupFlags & RSGXSID_GROUPFLAG_REALID ;
else if (data.mPgpKnown)
ok = data.mMeta.mGroupFlags & RSGXSID_GROUPFLAG_REALID ;
if (!ok) {
#ifdef DEBUG_CREATE_CIRCLE_DIALOG
std::cerr << "CreateCircleDialog::insertIdentities() Skipping ID: " << data.mMeta.mGroupId;
std::cerr << std::endl;
#endif
continue;
}
QString keyId = QString::fromStdString(data.mMeta.mGroupId.toStdString());
QString nickname = QString::fromUtf8(data.mMeta.mGroupName.c_str());
QString idtype = tr("Anon Id");
QPixmap pixmap ;
if(data.mImage.mSize == 0 || !pixmap.loadFromData(data.mImage.mData, data.mImage.mSize, "PNG"))
pixmap = QPixmap::fromImage(GxsIdDetails::makeDefaultIcon(RsGxsId(data.mMeta.mGroupId))) ;
if (data.mMeta.mGroupFlags & RSGXSID_GROUPFLAG_REALID)
{
if (data.mPgpKnown) {
RsPeerDetails details;
rsPeers->getGPGDetails(data.mPgpId, details);
idtype = QString::fromUtf8(details.name.c_str());
}
else
idtype = tr("PGP Linked Id");
}
QTreeWidgetItem *item = new QTreeWidgetItem();
item->setText(RSCIRCLEID_COL_NICKNAME, nickname);
item->setIcon(RSCIRCLEID_COL_NICKNAME, QIcon(pixmap));
item->setText(RSCIRCLEID_COL_KEYID, keyId);
item->setText(RSCIRCLEID_COL_IDTYPE, idtype);
tree->addTopLevelItem(item);
// External Circle.
if (mIsExistingCircle)
{
// check if its in the circle.
// We use an explicit cast
//
if ( mCircleGroup.mInvitedMembers.find(RsGxsId(data.mMeta.mGroupId)) != mCircleGroup.mInvitedMembers.end()) /* found it */
addMember(keyId, idtype, nickname);
}
}
}
void ChatHandler::tick()
{
RS_STACK_MUTEX(mMtx); /********** LOCKED **********/
// first fetch lobbies
std::vector<Lobby> lobbies;
std::list<ChatLobbyId> subscribed_ids;
mRsMsgs->getChatLobbyList(subscribed_ids);
for(std::list<ChatLobbyId>::iterator lit = subscribed_ids.begin(); lit != subscribed_ids.end(); ++lit)
{
ChatLobbyInfo info;
if(mRsMsgs->getChatLobbyInfo(*lit,info))
{
Lobby l;
l.id = *lit;
l.name = info.lobby_name;
l.topic = info.lobby_topic;
l.subscribed = true;
l.auto_subscribe = info.lobby_flags & RS_CHAT_LOBBY_FLAGS_AUTO_SUBSCRIBE;
l.is_private = !(info.lobby_flags & RS_CHAT_LOBBY_FLAGS_PUBLIC);
l.is_broadcast = false;
l.gxs_id = info.gxs_id;
lobbies.push_back(l);
}
}
ChatId id = ChatId::makeBroadcastId();
{
Lobby l;
l.id = id.toLobbyId();
l.name = "BroadCast";
l.topic = "Retroshare broadcast chat: messages are sent to all connected friends.";
l.subscribed = true;
l.auto_subscribe = false;
l.is_private = false;
l.is_broadcast = true;
l.gxs_id = id.toGxsId();
lobbies.push_back(l);
}
std::vector<VisibleChatLobbyRecord> unsubscribed_lobbies;
mRsMsgs->getListOfNearbyChatLobbies(unsubscribed_lobbies);
for(std::vector<VisibleChatLobbyRecord>::iterator vit = unsubscribed_lobbies.begin(); vit != unsubscribed_lobbies.end(); ++vit)
{
const VisibleChatLobbyRecord& info = *vit;
if(std::find(subscribed_ids.begin(), subscribed_ids.end(), info.lobby_id) == subscribed_ids.end())
{
Lobby l;
l.id = info.lobby_id;
l.name = info.lobby_name;
l.topic = info.lobby_topic;
l.subscribed = false;
l.auto_subscribe = info.lobby_flags & RS_CHAT_LOBBY_FLAGS_AUTO_SUBSCRIBE;
l.is_private = !(info.lobby_flags & RS_CHAT_LOBBY_FLAGS_PUBLIC);
l.is_broadcast = false;
l.gxs_id = RsGxsId();
lobbies.push_back(l);
}
}
// process new messages
bool changed = false;
bool lobby_unread_count_changed = false;
std::vector<std::list<ChatMessage>::iterator> done;
std::vector<RsPeerId> peers_changed;
bool gxs_id_failed = false; // to prevent asking for multiple failing gxs ids in one tick, to not flush the cache
for(std::list<ChatMessage>::iterator lit = mRawMsgs.begin(); lit != mRawMsgs.end(); ++lit)
{
ChatMessage& msg = *lit;
std::string author_id;
std::string author_name;
if(msg.chat_id.isBroadcast())
{
author_id = msg.broadcast_peer_id.toStdString();
author_name = mRsPeers->getPeerName(msg.broadcast_peer_id);
}
else if(msg.chat_id.isGxsId())
{
author_id = msg.chat_id.toGxsId().toStdString();
RsIdentityDetails details;
if(!gxs_id_failed && mRsIdentity->getIdDetails(msg.chat_id.toGxsId(), details))
{
author_name = details.mNickname;
}
else
{
gxs_id_failed = true;
continue;
}
}
else if(msg.chat_id.isLobbyId())
{
author_id = msg.lobby_peer_gxs_id.toStdString();
RsIdentityDetails details;
if(!gxs_id_failed && mRsIdentity->getIdDetails(msg.lobby_peer_gxs_id, details))
{
author_name = details.mNickname;
lobby_unread_count_changed = true;
}
else
{
gxs_id_failed = true;
continue;
}
}
else if(msg.chat_id.isPeerId())
{
RsPeerId id;
if(msg.incoming)
id = msg.chat_id.toPeerId();
else
id = mRsPeers->getOwnId();
author_id = id.toStdString();
author_name = mRsPeers->getPeerName(id);
if(std::find(peers_changed.begin(), peers_changed.end(), msg.chat_id.toPeerId()) == peers_changed.end())
peers_changed.push_back(msg.chat_id.toPeerId());
}
else
{
std::cerr << "Error in ChatHandler::tick(): unhandled chat_id=" << msg.chat_id.toStdString() << std::endl;
// remove from queue, so msgs with wrong ids to not pile up
done.push_back(lit);
continue;
}
if(mChatInfo.find(msg.chat_id) == mChatInfo.end())
{
ChatInfo info;
info.is_broadcast = msg.chat_id.isBroadcast();
info.is_gxs_id = msg.chat_id.isGxsId();
info.is_lobby = msg.chat_id.isLobbyId();
info.is_peer = msg.chat_id.isPeerId();
if(msg.chat_id.isLobbyId())
{
for(std::vector<Lobby>::iterator vit = mLobbies.begin(); vit != mLobbies.end(); ++vit)
{
if(vit->id == msg.chat_id.toLobbyId())
info.remote_author_name = vit->name;
}
}
else if(msg.chat_id.isGxsId())
{
RsIdentityDetails details;
if(!gxs_id_failed && mRsIdentity->getIdDetails(msg.chat_id.toGxsId(), details))
{
info.remote_author_id = msg.chat_id.toGxsId().toStdString();
info.remote_author_name = details.mNickname;
}
else
{
gxs_id_failed = true;
continue;
}
}
else if(msg.chat_id.isPeerId())
{
info.remote_author_id = msg.chat_id.toPeerId().toStdString();
info.remote_author_name = mRsPeers->getPeerName(msg.chat_id.toPeerId());
}
mChatInfo[msg.chat_id] = info;
}
Msg m;
m.read = !msg.incoming;
m.incoming = msg.incoming;
m.was_send = msg.online;
m.author_id = author_id;
m.author_name = author_name;
// remove html tags from chat message
// extract links form href
getPlainText(msg.msg, m.msg, m.links);
m.recv_time = msg.recvTime;
m.send_time = msg.sendTime;
m.id = RSRandom::random_u32();
mMsgs[msg.chat_id].push_back(m);
done.push_back(lit);
changed = true;
}
for(std::vector<std::list<ChatMessage>::iterator>::iterator vit = done.begin(); vit != done.end(); ++vit)
mRawMsgs.erase(*vit);
// send changes
if(changed)
{
mStateTokenServer->replaceToken(mMsgStateToken);
mStateTokenServer->replaceToken(mUnreadMsgsStateToken);
}
for(std::vector<RsPeerId>::iterator vit = peers_changed.begin(); vit != peers_changed.end(); ++vit)
{
const std::list<Msg>& msgs = mMsgs[ChatId(*vit)];
uint32_t count = 0;
for(std::list<Msg>::const_iterator lit = msgs.begin(); lit != msgs.end(); ++lit)
if(!lit->read)
count++;
if(mUnreadMsgNotify)
mUnreadMsgNotify->notifyUnreadMsgCountChanged(*vit, count);
}
std::sort(lobbies.begin(), lobbies.end(), &compare_lobby_id);
if(lobby_unread_count_changed || mLobbies != lobbies)
{
mStateTokenServer->replaceToken(mLobbiesStateToken);
mLobbies = lobbies;
}
}
void IdDialog::insertIdDetails(uint32_t token)
{
mStateHelper->setLoading(IDDIALOG_IDDETAILS, false);
/* get details from libretroshare */
RsGxsIdGroup data;
std::vector<RsGxsIdGroup> datavector;
if (!rsIdentity->getGroupData(token, datavector))
{
mStateHelper->setActive(IDDIALOG_IDDETAILS, false);
mStateHelper->clear(IDDIALOG_REPLIST);
ui->lineEdit_KeyId->setText("ERROR GETTING KEY!");
return;
}
if (datavector.size() != 1)
{
#ifdef ID_DEBUG
std::cerr << "IdDialog::insertIdDetails() Invalid datavector size";
#endif
mStateHelper->setActive(IDDIALOG_IDDETAILS, false);
mStateHelper->clear(IDDIALOG_IDDETAILS);
ui->lineEdit_KeyId->setText("INVALID DV SIZE");
return;
}
mStateHelper->setActive(IDDIALOG_IDDETAILS, true);
data = datavector[0];
/* get GPG Details from rsPeers */
RsPgpId ownPgpId = rsPeers->getGPGOwnId();
ui->lineEdit_Nickname->setText(QString::fromUtf8(data.mMeta.mGroupName.c_str()).left(RSID_MAXIMUM_NICKNAME_SIZE));
ui->lineEdit_KeyId->setText(QString::fromStdString(data.mMeta.mGroupId.toStdString()));
//ui->lineEdit_GpgHash->setText(QString::fromStdString(data.mPgpIdHash.toStdString()));
ui->lineEdit_GpgId->setText(QString::fromStdString(data.mPgpId.toStdString()));
time_t now = time(NULL) ;
ui->lineEdit_LastUsed->setText(getHumanReadableDuration(now - data.mLastUsageTS)) ;
ui->headerTextLabel->setText(QString::fromUtf8(data.mMeta.mGroupName.c_str()).left(RSID_MAXIMUM_NICKNAME_SIZE));
QPixmap pixmap ;
if(data.mImage.mSize == 0 || !pixmap.loadFromData(data.mImage.mData, data.mImage.mSize, "PNG"))
pixmap = QPixmap::fromImage(GxsIdDetails::makeDefaultIcon(RsGxsId(data.mMeta.mGroupId))) ;
#ifdef ID_DEBUG
std::cerr << "Setting header frame image : " << pix.width() << " x " << pix.height() << std::endl;
#endif
ui->avlabel->setPixmap(pixmap);
ui->avatarLabel->setPixmap(pixmap);
if (data.mPgpKnown)
{
RsPeerDetails details;
rsPeers->getGPGDetails(data.mPgpId, details);
ui->lineEdit_GpgName->setText(QString::fromUtf8(details.name.c_str()));
}
else
{
if (data.mMeta.mGroupFlags & RSGXSID_GROUPFLAG_REALID)
{
ui->lineEdit_GpgName->setText(tr("Unknown real name"));
}
else
{
ui->lineEdit_GpgName->setText(tr("Anonymous Id"));
}
}
if(data.mPgpId.isNull())
{
ui->lineEdit_GpgId->hide() ;
ui->lineEdit_GpgName->hide() ;
ui->PgpId_LB->hide() ;
ui->PgpName_LB->hide() ;
}
else
{
ui->lineEdit_GpgId->show() ;
ui->lineEdit_GpgName->show() ;
ui->PgpId_LB->show() ;
ui->PgpName_LB->show() ;
}
bool isLinkedToOwnPgpId = (data.mPgpKnown && (data.mPgpId == ownPgpId)) ;
bool isOwnId = (data.mMeta.mSubscribeFlags & GXS_SERV::GROUP_SUBSCRIBE_ADMIN);
if(isOwnId)
if (isLinkedToOwnPgpId)
ui->lineEdit_Type->setText(tr("Identity owned by you, linked to your Retroshare node")) ;
else
ui->lineEdit_Type->setText(tr("Anonymous identity, owned by you")) ;
else if (data.mMeta.mGroupFlags & RSGXSID_GROUPFLAG_REALID)
{
if (data.mPgpKnown)
if (rsPeers->isGPGAccepted(data.mPgpId))
ui->lineEdit_Type->setText(tr("Linked to a friend Retroshare node")) ;
else
ui->lineEdit_Type->setText(tr("Linked to a known Retroshare node")) ;
else
ui->lineEdit_Type->setText(tr("Linked to unknown Retroshare node")) ;
}
else
ui->lineEdit_Type->setText(tr("Anonymous identity")) ;
// if (isOwnId)
// {
// ui->radioButton_IdYourself->setChecked(true);
// }
// else if (data.mMeta.mGroupFlags & RSGXSID_GROUPFLAG_REALID)
// {
// if (data.mPgpKnown)
// {
// if (rsPeers->isGPGAccepted(data.mPgpId))
// {
// ui->radioButton_IdFriend->setChecked(true);
// }
// else
// {
// ui->radioButton_IdFOF->setChecked(true);
// }
// }
// else
// {
// ui->radioButton_IdOther->setChecked(true);
// }
// }
// else
// {
// ui->radioButton_IdPseudo->setChecked(true);
// }
if (isOwnId)
{
mStateHelper->setWidgetEnabled(ui->toolButton_Reputation, false);
ui->editIdentity->setEnabled(true);
ui->removeIdentity->setEnabled(true);
ui->chatIdentity->setEnabled(false);
ui->messageButton->setEnabled(false);
}
else
{
// No Reputation yet!
mStateHelper->setWidgetEnabled(ui->toolButton_Reputation, /*true*/ false);
ui->editIdentity->setEnabled(false);
ui->removeIdentity->setEnabled(false);
ui->chatIdentity->setEnabled(true);
ui->messageButton->setEnabled(true);
}
/* now fill in the reputation information */
ui->line_RatingOverall->setText("Overall Rating TODO");
ui->line_RatingOwn->setText("Own Rating TODO");
if (data.mPgpKnown)
{
ui->line_RatingImplicit->setText(tr("+50 Known PGP"));
}
else if (data.mMeta.mGroupFlags & RSGXSID_GROUPFLAG_REALID)
{
ui->line_RatingImplicit->setText(tr("+10 UnKnown PGP"));
}
else
{
ui->line_RatingImplicit->setText(tr("+5 Anon Id"));
}
{
QString rating = QString::number(data.mReputation.mOverallScore);
ui->line_RatingOverall->setText(rating);
}
{
QString rating = QString::number(data.mReputation.mIdScore);
ui->line_RatingImplicit->setText(rating);
}
{
QString rating = QString::number(data.mReputation.mOwnOpinion);
ui->line_RatingOwn->setText(rating);
}
{
QString rating = QString::number(data.mReputation.mPeerOpinion);
ui->line_RatingPeers->setText(rating);
}
}
void GxsIdChooser::loadPrivateIds()
{
if (mFirstLoad) {
clear();
}
std::list<RsGxsId> ids;
rsIdentity->getOwnIds(ids);
//rsIdentity->getDefaultId(defId);
// Prefer to use an application specific default???
if (mFirstLoad) {
if (!(mFlags & IDCHOOSER_ID_REQUIRED)) {
/* add No Signature option */
QString str = tr("No Signature");
QString id = "";
addItem(str, id);
setItemData(count() - 1, QString("%1_%2").arg(TYPE_NO_ID).arg(str), ROLE_SORT);
setItemData(count() - 1, TYPE_NO_ID, ROLE_TYPE);
}
} else {
for (int idx = 0; idx < count(); ++idx) {
QVariant type = itemData(idx, ROLE_TYPE);
switch (type.toInt()) {
case TYPE_NO_ID:
case TYPE_CREATE_ID:
break;
case TYPE_FOUND_ID:
case TYPE_UNKNOWN_ID:
{
QVariant var = itemData(idx);
RsGxsId gxsId = RsGxsId(var.toString().toStdString());
std::list<RsGxsId>::iterator lit = std::find(ids.begin(), ids.end(), gxsId);
if (lit == ids.end()) {
removeItem(idx);
idx--;
}
}
}
}
}
for (std::list<RsGxsId>::iterator it = ids.begin(); it != ids.end(); ++it) {
GxsIdDetails::process(*it, loadPrivateIdsCallback, this); /* add to Chooser */
}
if (mFirstLoad) {
if (!(mFlags & IDCHOOSER_NO_CREATE)) {
/* add Create Identity option */
QString str = tr("Create new Identity");
QString id = "";
addItem(QIcon(":/images/identity/identity_create_32.png"), str, id);
setItemData(count() - 1, QString("%1_%2").arg(TYPE_CREATE_ID).arg(str), ROLE_SORT);
setItemData(count() - 1, TYPE_CREATE_ID, ROLE_TYPE);
}
setDefaultItem();
emit idsLoaded();
}
mFirstLoad = false;
}
void p3Fido::sendMail( const char * filename )
{
std::ifstream mailfile( filename, std::ifstream::in );
if( !mailfile.good() ){
std::cerr << "Fido: Cannot open mail file " << filename << std::endl;
return;
}
MessageInfo mi;
mimetic::MimeEntity me( mailfile );
std::string msgId = me.header().messageid().str();
std::map< std::string, int >::iterator msgIt = m_sentMsgs.find( msgId );
if( msgIt != m_sentMsgs.end() ){ // we had this message already
(*msgIt).second--;
if( (*msgIt).second == 1 ){
m_sentMsgs.erase( msgIt );
}
return;
}
std::list< std::string > unknownMailboxes;
int numAddr = 0;
mimetic::AddressList & toList = me.header().to();
for( mimetic::AddressList::const_iterator it = toList.begin(); it != toList.end(); it++ ){
mimetic::Mailbox mailbox = (*it).mailbox();
if( mailbox.domain() != MAILDOMAIN )
continue;
numAddr++;
std::string rsAddr = mailbox.mailbox();
RsGxsId gxsid( rsAddr );
RsIdentityDetails detail;
if(!rsIdentity->getIdDetails(gxsid, detail)){
mi.rsgxsid_msgto.push_back( RsGxsId( gxsid ) );
}
else{
unknownMailboxes.push_back( mailbox.str() );
}
}
mimetic::AddressList & ccList = me.header().cc();
for( mimetic::AddressList::const_iterator it = ccList.begin(); it != ccList.end(); it++ ){
mimetic::Mailbox mailbox = (*it).mailbox();
if( mailbox.domain() != MAILDOMAIN )
continue;
numAddr++;
std::string rsAddr = mailbox.mailbox();
RsGxsId gxsid( rsAddr );
RsIdentityDetails detail;
if(!rsIdentity->getIdDetails(gxsid, detail)){
mi.rsgxsid_msgcc.push_back( gxsid );
}
else{
unknownMailboxes.push_back( mailbox.str() );
}
}
m_sentMsgs[ msgId ] = numAddr;
mi.title = me.header().subject();
std::string bodyText;
mimetic::ContentType contentType = me.header().contentType();
if( contentType.type() == "text" && contentType.subtype() == "plain" ){
bodyText = me.body().data();
}
else{
mimetic::MimeEntityList& parts = me.body().parts();
mimetic::MimeEntityList::iterator mbit = parts.begin();
if( mbit != parts.end() ){
mimetic::MimeEntity * pme = *mbit;
bodyText = pme->body().data();
}
}
mi.msg = bodyText;
RsGxsId mygxsid( MY_GXSID );
mi.rsgxsid_srcId = mygxsid;
mi.msgflags = 0;
mi.msgId = msgId;
if( !mi.rsgxsid_msgcc.empty() || !mi.rsgxsid_msgto.empty() ){
rsMsgs->MessageSend(mi);
}
if( !unknownMailboxes.empty() )
bounceMail( unknownMailboxes, mi );
}
