squawk/ui/squawk.cpp

1032 lines
39 KiB
C++
Raw Permalink 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/>.
*/
2019-03-29 14:54:34 +00:00
#include "squawk.h"
#include "ui_squawk.h"
2019-04-02 15:46:18 +00:00
#include <QDebug>
#include <QIcon>
2019-03-29 14:54:34 +00:00
Squawk::Squawk(QWidget *parent) :
QMainWindow(parent),
m_ui(new Ui::Squawk),
2019-03-30 20:13:13 +00:00
accounts(0),
2019-04-09 15:04:08 +00:00
rosterModel(),
conversations(),
contextMenu(new QMenu()),
dbus("org.freedesktop.Notifications", "/org/freedesktop/Notifications", "org.freedesktop.Notifications", QDBusConnection::sessionBus()),
vCards(),
requestedAccountsForPasswords(),
2020-04-11 20:00:15 +00:00
prompt(0),
currentConversation(0),
restoreSelection(),
needToRestore(false)
2019-03-29 14:54:34 +00:00
{
m_ui->setupUi(this);
m_ui->roster->setModel(&rosterModel);
m_ui->roster->setContextMenuPolicy(Qt::CustomContextMenu);
m_ui->roster->setColumnWidth(1, 30);
m_ui->roster->setIconSize(QSize(20, 20));
m_ui->roster->header()->setStretchLastSection(false);
m_ui->roster->header()->setSectionResizeMode(0, QHeaderView::Stretch);
2019-03-29 14:54:34 +00:00
for (int i = static_cast<int>(Shared::AvailabilityLowest); i < static_cast<int>(Shared::AvailabilityHighest) + 1; ++i) {
2019-07-01 13:53:01 +00:00
Shared::Availability av = static_cast<Shared::Availability>(i);
m_ui->comboBox->addItem(Shared::availabilityIcon(av), Shared::Global::getName(av));
}
m_ui->comboBox->setCurrentIndex(static_cast<int>(Shared::Availability::offline));
connect(m_ui->actionAccounts, &QAction::triggered, this, &Squawk::onAccounts);
connect(m_ui->actionAddContact, &QAction::triggered, this, &Squawk::onNewContact);
connect(m_ui->actionAddConference, &QAction::triggered, this, &Squawk::onNewConference);
2020-04-15 17:27:38 +00:00
connect(m_ui->actionQuit, &QAction::triggered, this, &Squawk::close);
connect(m_ui->comboBox, qOverload<int>(&QComboBox::activated), this, &Squawk::onComboboxActivated);
//connect(m_ui->roster, &QTreeView::doubleClicked, this, &Squawk::onRosterItemDoubleClicked);
connect(m_ui->roster, &QTreeView::customContextMenuRequested, this, &Squawk::onRosterContextMenu);
connect(m_ui->roster, &QTreeView::collapsed, this, &Squawk::onItemCollepsed);
2020-04-11 20:00:15 +00:00
connect(m_ui->roster->selectionModel(), &QItemSelectionModel::currentRowChanged, this, &Squawk::onRosterSelectionChanged);
connect(&rosterModel, &Models::Roster::unnoticedMessage, this, &Squawk::onUnnoticedMessage);
connect(rosterModel.accountsModel, &Models::Accounts::sizeChanged, this, &Squawk::onAccountsSizeChanged);
connect(&rosterModel, &Models::Roster::requestArchive, this, &Squawk::onRequestArchive);
connect(&rosterModel, &Models::Roster::fileDownloadRequest, this, &Squawk::fileDownloadRequest);
connect(&rosterModel, &Models::Roster::localPathInvalid, this, &Squawk::localPathInvalid);
connect(contextMenu, &QMenu::aboutToHide, this, &Squawk::onContextAboutToHide);
//m_ui->mainToolBar->addWidget(m_ui->comboBox);
if (testAttribute(Qt::WA_TranslucentBackground)) {
m_ui->roster->viewport()->setAutoFillBackground(false);
}
QSettings settings;
settings.beginGroup("ui");
settings.beginGroup("window");
if (settings.contains("geometry")) {
restoreGeometry(settings.value("geometry").toByteArray());
}
if (settings.contains("state")) {
restoreState(settings.value("state").toByteArray());
}
settings.endGroup();
2020-04-11 20:00:15 +00:00
if (settings.contains("splitter")) {
m_ui->splitter->restoreState(settings.value("splitter").toByteArray());
}
settings.endGroup();
2019-03-29 14:54:34 +00:00
}
Squawk::~Squawk() {
delete contextMenu;
2019-03-29 14:54:34 +00:00
}
void Squawk::onAccounts()
{
if (accounts == 0) {
accounts = new Accounts(rosterModel.accountsModel);
2019-03-29 14:54:34 +00:00
accounts->setAttribute(Qt::WA_DeleteOnClose);
connect(accounts, &Accounts::destroyed, this, &Squawk::onAccountsClosed);
connect(accounts, &Accounts::newAccount, this, &Squawk::newAccountRequest);
connect(accounts, &Accounts::changeAccount, this, &Squawk::modifyAccountRequest);
connect(accounts, &Accounts::connectAccount, this, &Squawk::connectAccount);
connect(accounts, &Accounts::disconnectAccount, this, &Squawk::disconnectAccount);
connect(accounts, &Accounts::removeAccount, this, &Squawk::removeAccountRequest);
2019-03-30 20:13:13 +00:00
2019-03-29 14:54:34 +00:00
accounts->show();
} else {
2019-03-30 20:13:13 +00:00
accounts->show();
accounts->raise();
accounts->activateWindow();
2019-03-29 14:54:34 +00:00
}
}
void Squawk::onAccountsSizeChanged(unsigned int size)
{
if (size > 0) {
m_ui->actionAddContact->setEnabled(true);
2019-09-04 16:38:52 +00:00
m_ui->actionAddConference->setEnabled(true);
} else {
m_ui->actionAddContact->setEnabled(false);
2019-09-04 16:38:52 +00:00
m_ui->actionAddConference->setEnabled(false);
}
}
void Squawk::onNewContact()
{
NewContact* nc = new NewContact(rosterModel.accountsModel, this);
connect(nc, &NewContact::accepted, this, &Squawk::onNewContactAccepted);
connect(nc, &NewContact::rejected, nc, &NewContact::deleteLater);
nc->exec();
}
2019-09-04 16:38:52 +00:00
void Squawk::onNewConference()
{
JoinConference* jc = new JoinConference(rosterModel.accountsModel, this);
connect(jc, &JoinConference::accepted, this, &Squawk::onJoinConferenceAccepted);
connect(jc, &JoinConference::rejected, jc, &JoinConference::deleteLater);
2019-09-04 16:38:52 +00:00
jc->exec();
}
void Squawk::onNewContactAccepted()
{
NewContact* nc = static_cast<NewContact*>(sender());
NewContact::Data value = nc->value();
emit addContactRequest(value.account, value.jid, value.name, value.groups);
nc->deleteLater();
}
2019-09-04 16:38:52 +00:00
void Squawk::onJoinConferenceAccepted()
{
JoinConference* jc = static_cast<JoinConference*>(sender());
JoinConference::Data value = jc->value();
emit addRoomRequest(value.account, value.jid, value.nick, value.password, value.autoJoin);
jc->deleteLater();
}
2019-03-29 14:54:34 +00:00
void Squawk::closeEvent(QCloseEvent* event)
{
if (accounts != 0) {
accounts->close();
}
2019-04-09 15:04:08 +00:00
for (Conversations::const_iterator itr = conversations.begin(), end = conversations.end(); itr != end; ++itr) {
disconnect(itr->second, &Conversation::destroyed, this, &Squawk::onConversationClosed);
2019-04-09 15:04:08 +00:00
itr->second->close();
}
conversations.clear();
2019-03-29 14:54:34 +00:00
for (std::map<QString, VCard*>::const_iterator itr = vCards.begin(), end = vCards.end(); itr != end; ++itr) {
disconnect(itr->second, &VCard::destroyed, this, &Squawk::onVCardClosed);
itr->second->close();
}
vCards.clear();
2019-03-29 14:54:34 +00:00
QMainWindow::closeEvent(event);
}
void Squawk::onAccountsClosed(QObject* parent)
{
accounts = 0;
}
2019-03-30 20:13:13 +00:00
void Squawk::newAccount(const QMap<QString, QVariant>& account)
{
rosterModel.addAccount(account);
2019-03-30 20:13:13 +00:00
}
void Squawk::onComboboxActivated(int index)
{
Shared::Availability av = Shared::Global::fromInt<Shared::Availability>(index);
if (av != Shared::Availability::offline) {
2019-04-03 18:15:36 +00:00
int size = rosterModel.accountsModel->rowCount(QModelIndex());
if (size > 0) {
emit changeState(av);
2019-04-03 18:15:36 +00:00
for (int i = 0; i < size; ++i) {
Models::Account* acc = rosterModel.accountsModel->getAccount(i);
if (acc->getState() == Shared::ConnectionState::disconnected) {
2019-04-03 18:15:36 +00:00
emit connectAccount(acc->getName());
}
}
} else {
m_ui->comboBox->setCurrentIndex(static_cast<int>(Shared::Availability::offline));
}
} else {
emit changeState(av);
2019-04-03 18:15:36 +00:00
int size = rosterModel.accountsModel->rowCount(QModelIndex());
for (int i = 0; i != size; ++i) {
Models::Account* acc = rosterModel.accountsModel->getAccount(i);
if (acc->getState() != Shared::ConnectionState::disconnected) {
2019-04-03 18:15:36 +00:00
emit disconnectAccount(acc->getName());
}
}
}
}
void Squawk::changeAccount(const QString& account, const QMap<QString, QVariant>& data)
{
for (QMap<QString, QVariant>::const_iterator itr = data.begin(), end = data.end(); itr != end; ++itr) {
QString attr = itr.key();
rosterModel.updateAccount(account, attr, *itr);
}
}
void Squawk::addContact(const QString& account, const QString& jid, const QString& group, const QMap<QString, QVariant>& data)
{
rosterModel.addContact(account, jid, group, data);
QSettings settings;
settings.beginGroup("ui");
settings.beginGroup("roster");
settings.beginGroup(account);
if (settings.value("expanded", false).toBool()) {
QModelIndex ind = rosterModel.getAccountIndex(account);
m_ui->roster->expand(ind);
}
settings.endGroup();
settings.endGroup();
settings.endGroup();
2019-04-03 21:23:51 +00:00
}
void Squawk::addGroup(const QString& account, const QString& name)
{
rosterModel.addGroup(account, name);
QSettings settings;
settings.beginGroup("ui");
settings.beginGroup("roster");
settings.beginGroup(account);
if (settings.value("expanded", false).toBool()) {
QModelIndex ind = rosterModel.getAccountIndex(account);
m_ui->roster->expand(ind);
if (settings.value(name + "/expanded", false).toBool()) {
m_ui->roster->expand(rosterModel.getGroupIndex(account, name));
}
}
settings.endGroup();
settings.endGroup();
settings.endGroup();
2019-04-03 21:23:51 +00:00
}
void Squawk::removeGroup(const QString& account, const QString& name)
{
2019-04-06 10:14:32 +00:00
rosterModel.removeGroup(account, name);
2019-04-03 21:23:51 +00:00
}
void Squawk::changeContact(const QString& account, const QString& jid, const QMap<QString, QVariant>& data)
2019-04-06 10:14:32 +00:00
{
rosterModel.changeContact(account, jid, data);
2019-04-06 10:14:32 +00:00
}
void Squawk::removeContact(const QString& account, const QString& jid)
{
rosterModel.removeContact(account, jid);
}
void Squawk::removeContact(const QString& account, const QString& jid, const QString& group)
{
rosterModel.removeContact(account, jid, group);
}
2019-04-03 21:23:51 +00:00
2019-04-07 14:02:41 +00:00
void Squawk::addPresence(const QString& account, const QString& jid, const QString& name, const QMap<QString, QVariant>& data)
{
rosterModel.addPresence(account, jid, name, data);
}
void Squawk::removePresence(const QString& account, const QString& jid, const QString& name)
{
rosterModel.removePresence(account, jid, name);
}
void Squawk::stateChanged(Shared::Availability state)
{
m_ui->comboBox->setCurrentIndex(static_cast<int>(state));
}
2019-04-03 21:23:51 +00:00
2019-04-09 15:04:08 +00:00
void Squawk::onRosterItemDoubleClicked(const QModelIndex& item)
{
if (item.isValid()) {
Models::Item* node = static_cast<Models::Item*>(item.internalPointer());
2020-04-17 23:17:47 +00:00
if (node->type == Models::Item::reference) {
node = static_cast<Models::Reference*>(node)->dereference();
}
2019-04-09 15:04:08 +00:00
Models::Contact* contact = 0;
2019-08-28 11:40:55 +00:00
Models::Room* room = 0;
2019-04-12 15:22:10 +00:00
QString res;
2019-08-28 11:40:55 +00:00
Models::Roster::ElId* id = 0;
2019-04-09 15:04:08 +00:00
switch (node->type) {
case Models::Item::contact:
contact = static_cast<Models::Contact*>(node);
2019-08-28 11:40:55 +00:00
id = new Models::Roster::ElId(contact->getAccountName(), contact->getJid());
2019-04-09 15:04:08 +00:00
break;
case Models::Item::presence:
contact = static_cast<Models::Contact*>(node->parentItem());
2019-08-28 11:40:55 +00:00
id = new Models::Roster::ElId(contact->getAccountName(), contact->getJid());
2019-04-12 15:22:10 +00:00
res = node->getName();
2019-04-09 15:04:08 +00:00
break;
2019-08-28 11:40:55 +00:00
case Models::Item::room:
room = static_cast<Models::Room*>(node);
id = new Models::Roster::ElId(room->getAccountName(), room->getJid());
break;
2019-04-09 15:04:08 +00:00
default:
m_ui->roster->expand(item);
break;
}
2019-08-28 11:40:55 +00:00
if (id != 0) {
Conversations::const_iterator itr = conversations.find(*id);
Models::Account* acc = rosterModel.getAccount(id->account);
2019-08-28 11:40:55 +00:00
Conversation* conv = 0;
bool created = false;
2019-04-09 15:04:08 +00:00
if (itr != conversations.end()) {
2019-08-28 11:40:55 +00:00
conv = itr->second;
} else if (contact != 0) {
created = true;
conv = new Chat(acc, contact);
2019-08-28 11:40:55 +00:00
} else if (room != 0) {
created = true;
conv = new Room(acc, room);
if (!room->getJoined()) {
emit setRoomJoined(id->account, id->name, true);
}
2019-08-28 11:40:55 +00:00
}
2019-04-12 15:22:10 +00:00
2019-08-28 11:40:55 +00:00
if (conv != 0) {
if (created) {
conv->setAttribute(Qt::WA_DeleteOnClose);
2020-04-11 20:00:15 +00:00
subscribeConversation(conv);
2019-08-28 11:40:55 +00:00
conversations.insert(std::make_pair(*id, conv));
2019-04-12 15:22:10 +00:00
}
2019-04-09 15:04:08 +00:00
conv->show();
2019-08-28 11:40:55 +00:00
conv->raise();
conv->activateWindow();
2019-04-12 15:22:10 +00:00
if (res.size() > 0) {
2019-05-30 09:36:21 +00:00
conv->setPalResource(res);
2019-04-12 15:22:10 +00:00
}
2019-04-09 15:04:08 +00:00
}
2019-08-28 11:40:55 +00:00
2020-04-11 20:00:15 +00:00
delete id;
2019-04-09 15:04:08 +00:00
}
}
}
void Squawk::onConversationClosed(QObject* parent)
{
Conversation* conv = static_cast<Conversation*>(sender());
Models::Roster::ElId id(conv->getAccount(), conv->getJid());
Conversations::const_iterator itr = conversations.find(id);
2020-04-11 20:00:15 +00:00
if (itr != conversations.end()) {
conversations.erase(itr);
2019-04-09 15:04:08 +00:00
}
if (conv->isMuc) {
Room* room = static_cast<Room*>(conv);
if (!room->autoJoined()) {
emit setRoomJoined(id.account, id.name, false);
}
}
2019-04-09 15:04:08 +00:00
}
2019-04-09 22:01:25 +00:00
void Squawk::fileProgress(const std::list<Shared::MessageInfo> msgs, qreal value, bool up)
{
rosterModel.fileProgress(msgs, value, up);
}
void Squawk::fileDownloadComplete(const std::list<Shared::MessageInfo> msgs, const QString& path)
{
rosterModel.fileComplete(msgs, false);
}
void Squawk::fileError(const std::list<Shared::MessageInfo> msgs, const QString& error, bool up)
2019-09-18 13:27:47 +00:00
{
rosterModel.fileError(msgs, error, up);
2019-09-18 13:27:47 +00:00
}
void Squawk::fileUploadComplete(const std::list<Shared::MessageInfo> msgs, const QString& path)
{
rosterModel.fileComplete(msgs, true);
}
void Squawk::accountMessage(const QString& account, const Shared::Message& data)
2019-04-09 22:01:25 +00:00
{
rosterModel.addMessage(account, data);
}
void Squawk::onUnnoticedMessage(const QString& account, const Shared::Message& msg)
{
notify(account, msg); //Telegram does this way - notifies even if the app is visible
QApplication::alert(this);
2019-04-09 22:01:25 +00:00
}
2019-04-10 20:53:42 +00:00
void Squawk::changeMessage(const QString& account, const QString& jid, const QString& id, const QMap<QString, QVariant>& data)
{
rosterModel.changeMessage(account, jid, id, data);
}
void Squawk::notify(const QString& account, const Shared::Message& msg)
{
QString name = QString(rosterModel.getContactName(account, msg.getPenPalJid()));
2019-12-31 18:14:12 +00:00
QString path = QString(rosterModel.getContactIconPath(account, msg.getPenPalJid(), msg.getPenPalResource()));
QVariantList args;
args << QString(QCoreApplication::applicationName());
args << QVariant(QVariant::UInt); //TODO some normal id
if (path.size() > 0) {
args << path;
} else {
2019-12-31 18:14:12 +00:00
args << QString("mail-message"); //TODO should here better be unknown user icon?
}
if (msg.getType() == Shared::Message::groupChat) {
args << msg.getFromResource() + " from " + name;
} else {
args << name;
}
2019-12-31 18:14:12 +00:00
QString body(msg.getBody());
QString oob(msg.getOutOfBandUrl());
if (body == oob) {
body = tr("Attached file");
}
args << body;
args << QStringList();
args << QVariantMap();
args << 3000;
dbus.callWithArgumentList(QDBus::AutoDetect, "Notify", args);
}
void Squawk::onConversationMessage(const Shared::Message& msg)
2019-04-10 20:53:42 +00:00
{
Conversation* conv = static_cast<Conversation*>(sender());
QString acc = conv->getAccount();
2019-11-12 13:38:01 +00:00
rosterModel.addMessage(acc, msg);
emit sendMessage(acc, msg);
2019-09-23 12:09:15 +00:00
}
void Squawk::onRequestArchive(const QString& account, const QString& jid, const QString& before)
{
emit requestArchive(account, jid, 20, before); //TODO amount as a settings value
}
void Squawk::responseArchive(const QString& account, const QString& jid, const std::list<Shared::Message>& list, bool last)
{
rosterModel.responseArchive(account, jid, list, last);
}
2019-05-29 15:05:54 +00:00
void Squawk::removeAccount(const QString& account)
{
Conversations::const_iterator itr = conversations.begin();
while (itr != conversations.end()) {
if (itr->first.account == account) {
Conversations::const_iterator lItr = itr;
++itr;
Conversation* conv = lItr->second;
disconnect(conv, &Conversation::destroyed, this, &Squawk::onConversationClosed);
2019-05-29 15:05:54 +00:00
conv->close();
conversations.erase(lItr);
} else {
++itr;
}
}
2020-04-11 20:00:15 +00:00
if (currentConversation != 0 && currentConversation->getAccount() == account) {
currentConversation->deleteLater();
currentConversation = 0;
m_ui->filler->show();
}
2019-05-29 15:05:54 +00:00
rosterModel.removeAccount(account);
}
void Squawk::onRosterContextMenu(const QPoint& point)
{
QModelIndex index = m_ui->roster->indexAt(point);
if (index.isValid()) {
Models::Item* item = static_cast<Models::Item*>(index.internalPointer());
2020-04-17 23:17:47 +00:00
if (item->type == Models::Item::reference) {
item = static_cast<Models::Reference*>(item)->dereference();
}
contextMenu->clear();
bool hasMenu = false;
bool active = item->getAccountConnectionState() == Shared::ConnectionState::connected;
switch (item->type) {
case Models::Item::account: {
Models::Account* acc = static_cast<Models::Account*>(item);
hasMenu = true;
QString name = acc->getName();
if (acc->getState() != Shared::ConnectionState::disconnected) {
QAction* con = contextMenu->addAction(Shared::icon("network-disconnect"), tr("Disconnect"));
con->setEnabled(active);
connect(con, &QAction::triggered, [this, name]() {
emit disconnectAccount(name);
});
} else {
QAction* con = contextMenu->addAction(Shared::icon("network-connect"), tr("Connect"));
connect(con, &QAction::triggered, [this, name]() {
emit connectAccount(name);
});
}
QAction* card = contextMenu->addAction(Shared::icon("user-properties"), tr("VCard"));
card->setEnabled(active);
connect(card, &QAction::triggered, std::bind(&Squawk::onActivateVCard, this, name, acc->getBareJid(), true));
QAction* remove = contextMenu->addAction(Shared::icon("edit-delete"), tr("Remove"));
remove->setEnabled(active);
connect(remove, &QAction::triggered, [this, name]() {
emit removeAccount(name);
});
}
break;
case Models::Item::contact: {
Models::Contact* cnt = static_cast<Models::Contact*>(item);
hasMenu = true;
QAction* dialog = contextMenu->addAction(Shared::icon("mail-message"), tr("Open dialog"));
dialog->setEnabled(active);
2019-06-14 16:36:04 +00:00
connect(dialog, &QAction::triggered, [this, index]() {
onRosterItemDoubleClicked(index);
});
Shared::SubscriptionState state = cnt->getState();
switch (state) {
case Shared::SubscriptionState::both:
case Shared::SubscriptionState::to: {
QAction* unsub = contextMenu->addAction(Shared::icon("news-unsubscribe"), tr("Unsubscribe"));
unsub->setEnabled(active);
2019-06-14 16:36:04 +00:00
connect(unsub, &QAction::triggered, [this, cnt]() {
emit unsubscribeContact(cnt->getAccountName(), cnt->getJid(), "");
});
}
break;
case Shared::SubscriptionState::from:
case Shared::SubscriptionState::unknown:
case Shared::SubscriptionState::none: {
QAction* sub = contextMenu->addAction(Shared::icon("news-subscribe"), tr("Subscribe"));
sub->setEnabled(active);
2019-06-14 16:36:04 +00:00
connect(sub, &QAction::triggered, [this, cnt]() {
emit subscribeContact(cnt->getAccountName(), cnt->getJid(), "");
});
}
}
QString accName = cnt->getAccountName();
QString cntJID = cnt->getJid();
QString cntName = cnt->getName();
QAction* rename = contextMenu->addAction(Shared::icon("edit-rename"), tr("Rename"));
rename->setEnabled(active);
connect(rename, &QAction::triggered, [this, cntName, accName, cntJID]() {
QInputDialog* dialog = new QInputDialog(this);
connect(dialog, &QDialog::accepted, [this, dialog, cntName, accName, cntJID]() {
QString newName = dialog->textValue();
if (newName != cntName) {
emit renameContactRequest(accName, cntJID, newName);
}
dialog->deleteLater();
});
connect(dialog, &QDialog::rejected, dialog, &QObject::deleteLater);
dialog->setInputMode(QInputDialog::TextInput);
dialog->setLabelText(tr("Input new name for %1\nor leave it empty for the contact \nto be displayed as %1").arg(cntJID));
dialog->setWindowTitle(tr("Renaming %1").arg(cntJID));
dialog->setTextValue(cntName);
dialog->exec();
});
QMenu* groupsMenu = contextMenu->addMenu(Shared::icon("group"), tr("Groups"));
std::deque<QString> groupList = rosterModel.groupList(accName);
for (QString groupName : groupList) {
QAction* gr = groupsMenu->addAction(groupName);
gr->setCheckable(true);
gr->setChecked(rosterModel.groupHasContact(accName, groupName, cntJID));
gr->setEnabled(active);
connect(gr, &QAction::toggled, [this, accName, groupName, cntJID](bool checked) {
if (checked) {
emit addContactToGroupRequest(accName, cntJID, groupName);
} else {
emit removeContactFromGroupRequest(accName, cntJID, groupName);
}
});
}
QAction* newGroup = groupsMenu->addAction(Shared::icon("group-new"), tr("New group"));
newGroup->setEnabled(active);
connect(newGroup, &QAction::triggered, [this, accName, cntJID]() {
QInputDialog* dialog = new QInputDialog(this);
connect(dialog, &QDialog::accepted, [this, dialog, accName, cntJID]() {
emit addContactToGroupRequest(accName, cntJID, dialog->textValue());
dialog->deleteLater();
});
connect(dialog, &QDialog::rejected, dialog, &QObject::deleteLater);
dialog->setInputMode(QInputDialog::TextInput);
dialog->setLabelText(tr("New group name"));
dialog->setWindowTitle(tr("Add %1 to a new group").arg(cntJID));
dialog->exec();
});
QAction* card = contextMenu->addAction(Shared::icon("user-properties"), tr("VCard"));
card->setEnabled(active);
connect(card, &QAction::triggered, std::bind(&Squawk::onActivateVCard, this, accName, cnt->getJid(), false));
QAction* remove = contextMenu->addAction(Shared::icon("edit-delete"), tr("Remove"));
remove->setEnabled(active);
2019-06-14 16:36:04 +00:00
connect(remove, &QAction::triggered, [this, cnt]() {
emit removeContactRequest(cnt->getAccountName(), cnt->getJid());
});
}
break;
case Models::Item::room: {
Models::Room* room = static_cast<Models::Room*>(item);
hasMenu = true;
QAction* dialog = contextMenu->addAction(Shared::icon("mail-message"), tr("Open conversation"));
dialog->setEnabled(active);
connect(dialog, &QAction::triggered, [this, index]() {
onRosterItemDoubleClicked(index);
});
Models::Roster::ElId id(room->getAccountName(), room->getJid());
if (room->getAutoJoin()) {
QAction* unsub = contextMenu->addAction(Shared::icon("news-unsubscribe"), tr("Unsubscribe"));
unsub->setEnabled(active);
connect(unsub, &QAction::triggered, [this, id]() {
emit setRoomAutoJoin(id.account, id.name, false);
2020-04-11 20:00:15 +00:00
if (conversations.find(id) == conversations.end()
&& (currentConversation == 0 || currentConversation->getId() != id)
) { //to leave the room if it's not opened in a conversation window
emit setRoomJoined(id.account, id.name, false);
}
});
} else {
QAction* unsub = contextMenu->addAction(Shared::icon("news-subscribe"), tr("Subscribe"));
unsub->setEnabled(active);
connect(unsub, &QAction::triggered, [this, id]() {
emit setRoomAutoJoin(id.account, id.name, true);
2020-04-11 20:00:15 +00:00
if (conversations.find(id) == conversations.end()
&& (currentConversation == 0 || currentConversation->getId() != id)
) { //to join the room if it's not already joined
emit setRoomJoined(id.account, id.name, true);
}
});
}
QAction* remove = contextMenu->addAction(Shared::icon("edit-delete"), tr("Remove"));
remove->setEnabled(active);
connect(remove, &QAction::triggered, [this, id]() {
emit removeRoomRequest(id.account, id.name);
});
}
break;
default:
break;
}
if (hasMenu) {
contextMenu->popup(m_ui->roster->viewport()->mapToGlobal(point));
}
}
}
void Squawk::addRoom(const QString& account, const QString jid, const QMap<QString, QVariant>& data)
{
rosterModel.addRoom(account, jid, data);
}
void Squawk::changeRoom(const QString& account, const QString jid, const QMap<QString, QVariant>& data)
{
rosterModel.changeRoom(account, jid, data);
}
void Squawk::removeRoom(const QString& account, const QString jid)
{
rosterModel.removeRoom(account, jid);
}
void Squawk::addRoomParticipant(const QString& account, const QString& jid, const QString& name, const QMap<QString, QVariant>& data)
{
rosterModel.addRoomParticipant(account, jid, name, data);
}
void Squawk::changeRoomParticipant(const QString& account, const QString& jid, const QString& name, const QMap<QString, QVariant>& data)
{
rosterModel.changeRoomParticipant(account, jid, name, data);
}
void Squawk::removeRoomParticipant(const QString& account, const QString& jid, const QString& name)
{
rosterModel.removeRoomParticipant(account, jid, name);
}
void Squawk::responseVCard(const QString& jid, const Shared::VCard& card)
{
std::map<QString, VCard*>::const_iterator itr = vCards.find(jid);
if (itr != vCards.end()) {
itr->second->setVCard(card);
itr->second->hideProgress();
}
}
void Squawk::onVCardClosed()
{
VCard* vCard = static_cast<VCard*>(sender());
std::map<QString, VCard*>::const_iterator itr = vCards.find(vCard->getJid());
if (itr == vCards.end()) {
qDebug() << "VCard has been closed but can not be found among other opened vCards, application is most probably going to crash";
return;
}
vCards.erase(itr);
}
void Squawk::onActivateVCard(const QString& account, const QString& jid, bool edition)
{
std::map<QString, VCard*>::const_iterator itr = vCards.find(jid);
VCard* card;
if (itr != vCards.end()) {
card = itr->second;
} else {
card = new VCard(jid, edition);
if (edition) {
card->setWindowTitle(tr("%1 account card").arg(account));
} else {
card->setWindowTitle(tr("%1 contact card").arg(jid));
}
card->setAttribute(Qt::WA_DeleteOnClose);
vCards.insert(std::make_pair(jid, card));
connect(card, &VCard::destroyed, this, &Squawk::onVCardClosed);
connect(card, &VCard::saveVCard, std::bind( &Squawk::onVCardSave, this, std::placeholders::_1, account));
}
card->show();
card->raise();
card->activateWindow();
card->showProgress(tr("Downloading vCard"));
emit requestVCard(account, jid);
}
void Squawk::onVCardSave(const Shared::VCard& card, const QString& account)
{
VCard* widget = static_cast<VCard*>(sender());
emit uploadVCard(account, card);
widget->deleteLater();
}
void Squawk::readSettings()
{
QSettings settings;
settings.beginGroup("ui");
if (settings.contains("availability")) {
int avail = settings.value("availability").toInt();
m_ui->comboBox->setCurrentIndex(avail);
emit stateChanged(Shared::Global::fromInt<Shared::Availability>(avail));
int size = settings.beginReadArray("connectedAccounts");
for (int i = 0; i < size; ++i) {
settings.setArrayIndex(i);
emit connectAccount(settings.value("name").toString()); //TODO this is actually not needed, stateChanged event already connects everything you have
} // need to fix that
settings.endArray();
}
settings.endGroup();
}
void Squawk::writeSettings()
{
QSettings settings;
settings.beginGroup("ui");
settings.beginGroup("window");
settings.setValue("geometry", saveGeometry());
settings.setValue("state", saveState());
settings.endGroup();
2020-04-11 20:00:15 +00:00
settings.setValue("splitter", m_ui->splitter->saveState());
settings.setValue("availability", m_ui->comboBox->currentIndex());
settings.beginWriteArray("connectedAccounts");
int size = rosterModel.accountsModel->rowCount(QModelIndex());
for (int i = 0; i < size; ++i) {
Models::Account* acc = rosterModel.accountsModel->getAccount(i);
if (acc->getState() != Shared::ConnectionState::disconnected) {
settings.setArrayIndex(i);
settings.setValue("name", acc->getName());
}
}
settings.endArray();
settings.remove("roster");
settings.beginGroup("roster");
for (int i = 0; i < size; ++i) {
QModelIndex acc = rosterModel.index(i, 0, QModelIndex());
Models::Account* account = rosterModel.accountsModel->getAccount(i);
QString accName = account->getName();
settings.beginGroup(accName);
settings.setValue("expanded", m_ui->roster->isExpanded(acc));
std::deque<QString> groups = rosterModel.groupList(accName);
for (const QString& groupName : groups) {
settings.beginGroup(groupName);
QModelIndex gIndex = rosterModel.getGroupIndex(accName, groupName);
settings.setValue("expanded", m_ui->roster->isExpanded(gIndex));
settings.endGroup();
}
settings.endGroup();
}
settings.endGroup();
settings.endGroup();
}
void Squawk::onItemCollepsed(const QModelIndex& index)
{
QSettings settings;
Models::Item* item = static_cast<Models::Item*>(index.internalPointer());
switch (item->type) {
case Models::Item::account:
settings.setValue("ui/roster/" + item->getName() + "/expanded", false);
break;
case Models::Item::group: {
QModelIndex accInd = rosterModel.parent(index);
Models::Account* account = rosterModel.accountsModel->getAccount(accInd.row());
settings.setValue("ui/roster/" + account->getName() + "/" + item->getName() + "/expanded", false);
}
break;
default:
break;
}
}
void Squawk::requestPassword(const QString& account)
{
requestedAccountsForPasswords.push_back(account);
checkNextAccountForPassword();
}
void Squawk::checkNextAccountForPassword()
{
if (prompt == 0 && requestedAccountsForPasswords.size() > 0) {
prompt = new QInputDialog(this);
QString accName = requestedAccountsForPasswords.front();
connect(prompt, &QDialog::accepted, this, &Squawk::onPasswordPromptAccepted);
connect(prompt, &QDialog::rejected, this, &Squawk::onPasswordPromptRejected);
prompt->setInputMode(QInputDialog::TextInput);
prompt->setTextEchoMode(QLineEdit::Password);
prompt->setLabelText(tr("Input the password for account %1").arg(accName));
prompt->setWindowTitle(tr("Password for account %1").arg(accName));
prompt->setTextValue("");
prompt->exec();
}
}
void Squawk::onPasswordPromptAccepted()
{
emit responsePassword(requestedAccountsForPasswords.front(), prompt->textValue());
onPasswordPromptDone();
}
void Squawk::onPasswordPromptDone()
{
prompt->deleteLater();
prompt = 0;
requestedAccountsForPasswords.pop_front();
checkNextAccountForPassword();
}
void Squawk::onPasswordPromptRejected()
{
//for now it's the same on reject and on accept, but one day I'm gonna make
//"Asking for the password again on the authentication failure" feature
//and here I'll be able to break the circle of password requests
emit responsePassword(requestedAccountsForPasswords.front(), prompt->textValue());
onPasswordPromptDone();
}
2020-04-11 20:00:15 +00:00
void Squawk::subscribeConversation(Conversation* conv)
{
connect(conv, &Conversation::destroyed, this, &Squawk::onConversationClosed);
2021-02-07 17:02:11 +00:00
connect(conv, &Conversation::sendMessage, this, &Squawk::onConversationMessage);
connect(conv, &Conversation::notifyableMessage, this, &Squawk::notify);
2020-04-11 20:00:15 +00:00
}
void Squawk::onRosterSelectionChanged(const QModelIndex& current, const QModelIndex& previous)
{
if (restoreSelection.isValid() && restoreSelection == current) {
restoreSelection = QModelIndex();
return;
}
2020-04-11 20:00:15 +00:00
if (current.isValid()) {
Models::Item* node = static_cast<Models::Item*>(current.internalPointer());
2020-04-17 23:17:47 +00:00
if (node->type == Models::Item::reference) {
node = static_cast<Models::Reference*>(node)->dereference();
}
2020-04-11 20:00:15 +00:00
Models::Contact* contact = 0;
Models::Room* room = 0;
QString res;
Models::Roster::ElId* id = 0;
bool hasContext = true;
2020-04-11 20:00:15 +00:00
switch (node->type) {
case Models::Item::contact:
contact = static_cast<Models::Contact*>(node);
id = new Models::Roster::ElId(contact->getAccountName(), contact->getJid());
break;
case Models::Item::presence:
contact = static_cast<Models::Contact*>(node->parentItem());
id = new Models::Roster::ElId(contact->getAccountName(), contact->getJid());
res = node->getName();
hasContext = false;
2020-04-11 20:00:15 +00:00
break;
case Models::Item::room:
room = static_cast<Models::Room*>(node);
id = new Models::Roster::ElId(room->getAccountName(), room->getJid());
break;
case Models::Item::participant:
room = static_cast<Models::Room*>(node->parentItem());
id = new Models::Roster::ElId(room->getAccountName(), room->getJid());
hasContext = false;
break;
case Models::Item::group:
hasContext = false;
2020-04-11 20:00:15 +00:00
default:
break;
}
if (hasContext && QGuiApplication::mouseButtons() & Qt::RightButton) {
if (id != 0) {
delete id;
}
needToRestore = true;
restoreSelection = previous;
return;
}
2020-04-11 20:00:15 +00:00
if (id != 0) {
if (currentConversation != 0) {
if (currentConversation->getId() == *id) {
2020-04-11 20:00:15 +00:00
if (contact != 0) {
currentConversation->setPalResource(res);
}
return;
2020-04-11 20:00:15 +00:00
} else {
currentConversation->deleteLater();
}
} else {
m_ui->filler->hide();
}
Models::Account* acc = rosterModel.getAccount(id->account);
if (contact != 0) {
currentConversation = new Chat(acc, contact);
} else if (room != 0) {
currentConversation = new Room(acc, room);
if (!room->getJoined()) {
emit setRoomJoined(id->account, id->name, true);
}
}
if (!testAttribute(Qt::WA_TranslucentBackground)) {
currentConversation->setFeedFrames(true, false, true, true);
}
subscribeConversation(currentConversation);
if (res.size() > 0) {
currentConversation->setPalResource(res);
}
m_ui->splitter->insertWidget(1, currentConversation);
delete id;
} else {
if (currentConversation != 0) {
currentConversation->deleteLater();
currentConversation = 0;
m_ui->filler->show();
}
}
} else {
if (currentConversation != 0) {
currentConversation->deleteLater();
currentConversation = 0;
m_ui->filler->show();
}
2020-04-11 20:00:15 +00:00
}
}
void Squawk::onContextAboutToHide()
{
if (needToRestore) {
needToRestore = false;
m_ui->roster->selectionModel()->setCurrentIndex(restoreSelection, QItemSelectionModel::ClearAndSelect);
}
}