1
0
forked from blue/squawk
squawk/ui/models/roster.cpp

1098 lines
39 KiB
C++
Raw Normal View History

/*
* Squawk messenger.
* Copyright (C) 2019 Yury Gubich <blue@macaw.me>
*
* 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 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "roster.h"
2019-04-03 21:23:51 +00:00
#include <QDebug>
#include <QIcon>
2019-04-05 15:12:59 +00:00
#include <QFont>
2023-08-15 15:28:25 +00:00
#include "shared/defines.h"
Models::Roster::Roster(QObject* parent):
QAbstractItemModel(parent),
2019-04-03 18:15:36 +00:00
accountsModel(new Accounts()),
root(new Item(Item::root, {{"name", "root"}})),
accounts(),
2019-04-03 21:23:51 +00:00
groups(),
contacts()
{
connect(accountsModel, &Accounts::dataChanged, this, &Roster::onAccountDataChanged);
connect(root, &Item::childChanged, this, &Roster::onChildChanged);
connect(root, &Item::childIsAboutToBeInserted, this, &Roster::onChildIsAboutToBeInserted);
connect(root, &Item::childInserted, this, &Roster::onChildInserted);
connect(root, &Item::childIsAboutToBeRemoved, this, &Roster::onChildIsAboutToBeRemoved);
connect(root, &Item::childRemoved, this, &Roster::onChildRemoved);
connect(root, &Item::childIsAboutToBeMoved, this, &Roster::onChildIsAboutToBeMoved);
connect(root, &Item::childMoved, this, &Roster::onChildMoved);
}
2023-08-15 15:28:25 +00:00
Models::Roster::~Roster() {
2019-04-03 18:15:36 +00:00
delete accountsModel;
delete root;
}
2023-08-15 15:28:25 +00:00
void Models::Roster::addAccount(const QMap<QString, QVariant>& data) {
2019-04-07 14:02:41 +00:00
Account* acc = new Account(data);
connect(acc, &Account::reconnected, this, &Roster::onAccountReconnected);
root->appendChild(acc);
2019-04-03 15:09:29 +00:00
accounts.insert(std::make_pair(acc->getName(), acc));
2019-04-03 18:15:36 +00:00
accountsModel->addAccount(acc);
emit addedElement({acc->getId()});
}
2023-08-15 15:28:25 +00:00
QVariant Models::Roster::data (const QModelIndex& index, int role) const {
if (!index.isValid())
return QVariant();
QVariant result;
Item *item = static_cast<Item*>(index.internalPointer());
2023-08-15 15:28:25 +00:00
if (item->type == Item::reference)
2020-04-17 23:17:47 +00:00
item = static_cast<Reference*>(item)->dereference();
2023-08-15 15:28:25 +00:00
switch (role) {
2023-08-15 15:28:25 +00:00
case Qt::DisplayRole: {
if (index.column() != 0)
break;
2023-08-15 15:28:25 +00:00
switch (item->type) {
case Item::group: {
Group* gr = static_cast<Group*>(item);
QString str("");
str += gr->getName();
unsigned int amount = gr->getUnreadMessages();
2023-08-15 15:28:25 +00:00
if (amount > 0)
str += QString(" (") + tr("New messages") + ")";
2023-08-15 15:28:25 +00:00
result = str;
}
break;
default:
result = item->data(index.column());
break;
}
}
break;
case Qt::DecorationRole:
switch (item->type) {
case Item::account: {
quint8 col = index.column();
2019-04-03 18:15:36 +00:00
Account* acc = static_cast<Account*>(item);
if (col == 0) {
result = acc->getStatusIcon(false);
} else if (col == 1) {
QString path = acc->getAvatarPath();
2023-08-15 15:28:25 +00:00
if (path.size() > 0)
result = QIcon(path);
}
}
break;
case Item::contact: {
2019-04-05 15:12:59 +00:00
Contact* contact = static_cast<Contact*>(item);
quint8 col = index.column();
if (col == 0) {
result = contact->getStatusIcon(false);
} else if (col == 1) {
2023-08-15 15:28:25 +00:00
if (contact->getAvatarState() != Shared::Avatar::empty)
result = QIcon(contact->getAvatarPath());
}
2019-04-07 14:02:41 +00:00
}
break;
case Item::presence: {
2023-08-15 15:28:25 +00:00
if (index.column() != 0)
break;
2023-08-15 15:28:25 +00:00
2019-04-07 14:02:41 +00:00
Presence* presence = static_cast<Presence*>(item);
result = presence->getStatusIcon(false);
2019-04-05 15:12:59 +00:00
}
break;
case Item::room: {
2019-12-17 16:54:53 +00:00
quint8 col = index.column();
Room* room = static_cast<Room*>(item);
2019-12-17 16:54:53 +00:00
if (col == 0) {
result = room->getStatusIcon(false);
} else if (col == 1) {
QString path = room->getAvatarPath();
2023-08-15 15:28:25 +00:00
if (path.size() > 0)
2019-12-17 16:54:53 +00:00
result = QIcon(path);
}
}
break;
case Item::participant: {
2019-12-30 20:22:04 +00:00
quint8 col = index.column();
Participant* p = static_cast<Participant*>(item);
if (col == 0) {
result = p->getStatusIcon(false);
} else if (col == 1) {
QString path = p->getAvatarPath();
2023-08-15 15:28:25 +00:00
if (path.size() > 0)
2019-12-30 20:22:04 +00:00
result = QIcon(path);
}
2023-08-15 15:28:25 +00:00
if (index.column() != 0)
break;
}
break;
default:
break;
}
break;
2019-04-05 15:12:59 +00:00
case Qt::FontRole:
switch (item->type) {
case Item::account:{
QFont font;
font.setBold(true);
result = font;
}
break;
case Item::group:{
QFont font;
font.setItalic(true);
result = font;
}
break;
default:
break;
}
break;
case Qt::ToolTipRole:
switch (item->type) {
case Item::account: {
Account* acc = static_cast<Account*>(item);
result = Shared::Global::getName(acc->getAvailability());
}
break;
case Item::contact: {
Contact* contact = static_cast<Contact*>(item);
QString str("");
int mc = contact->getMessagesCount();
2023-08-15 15:28:25 +00:00
if (mc > 0)
str += QString(tr("New messages: ")) + std::to_string(mc).c_str() + "\n";
2023-08-15 15:28:25 +00:00
str += tr("Jabber ID: ") + contact->getJid() + "\n";
Shared::SubscriptionState ss = contact->getState();
if (ss == Shared::SubscriptionState::both || ss == Shared::SubscriptionState::to) {
Shared::Availability av = contact->getAvailability();
str += tr("Availability: ") + Shared::Global::getName(av);
if (av != Shared::Availability::offline) {
QString s = contact->getStatus();
2023-08-15 15:28:25 +00:00
if (s.size() > 0)
str += "\n" + tr("Status: ") + s;
}
str += "\n" + tr("Subscription: ") + Shared::Global::getName(ss);
} else {
str += tr("Subscription: ") + Shared::Global::getName(ss);
}
result = str;
}
break;
case Item::presence: {
Presence* contact = static_cast<Presence*>(item);
QString str;
Shared::Availability av = contact->getAvailability();
str += tr("Availability: ") + Shared::Global::getName(av);
QString s = contact->getStatus();
2023-08-15 15:28:25 +00:00
if (s.size() > 0)
str += "\n" + tr("Status: ") + s;
2023-08-15 15:28:25 +00:00
str += "\n" + tr("Client: ") + contact->getClientNode();
result = str;
}
break;
case Item::participant: {
Participant* p = static_cast<Participant*>(item);
QString str;
Shared::Availability av = p->getAvailability();
str += tr("Availability: ") + Shared::Global::getName(av) + "\n";
QString s = p->getStatus();
2023-08-15 15:28:25 +00:00
if (s.size() > 0)
str += tr("Status: ") + s + "\n";
str += tr("Affiliation: ") + Shared::Global::getName(p->getAffiliation()) + "\n";
str += tr("Role: ") + Shared::Global::getName(p->getRole()) + "\n";
str += tr("Client: ") + p->getClientNode();
result = str;
}
break;
case Item::group: {
Group* gr = static_cast<Group*>(item);
unsigned int count = gr->getUnreadMessages();
QString str("");
2023-08-15 15:28:25 +00:00
if (count > 0)
str += tr("New messages: ") + std::to_string(count).c_str() + "\n";
2023-08-15 15:28:25 +00:00
str += tr("Online contacts: ") + std::to_string(gr->getOnlineContacts()).c_str() + "\n";
str += tr("Total contacts: ") + std::to_string(gr->childCount()).c_str();
result = str;
}
break;
case Item::room: {
Room* rm = static_cast<Room*>(item);
unsigned int count = rm->getMessagesCount();
QString str("");
2023-08-15 15:28:25 +00:00
if (count > 0)
str += tr("New messages: ") + std::to_string(count).c_str() + "\n";
2019-12-17 16:54:53 +00:00
str += tr("Jabber ID: ") + rm->getJid() + "\n";
str += tr("Subscription: ") + rm->getStatusText();
2023-08-15 15:28:25 +00:00
if (rm->getJoined())
str += QString("\n") + tr("Members: ") + std::to_string(rm->childCount()).c_str();
2023-08-15 15:28:25 +00:00
result = str;
}
break;
default:
result = "";
break;
}
break;
case Qt::ForegroundRole:
switch (item->type) {
case Item::account: {
Account* acc = static_cast<Account*>(item);
2023-08-15 15:28:25 +00:00
if (!acc->getActive())
result = qApp->palette().brush(QPalette::Disabled, QPalette::Text);
}
break;
default:
break;
}
default:
break;
}
return result;
}
2023-08-15 15:28:25 +00:00
int Models::Roster::columnCount (const QModelIndex& parent) const {
if (parent.isValid())
return static_cast<Item*>(parent.internalPointer())->columnCount();
2023-08-15 15:28:25 +00:00
else
return root->columnCount();
}
2023-08-15 15:28:25 +00:00
void Models::Roster::updateAccount(const QString& account, const QString& field, const QVariant& value) {
std::map<QString, Account*>::iterator itr = accounts.find(account);
if (itr != accounts.end()) {
Account* acc = itr->second;
2019-04-03 18:15:36 +00:00
acc->update(field, value);
}
}
2023-08-15 15:28:25 +00:00
Qt::ItemFlags Models::Roster::flags(const QModelIndex& index) const {
if (!index.isValid())
2020-07-29 20:26:56 +00:00
return Qt::ItemFlags();
return QAbstractItemModel::flags(index);
}
2023-08-15 15:28:25 +00:00
int Models::Roster::rowCount (const QModelIndex& parent) const{
Item *parentItem;
2023-08-15 15:28:25 +00:00
if (!parent.isValid())
parentItem = root;
2023-08-15 15:28:25 +00:00
else
parentItem = static_cast<Item*>(parent.internalPointer());
return parentItem->childCount();
}
2023-08-15 15:28:25 +00:00
QVariant Models::Roster::headerData(int section, Qt::Orientation orientation, int role) const {
SHARED_UNUSED(section);
SHARED_UNUSED(orientation);
SHARED_UNUSED(role);
return QVariant();
}
2023-08-15 15:28:25 +00:00
QModelIndex Models::Roster::parent (const QModelIndex& child) const {
if (!child.isValid())
return QModelIndex();
Item *childItem = static_cast<Item*>(child.internalPointer());
2023-08-15 15:28:25 +00:00
if (childItem == root)
return QModelIndex();
Item *parentItem = childItem->parentItem();
2023-08-15 15:28:25 +00:00
if (parentItem == root)
2019-05-30 09:36:21 +00:00
return createIndex(0, 0, parentItem);
return createIndex(parentItem->row(), 0, parentItem);
}
2023-08-15 15:28:25 +00:00
QModelIndex Models::Roster::index (int row, int column, const QModelIndex& parent) const {
if (!hasIndex(row, column, parent))
return QModelIndex();
Item *parentItem;
2023-08-15 15:28:25 +00:00
if (!parent.isValid())
parentItem = root;
2023-08-15 15:28:25 +00:00
else
parentItem = static_cast<Item*>(parent.internalPointer());
Item *childItem = parentItem->child(row);
2023-08-15 15:28:25 +00:00
if (childItem)
return createIndex(row, column, childItem);
2023-08-15 15:28:25 +00:00
else
return QModelIndex();
}
Models::Roster::ElId::ElId(const QString& p_account, const QString& p_name):
account(p_account),
name(p_name)
2019-04-03 18:15:36 +00:00
{}
2023-08-15 15:28:25 +00:00
bool Models::Roster::ElId::operator <(const Models::Roster::ElId& other) const {
if (account == other.account)
return name < other.name;
2023-08-15 15:28:25 +00:00
else
return account < other.account;
}
2023-08-15 15:28:25 +00:00
bool Models::Roster::ElId::operator!=(const Models::Roster::ElId& other) const {
2020-04-11 20:00:15 +00:00
return !(operator == (other));
}
2023-08-15 15:28:25 +00:00
bool Models::Roster::ElId::operator==(const Models::Roster::ElId& other) const {
2020-04-11 20:00:15 +00:00
return (account == other.account) && (name == other.name);
}
2023-08-15 15:28:25 +00:00
void Models::Roster::onAccountDataChanged(const QModelIndex& tl, const QModelIndex& br, const QVector<int>& roles) {
2019-04-03 18:15:36 +00:00
if (tl.column() == 0) {
emit dataChanged(tl, br, roles);
} else if (tl.column() == 2) {
int row = tl.row();
Account* acc = accountsModel->getAccount(row);
emit dataChanged(createIndex(row, 0, acc), createIndex(br.row(), 0, acc), roles);
}
}
2023-08-15 15:28:25 +00:00
void Models::Roster::addGroup(const QString& account, const QString& name) {
2019-04-05 15:12:59 +00:00
ElId id(account, name);
std::map<ElId, Group*>::const_iterator gItr = groups.find(id);
2019-04-05 15:12:59 +00:00
if (gItr != groups.end()) {
qDebug() << "An attempt to add group " << name << " to account " << account <<" which already exists there, skipping";
return;
}
2019-04-03 21:23:51 +00:00
std::map<QString, Account*>::iterator itr = accounts.find(account);
if (itr != accounts.end()) {
Account* acc = itr->second;
Group* group = new Group({{"name", name}});
2019-04-05 15:12:59 +00:00
groups.insert(std::make_pair(id, group));
acc->appendChild(group);
emit addedElement({acc->getId(), group->getId()});
2019-04-03 21:23:51 +00:00
} else {
qDebug() << "An attempt to add group " << name << " to non existing account " << account << ", skipping";
}
}
2023-08-15 15:28:25 +00:00
void Models::Roster::addContact(const QString& account, const QString& jid, const QString& group, const QMap<QString, QVariant>& data) {
2019-04-03 21:23:51 +00:00
Item* parent;
2019-04-05 15:12:59 +00:00
Account* acc;
2020-04-17 23:17:47 +00:00
Contact* contact;
Reference* ref = 0;
2019-04-05 15:12:59 +00:00
ElId id(account, jid);
{
2019-04-03 21:23:51 +00:00
std::map<QString, Account*>::iterator itr = accounts.find(account);
if (itr == accounts.end()) {
qDebug() << "An attempt to add a contact" << jid << "to non existing account" << account << ", skipping";
2019-04-03 21:23:51 +00:00
return;
}
2019-04-05 15:12:59 +00:00
acc = itr->second;
}
2020-04-17 23:17:47 +00:00
{
std::map<ElId, Contact*>::iterator itr = contacts.find(id);
if (itr == contacts.end()) {
contact = new Contact(acc, jid, data);
connect(contact, &Contact::requestArchive, this, &Roster::onElementRequestArchive);
connect(contact, &Contact::fileDownloadRequest, this, &Roster::fileDownloadRequest);
connect(contact, &Contact::unnoticedMessage, this, &Roster::unnoticedMessage);
connect(contact, &Contact::localPathInvalid, this, &Roster::localPathInvalid);
connect(contact, &Contact::unreadMessagesCountChanged, this, &Roster::recalculateUnreadMessages);
2020-04-17 23:17:47 +00:00
contacts.insert(std::make_pair(id, contact));
} else {
contact = itr->second;
}
}
std::list<QString> path = {acc->getId()};
2020-04-17 23:17:47 +00:00
if (group == "") {
if (acc->getContact(jid) != -1) {
qDebug() << "An attempt to add a contact" << jid << "to the ungrouped contact set of account" << account << "for the second time, skipping";
return;
} else {
parent = acc;
2019-04-05 15:12:59 +00:00
}
2019-04-03 21:23:51 +00:00
} else {
std::map<ElId, Group*>::iterator itr = groups.find({account, group});
2019-04-03 21:23:51 +00:00
if (itr == groups.end()) {
qDebug() << "An attempt to add a contact" << jid << "to non existing group" << group << ", adding group";
addGroup(account, group);
itr = groups.find({account, group});
2019-04-03 21:23:51 +00:00
}
2019-04-05 15:12:59 +00:00
2019-04-03 21:23:51 +00:00
parent = itr->second;
path.push_back(parent->getId());
2019-04-05 15:12:59 +00:00
2020-04-17 23:17:47 +00:00
if (parent->getContact(jid) != -1) {
qDebug() << "An attempt to add a contact" << jid << "to the group" << group << "for the second time, skipping";
return;
2019-04-05 15:12:59 +00:00
}
2020-04-17 23:17:47 +00:00
int refIndex = acc->getContact(jid);
if (refIndex != -1) { //checking if that contact is among ugrouped
qDebug() << "An attempt to add a already existing contact " << jid
<< " to the group " << group
<< ", contact will be moved from ungrouped contacts of " << account;
ref = static_cast<Reference*>(acc->child(refIndex));
acc->removeChild(refIndex);
2019-04-05 15:12:59 +00:00
}
2019-04-03 21:23:51 +00:00
}
path.push_back(contact->getId());
2020-04-17 23:17:47 +00:00
2023-08-15 15:28:25 +00:00
if (ref == 0)
2020-04-17 23:17:47 +00:00
ref = new Reference(contact);
2023-08-15 15:28:25 +00:00
2020-04-17 23:17:47 +00:00
parent->appendChild(ref);
emit addedElement(path);
2019-04-03 21:23:51 +00:00
}
2023-08-15 15:28:25 +00:00
void Models::Roster::removeGroup(const QString& account, const QString& name) {
2019-04-05 15:12:59 +00:00
ElId id(account, name);
std::map<ElId, Group*>::const_iterator gItr = groups.find(id);
2019-04-05 15:12:59 +00:00
if (gItr == groups.end()) {
qDebug() << "An attempt to remove group " << name << " from account " << account <<" which doesn't exist there, skipping";
return;
}
Group* item = gItr->second;
2019-04-05 15:12:59 +00:00
Item* parent = item->parentItem();
int row = item->row();
parent->removeChild(row);
2020-04-17 23:17:47 +00:00
std::deque<Reference*> toInsert;
2019-04-05 15:12:59 +00:00
for (int i = 0; item->childCount() > 0; ++i) {
2020-04-17 23:17:47 +00:00
Reference* ref = static_cast<Reference*>(item->child(0));
2019-04-05 15:12:59 +00:00
item->removeChild(0);
2020-04-17 23:17:47 +00:00
Contact* cont = static_cast<Contact*>(ref->dereference());
2023-08-15 15:28:25 +00:00
if (cont->referencesCount() == 1)
2020-04-17 23:17:47 +00:00
toInsert.push_back(ref);
2023-08-15 15:28:25 +00:00
else
2020-04-17 23:17:47 +00:00
delete ref;
2019-04-05 15:12:59 +00:00
}
if (toInsert.size() > 0) {
Account* acc = accounts.find("account")->second;
for (std::deque<Contact*>::size_type i = 0; i < toInsert.size(); ++i) {
2020-04-17 23:17:47 +00:00
acc->appendChild(toInsert[i]); //TODO optimisation
2019-04-05 15:12:59 +00:00
}
}
item->deleteLater();
groups.erase(gItr);
2019-04-03 21:23:51 +00:00
}
2023-08-15 15:28:25 +00:00
void Models::Roster::changeContact(const QString& account, const QString& jid, const QMap<QString, QVariant>& data) {
Element* el = getElement(ElId(account, jid));
if (el != nullptr) {
for (QMap<QString, QVariant>::const_iterator itr = data.begin(), end = data.end(); itr != end; ++itr) {
el->update(itr.key(), itr.value());
}
}
}
2023-08-15 15:28:25 +00:00
void Models::Roster::changeMessage(const QString& account, const QString& jid, const QString& id, const QMap<QString, QVariant>& data) {
Element* el = getElement(ElId(account, jid));
2023-08-15 15:28:25 +00:00
if (el != nullptr)
el->changeMessage(id, data);
2023-08-15 15:28:25 +00:00
else
qDebug() << "A request to change a message of the contact " << jid << " in the account " << account << " but it wasn't found";
2019-04-06 10:14:32 +00:00
}
2023-08-15 15:28:25 +00:00
void Models::Roster::removeContact(const QString& account, const QString& jid) {
2019-04-06 10:14:32 +00:00
ElId id(account, jid);
2020-04-17 23:17:47 +00:00
std::map<ElId, Contact*>::iterator itr = contacts.find(id);
if (itr != contacts.end()) {
Contact* contact = itr->second;
contacts.erase(itr);
delete contact;
std::set<ElId> toRemove;
for (std::pair<ElId, Group*> pair : groups) {
2023-08-15 15:28:25 +00:00
if (pair.second->childCount() == 0)
2020-04-17 23:17:47 +00:00
toRemove.insert(pair.first);
2019-04-06 10:14:32 +00:00
}
2019-04-07 14:02:41 +00:00
2023-08-15 15:28:25 +00:00
for (const ElId& elId : toRemove)
2020-04-17 23:17:47 +00:00
removeGroup(elId.account, elId.name);
} else {
qDebug() << "An attempt to remove contact " << jid << " from account " << account <<" which doesn't exist there, skipping";
2019-04-06 10:14:32 +00:00
}
}
2023-08-15 15:28:25 +00:00
void Models::Roster::removeContact(const QString& account, const QString& jid, const QString& group) {
2019-04-06 10:14:32 +00:00
ElId contactId(account, jid);
ElId groupId(account, group);
2020-04-17 23:17:47 +00:00
std::map<ElId, Contact*>::iterator cItr = contacts.find(contactId);
if (cItr == contacts.end()) {
qDebug() << "An attempt to remove non existing contact " << jid << " from group " << group << " of account " << account <<", skipping";
return;
}
std::map<ElId, Group*>::iterator gItr = groups.find(groupId);
2019-04-06 10:14:32 +00:00
if (gItr == groups.end()) {
qDebug() << "An attempt to remove contact " << jid << " from non existing group " << group << " of account " << account <<", skipping";
return;
}
Account* acc = accounts.find(account)->second; //I assume the account is found, otherwise there will be no groups with that ElId;
Group* gr = gItr->second;
2020-04-17 23:17:47 +00:00
Contact* cont = cItr->second;
int contRow = gr->getContact(jid);
if (contRow == -1) {
qDebug() << "An attempt to remove contact " << jid << " of account " << account << " from group " << group <<", but there is no such contact in that group, skipping";
return;
2019-04-06 10:14:32 +00:00
}
2020-04-17 23:17:47 +00:00
Reference* ref = static_cast<Reference*>(gr->child(contRow));
gr->removeChild(contRow);
2019-04-06 10:14:32 +00:00
2020-04-17 23:17:47 +00:00
if (cont->referencesCount() == 1) {
qDebug() << "An attempt to remove last instance of contact" << jid << "from the group" << group << ", contact will be moved to ungrouped contacts of" << account;
2020-04-17 23:17:47 +00:00
acc->appendChild(ref);
} else {
2020-04-17 23:17:47 +00:00
delete ref;
}
2023-08-15 15:28:25 +00:00
if (gr->childCount() == 0)
2020-04-17 23:17:47 +00:00
removeGroup(account, group);
2019-04-06 10:14:32 +00:00
}
2019-04-07 14:02:41 +00:00
2023-08-15 15:28:25 +00:00
void Models::Roster::onChildChanged(Models::Item* item, int row, int col) {
SHARED_UNUSED(col);
QModelIndex index = createIndex(row, 0, item);
QModelIndex index2 = createIndex(row, 1, item);
emit dataChanged(index, index2);
2019-04-07 14:02:41 +00:00
}
2023-08-15 15:28:25 +00:00
void Models::Roster::onChildIsAboutToBeInserted(Models::Item* parent, int first, int last) {
2019-04-07 14:02:41 +00:00
int row = 0;
if (parent != root) {
row = parent->row();
beginInsertRows(createIndex(row, 0, parent), first, last);
} else {
beginInsertRows(QModelIndex(), first, last);
}
}
2023-08-15 15:28:25 +00:00
void Models::Roster::onChildIsAboutToBeMoved(Models::Item* source, int first, int last, Models::Item* destination, int newIndex) {
2019-04-07 14:02:41 +00:00
int oldRow = 0;
2023-08-15 15:28:25 +00:00
if (source != root)
2019-04-07 14:02:41 +00:00
oldRow = source->row();
2023-08-15 15:28:25 +00:00
2019-04-07 14:02:41 +00:00
int newRow = 0;
2023-08-15 15:28:25 +00:00
if (destination != root)
2019-04-07 14:02:41 +00:00
newRow = destination->row();
2023-08-15 15:28:25 +00:00
2019-04-07 14:02:41 +00:00
beginMoveRows(createIndex(oldRow, 0, source), first, last, createIndex(newRow, 0, destination), newIndex);
}
2023-08-15 15:28:25 +00:00
void Models::Roster::onChildIsAboutToBeRemoved(Models::Item* parent, int first, int last) {
2019-04-07 14:02:41 +00:00
int row = 0;
2023-08-15 15:28:25 +00:00
if (parent != root)
2019-04-07 14:02:41 +00:00
row = parent->row();
2023-08-15 15:28:25 +00:00
2019-04-07 14:02:41 +00:00
beginRemoveRows(createIndex(row, 0, parent), first, last);
}
2023-08-15 15:28:25 +00:00
void Models::Roster::onChildInserted() {
2019-04-07 14:02:41 +00:00
endInsertRows();
}
2023-08-15 15:28:25 +00:00
void Models::Roster::onChildMoved() {
2019-04-07 14:02:41 +00:00
endMoveRows();
}
2023-08-15 15:28:25 +00:00
void Models::Roster::onChildRemoved() {
2019-04-07 14:02:41 +00:00
endRemoveRows();
}
2023-08-15 15:28:25 +00:00
void Models::Roster::addPresence(const QString& account, const QString& jid, const QString& name, const QMap<QString, QVariant>& data) {
2019-04-07 14:02:41 +00:00
ElId contactId(account, jid);
2020-04-17 23:17:47 +00:00
std::map<ElId, Contact*>::iterator itr = contacts.find(contactId);
if (itr != contacts.end()) {
itr->second->addPresence(name, data);
2019-04-07 14:02:41 +00:00
}
2019-04-07 14:02:41 +00:00
}
2023-08-15 15:28:25 +00:00
void Models::Roster::removePresence(const QString& account, const QString& jid, const QString& name) {
2019-04-07 14:02:41 +00:00
ElId contactId(account, jid);
2020-04-17 23:17:47 +00:00
std::map<ElId, Contact*>::iterator itr = contacts.find(contactId);
if (itr != contacts.end()) {
itr->second->removePresence(name);
2019-04-07 14:02:41 +00:00
}
}
2019-04-09 22:01:25 +00:00
2023-08-15 15:28:25 +00:00
void Models::Roster::addMessage(const QString& account, const Shared::Message& data) {
Element* el = getElement(ElId(account, data.getPenPalJid()));
2023-08-15 15:28:25 +00:00
if (el != nullptr)
el->addMessage(data);
2019-04-09 22:01:25 +00:00
}
2023-08-15 15:28:25 +00:00
void Models::Roster::removeAccount(const QString& account) {
2019-05-29 15:05:54 +00:00
std::map<QString, Account*>::const_iterator itr = accounts.find(account);
if (itr == accounts.end()) {
qDebug() << "An attempt to remove non existing account " << account << ", skipping";
return;
}
Account* acc = itr->second;
int index = acc->row();
root->removeChild(index);
accountsModel->removeAccount(index);
2019-05-30 09:36:21 +00:00
accounts.erase(itr);
2019-05-29 15:05:54 +00:00
2020-04-17 23:17:47 +00:00
std::map<ElId, Contact*>::const_iterator cItr = contacts.begin();
2019-05-29 15:05:54 +00:00
while (cItr != contacts.end()) {
if (cItr->first.account == account) {
2020-04-17 23:17:47 +00:00
std::map<ElId, Contact*>::const_iterator lItr = cItr;
2019-05-29 15:05:54 +00:00
++cItr;
contacts.erase(lItr);
} else {
++cItr;
}
}
std::map<ElId, Group*>::const_iterator gItr = groups.begin();
2019-05-29 15:05:54 +00:00
while (gItr != groups.end()) {
if (gItr->first.account == account) {
std::map<ElId, Group*>::const_iterator lItr = gItr;
2019-05-29 15:05:54 +00:00
++gItr;
groups.erase(lItr);
} else {
++gItr;
}
}
std::map<ElId, Room*>::const_iterator rItr = rooms.begin();
while (rItr != rooms.end()) {
if (rItr->first.account == account) {
std::map<ElId, Room*>::const_iterator lItr = rItr;
++rItr;
rooms.erase(lItr);
} else {
++rItr;
}
}
disconnect(acc, &Account::reconnected, this, &Roster::onAccountReconnected);
2019-05-30 09:36:21 +00:00
acc->deleteLater();
2019-05-29 15:05:54 +00:00
}
2023-08-15 15:28:25 +00:00
QString Models::Roster::getContactName(const QString& account, const QString& jid) const {
ElId id(account, jid);
2020-04-17 23:17:47 +00:00
std::map<ElId, Contact*>::const_iterator cItr = contacts.find(id);
QString name = "";
if (cItr == contacts.end()) {
std::map<ElId, Room*>::const_iterator rItr = rooms.find(id);
2023-08-15 15:28:25 +00:00
if (rItr == rooms.end())
qDebug() << "An attempt to get a name of non existing contact/room " << account << ":" << jid << ", skipping";
2023-08-15 15:28:25 +00:00
else
2019-09-24 09:21:29 +00:00
name = rItr->second->getRoomName();
} else {
name = cItr->second->getContactName();
}
return name;
}
2023-08-15 15:28:25 +00:00
void Models::Roster::addRoom(const QString& account, const QString jid, const QMap<QString, QVariant>& data) {
Account* acc;
{
std::map<QString, Account*>::iterator itr = accounts.find(account);
if (itr == accounts.end()) {
qDebug() << "An attempt to add a room " << jid << " to non existing account " << account << ", skipping";
return;
}
acc = itr->second;
}
ElId id = {account, jid};
std::map<ElId, Room*>::const_iterator itr = rooms.find(id);
if (itr != rooms.end()) {
qDebug() << "An attempt to add already existing room" << jid << ", skipping";
return;
}
Room* room = new Room(acc, jid, data);
connect(room, &Room::requestArchive, this, &Roster::onElementRequestArchive);
connect(room, &Room::fileDownloadRequest, this, &Roster::fileDownloadRequest);
connect(room, &Room::unnoticedMessage, this, &Roster::unnoticedMessage);
connect(room, &Room::localPathInvalid, this, &Roster::localPathInvalid);
connect(room, &Room::unreadMessagesCountChanged, this, &Roster::recalculateUnreadMessages);
rooms.insert(std::make_pair(id, room));
acc->appendChild(room);
emit addedElement({acc->getId(), room->getId()});
}
2023-08-15 15:28:25 +00:00
void Models::Roster::changeRoom(const QString& account, const QString jid, const QMap<QString, QVariant>& data) {
ElId id = {account, jid};
std::map<ElId, Room*>::const_iterator itr = rooms.find(id);
if (itr == rooms.end()) {
qDebug() << "An attempt to change non existing room" << jid << ", skipping";
return;
}
Room* room = itr->second;
for (QMap<QString, QVariant>::const_iterator dItr = data.begin(), dEnd = data.end(); dItr != dEnd; ++dItr) {
room->update(dItr.key(), dItr.value());
}
}
2023-08-15 15:28:25 +00:00
void Models::Roster::removeRoom(const QString& account, const QString jid) {
Account* acc;
{
std::map<QString, Account*>::iterator itr = accounts.find(account);
if (itr == accounts.end()) {
qDebug() << "An attempt to remove a room " << jid << " from non existing account " << account << ", skipping";
return;
}
acc = itr->second;
}
ElId id = {account, jid};
std::map<ElId, Room*>::const_iterator itr = rooms.find(id);
if (itr == rooms.end()) {
qDebug() << "An attempt to remove non existing room" << jid << ", skipping";
return;
}
Room* room = itr->second;
acc->removeChild(room->row());
room->deleteLater();
rooms.erase(itr);
}
2023-08-15 15:28:25 +00:00
void Models::Roster::addRoomParticipant(const QString& account, const QString& jid, const QString& name, const QMap<QString, QVariant>& data) {
ElId id = {account, jid};
std::map<ElId, Room*>::const_iterator itr = rooms.find(id);
if (itr == rooms.end()) {
qDebug() << "An attempt to add participant" << name << "non existing room" << jid << "of an account" << account << ", skipping";
return;
} else {
itr->second->addParticipant(name, data);
}
}
2023-08-15 15:28:25 +00:00
void Models::Roster::changeRoomParticipant(const QString& account, const QString& jid, const QString& name, const QMap<QString, QVariant>& data) {
ElId id = {account, jid};
std::map<ElId, Room*>::const_iterator itr = rooms.find(id);
if (itr == rooms.end()) {
qDebug() << "An attempt change participant" << name << "of non existing room" << jid << "of an account" << account << ", skipping";
return;
} else {
itr->second->changeParticipant(name, data);
}
}
2023-08-15 15:28:25 +00:00
void Models::Roster::removeRoomParticipant(const QString& account, const QString& jid, const QString& name) {
ElId id = {account, jid};
std::map<ElId, Room*>::const_iterator itr = rooms.find(id);
if (itr == rooms.end()) {
qDebug() << "An attempt remove participant" << name << "from non existing room" << jid << "of an account" << account << ", skipping";
return;
} else {
itr->second->removeParticipant(name);
}
}
2023-08-15 15:28:25 +00:00
std::deque<QString> Models::Roster::groupList(const QString& account) const {
std::deque<QString> answer;
for (std::pair<ElId, Group*> pair : groups) {
2023-08-15 15:28:25 +00:00
if (pair.first.account == account)
answer.push_back(pair.first.name);
}
return answer;
}
2023-08-15 15:28:25 +00:00
bool Models::Roster::groupHasContact(const QString& account, const QString& group, const QString& contact) const {
ElId grId({account, group});
std::map<ElId, Group*>::const_iterator gItr = groups.find(grId);
if (gItr == groups.end()) {
return false;
} else {
2020-04-17 23:17:47 +00:00
return gItr->second->getContact(contact) != -1;
}
}
2023-08-15 15:28:25 +00:00
QString Models::Roster::getContactIconPath(const QString& account, const QString& jid, const QString& resource) const {
ElId id(account, jid);
2020-04-17 23:17:47 +00:00
std::map<ElId, Contact*>::const_iterator cItr = contacts.find(id);
QString path = "";
if (cItr == contacts.end()) {
std::map<ElId, Room*>::const_iterator rItr = rooms.find(id);
2023-08-15 15:28:25 +00:00
if (rItr == rooms.end())
qDebug() << "An attempt to get an icon path of non existing contact" << account << ":" << jid << ", returning empty value";
2023-08-15 15:28:25 +00:00
else
2019-12-31 18:14:12 +00:00
path = rItr->second->getParticipantIconPath(resource);
} else {
2023-08-15 15:28:25 +00:00
if (cItr->second->getAvatarState() != Shared::Avatar::empty)
path = cItr->second->getAvatarPath();
}
return path;
}
Models::Account * Models::Roster::getAccount(const QString& name) {
return const_cast<Models::Account*>(getAccountConst(name));}
const Models::Account * Models::Roster::getAccountConst(const QString& name) const {
return accounts.at(name);}
2023-08-15 15:28:25 +00:00
const Models::Element * Models::Roster::getElementConst(const Models::Roster::ElId& id) const {
std::map<ElId, Contact*>::const_iterator cItr = contacts.find(id);
if (cItr != contacts.end()) {
return cItr->second;
} else {
std::map<ElId, Room*>::const_iterator rItr = rooms.find(id);
2023-08-15 15:28:25 +00:00
if (rItr != rooms.end())
return rItr->second;
}
return nullptr;
}
2023-08-15 15:28:25 +00:00
bool Models::Roster::markMessageAsRead(const Models::Roster::ElId& elementId, const QString& messageId) {
const Element* el = getElementConst(elementId);
2023-08-15 15:28:25 +00:00
if (el != nullptr)
return el->markMessageAsRead(messageId);
2023-08-15 15:28:25 +00:00
else
return false;
}
2023-08-15 15:28:25 +00:00
QModelIndex Models::Roster::getAccountIndex(const QString& name) const {
std::map<QString, Account*>::const_iterator itr = accounts.find(name);
if (itr == accounts.end()) {
return QModelIndex();
} else {
return index(itr->second->row(), 0, QModelIndex());
}
}
2023-08-15 15:28:25 +00:00
QModelIndex Models::Roster::getGroupIndex(const QString& account, const QString& name) const {
std::map<QString, Account*>::const_iterator itr = accounts.find(account);
if (itr == accounts.end()) {
return QModelIndex();
} else {
std::map<ElId, Group*>::const_iterator gItr = groups.find(ElId(account, name));
if (gItr == groups.end()) {
return QModelIndex();
} else {
QModelIndex accIndex = index(itr->second->row(), 0, QModelIndex());
return index(gItr->second->row(), 0, accIndex);
}
}
}
2023-08-15 15:28:25 +00:00
QModelIndex Models::Roster::getContactIndex(const QString& account, const QString& jid, const QString& resource) const {
std::map<QString, Account*>::const_iterator itr = accounts.find(account);
if (itr == accounts.end()) {
return QModelIndex();
} else {
Account* acc = itr->second;
QModelIndex accIndex = index(acc->row(), 0, QModelIndex());
std::map<ElId, Contact*>::const_iterator cItr = contacts.find(ElId(account, jid));
if (cItr != contacts.end()) {
QModelIndex contactIndex = index(acc->getContact(jid), 0, accIndex);
if (resource.size() == 0) {
return contactIndex;
} else {
Presence* pres = cItr->second->getPresence(resource);
2023-08-15 15:28:25 +00:00
if (pres != nullptr)
return index(pres->row(), 0, contactIndex);
2023-08-15 15:28:25 +00:00
else
return contactIndex;
}
} else {
std::map<ElId, Room*>::const_iterator rItr = rooms.find(ElId(account, jid));
if (rItr != rooms.end()) {
QModelIndex roomIndex = index(rItr->second->row(), 0, accIndex);
if (resource.size() == 0) {
return roomIndex;
} else {
Participant* part = rItr->second->getParticipant(resource);
2023-08-15 15:28:25 +00:00
if (part != nullptr)
return index(part->row(), 0, roomIndex);
2023-08-15 15:28:25 +00:00
else
return roomIndex;
}
} else {
return QModelIndex();
}
}
}
}
2023-08-15 15:28:25 +00:00
void Models::Roster::onElementRequestArchive(const QString& before) {
Element* el = static_cast<Element*>(sender());
emit requestArchive(el->getAccountName(), el->getJid(), before);
}
2023-08-15 15:28:25 +00:00
void Models::Roster::responseArchive(const QString& account, const QString& jid, const std::list<Shared::Message>& list, bool last) {
ElId id(account, jid);
Element* el = getElement(id);
2023-08-15 15:28:25 +00:00
if (el != nullptr)
el->responseArchive(list, last);
}
2023-08-15 15:28:25 +00:00
void Models::Roster::fileProgress(const std::list<Shared::MessageInfo>& msgs, qreal value, bool up) {
for (const Shared::MessageInfo& info : msgs) {
Element* el = getElement(ElId(info.account, info.jid));
2023-08-15 15:28:25 +00:00
if (el != nullptr)
el->fileProgress(info.messageId, value, up);
}
}
2021-02-27 12:21:27 +00:00
2023-08-15 15:28:25 +00:00
void Models::Roster::fileComplete(const std::list<Shared::MessageInfo>& msgs, bool up) {
for (const Shared::MessageInfo& info : msgs) {
Element* el = getElement(ElId(info.account, info.jid));
2023-08-15 15:28:25 +00:00
if (el != nullptr)
el->fileComplete(info.messageId, up);
2021-02-27 12:21:27 +00:00
}
}
2023-08-15 15:28:25 +00:00
void Models::Roster::fileError(const std::list<Shared::MessageInfo>& msgs, const QString& err, bool up) {
for (const Shared::MessageInfo& info : msgs) {
Element* el = getElement(ElId(info.account, info.jid));
2023-08-15 15:28:25 +00:00
if (el != nullptr)
el->fileError(info.messageId, err, up);
2021-02-27 12:21:27 +00:00
}
}
2023-08-15 15:28:25 +00:00
Models::Element * Models::Roster::getElement(const Models::Roster::ElId& id) {
return const_cast<Models::Element*>(getElementConst(id));
}
2023-08-15 15:28:25 +00:00
Models::Item::Type Models::Roster::getContactType(const Models::Roster::ElId& id) const {
const Models::Element* el = getElementConst(id);
2023-08-15 15:28:25 +00:00
if (el == nullptr)
return Item::root;
2023-08-15 15:28:25 +00:00
return el->type;
2021-02-27 12:21:27 +00:00
}
2023-08-15 15:28:25 +00:00
void Models::Roster::onAccountReconnected() {
Account* acc = static_cast<Account*>(sender());
QString accName = acc->getName();
for (const std::pair<const ElId, Contact*>& pair : contacts) {
2023-08-15 15:28:25 +00:00
if (pair.first.account == accName)
pair.second->handleRecconnect();
}
}
2023-08-15 15:28:25 +00:00
void Models::Roster::recalculateUnreadMessages() {
int count(0);
2023-08-15 15:28:25 +00:00
for (const std::pair<const ElId, Contact*>& pair : contacts)
count += pair.second->getMessagesCount();
2023-08-15 15:28:25 +00:00
for (const std::pair<const ElId, Room*>& pair : rooms)
count += pair.second->getMessagesCount();
2023-08-15 15:28:25 +00:00
emit unreadMessagesCountChanged(count);
}
2023-08-15 15:28:25 +00:00
std::list<QString> Models::Roster::getItemPath(const QModelIndex& index) const {
std::list<QString> result;
if (index.isValid() && index.model() == this) {
Item* item = static_cast<Item*>(index.internalPointer());
while (item->type != Item::root) {
result.push_front(item->getId());
item = item->parentItem();
}
}
return result;
}
2023-08-15 15:28:25 +00:00
QModelIndex Models::Roster::getIndexByPath(const std::list<QString>& path) const {
if (path.empty())
return QModelIndex();
QModelIndex current;
for (const QString& hop : path) {
int rows = rowCount(current);
bool found = false;
for (int i = 0; i < rows; ++i) {
QModelIndex el = index(i, 0, current);
Item* item = static_cast<Item*>(el.internalPointer());
if (item->getId() == hop) {
found = true;
current = el;
break;
}
}
if (!found)
break;
}
return current; //this way I will return the last matching model index, may be it's logically incorrect
// std::list<QString>::const_iterator pathItr = path.begin();
// QString accName = *pathItr;
// QModelIndex accIndex = getAccountIndex(accName);
// if (path.size() == 1)
// return accIndex;
//
// if (!accIndex.isValid())
// return QModelIndex();
//
// ++pathItr;
// ElId id{accName, *pathItr};
// QModelIndex contactIndex = getContactIndex(id.account, id.name);
// if (!contactIndex.isValid())
// contactIndex = getGroupIndex(id.account, id.name);
//
// if (path.size() == 2)
// return contactIndex;
//
// if (!contactIndex.isValid())
// return QModelIndex();
//
// ++pathItr;
}