375 lines
9.8 KiB
C++
375 lines
9.8 KiB
C++
/*
|
|
* 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 "item.h"
|
|
#include "account.h"
|
|
#include "reference.h"
|
|
#include "contact.h"
|
|
|
|
#include <QDebug>
|
|
|
|
Models::Item::Item(Type p_type, const QMap<QString, QVariant> &p_data, Item *p_parent):
|
|
QObject(),
|
|
type(p_type),
|
|
name(""),
|
|
childItems(),
|
|
parent(p_parent),
|
|
references(),
|
|
destroyingByParent(false),
|
|
destroyingByOriginal(false)
|
|
{
|
|
QMap<QString, QVariant>::const_iterator itr = p_data.find("name");
|
|
if (itr != p_data.end()) {
|
|
setName(itr.value().toString());
|
|
}
|
|
}
|
|
|
|
Models::Item::Item(const Models::Item& other):
|
|
QObject(),
|
|
type(other.type),
|
|
name(other.name),
|
|
childItems(),
|
|
parent(nullptr)
|
|
{
|
|
}
|
|
|
|
Models::Item::~Item()
|
|
{
|
|
if (!destroyingByParent) {
|
|
Item* parent = parentItem();
|
|
if (parent != nullptr) {
|
|
if (parent->type == reference) {
|
|
parent->Item::removeChild(row());
|
|
} else {
|
|
parent->removeChild(row());
|
|
}
|
|
}
|
|
}
|
|
|
|
for (Reference* ref : references) {
|
|
ref->destroyingByOriginal = true;
|
|
delete ref;
|
|
}
|
|
|
|
for (Item* child : childItems) {
|
|
child->destroyingByParent = true;
|
|
delete child;
|
|
}
|
|
}
|
|
|
|
void Models::Item::setName(const QString& p_name)
|
|
{
|
|
if (name != p_name) {
|
|
name = p_name;
|
|
changed(0);
|
|
}
|
|
}
|
|
|
|
void Models::Item::appendChild(Models::Item* child)
|
|
{
|
|
_appendChild(child);
|
|
}
|
|
|
|
void Models::Item::_appendChild(Models::Item* child)
|
|
{
|
|
bool moving = false;
|
|
int newRow = 0;
|
|
std::deque<Item*>::const_iterator before = childItems.begin();
|
|
Type ct = child->type;
|
|
if (ct == reference) {
|
|
ct = static_cast<Reference*>(child)->dereference()->type;
|
|
}
|
|
while (before != childItems.end()) {
|
|
Item* bfr = *before;
|
|
Type bt = bfr->type;
|
|
if (bt == reference) {
|
|
bt = static_cast<Reference*>(bfr)->dereference()->type;
|
|
}
|
|
if (bt > ct) {
|
|
break;
|
|
} else if (bt == ct && bfr->getDisplayedName() > child->getDisplayedName()) {
|
|
break;
|
|
}
|
|
newRow++;
|
|
before++;
|
|
}
|
|
|
|
if (child->parent != nullptr) {
|
|
int oldRow = child->row();
|
|
moving = true;
|
|
emit childIsAboutToBeMoved(child->parent, oldRow, oldRow, this, newRow);
|
|
child->parent->_removeChild(oldRow);
|
|
} else {
|
|
emit childIsAboutToBeInserted(this, newRow, newRow);
|
|
}
|
|
childItems.insert(before, child);
|
|
child->parent = this;
|
|
|
|
QObject::connect(child, &Item::childChanged, this, &Item::childChanged);
|
|
QObject::connect(child, &Item::childIsAboutToBeInserted, this, &Item::childIsAboutToBeInserted);
|
|
QObject::connect(child, &Item::childInserted, this, &Item::childInserted);
|
|
QObject::connect(child, &Item::childIsAboutToBeRemoved, this, &Item::childIsAboutToBeRemoved);
|
|
QObject::connect(child, &Item::childRemoved, this, &Item::childRemoved);
|
|
QObject::connect(child, &Item::childIsAboutToBeMoved, this, &Item::childIsAboutToBeMoved);
|
|
QObject::connect(child, &Item::childMoved, this, &Item::childMoved);
|
|
|
|
if (moving) {
|
|
emit childMoved();
|
|
} else {
|
|
emit childInserted();
|
|
}
|
|
}
|
|
|
|
Models::Item * Models::Item::child(int row)
|
|
{
|
|
return childItems[row];
|
|
}
|
|
|
|
int Models::Item::childCount() const
|
|
{
|
|
return childItems.size();
|
|
}
|
|
|
|
int Models::Item::row() const
|
|
{
|
|
if (parent != nullptr) {
|
|
std::deque<Item*>::const_iterator itr = parent->childItems.begin();
|
|
std::deque<Item*>::const_iterator end = parent->childItems.end();
|
|
|
|
for (int i = 0; itr != end; ++itr, ++i) {
|
|
if (*itr == this) {
|
|
return i;
|
|
}
|
|
}
|
|
}
|
|
|
|
return -1; //TODO not sure how it helps
|
|
}
|
|
|
|
Models::Item * Models::Item::parentItem()
|
|
{
|
|
return parent;
|
|
}
|
|
|
|
const Models::Item * Models::Item::parentItemConst() const
|
|
{
|
|
return parent;
|
|
}
|
|
|
|
int Models::Item::columnCount() const
|
|
{
|
|
return 2;
|
|
}
|
|
|
|
QString Models::Item::getName() const
|
|
{
|
|
return name;
|
|
}
|
|
|
|
QVariant Models::Item::data(int column) const
|
|
{
|
|
if (column != 0) {
|
|
return QVariant();
|
|
}
|
|
return name;
|
|
}
|
|
|
|
void Models::Item::removeChild(int index)
|
|
{
|
|
emit childIsAboutToBeRemoved(this, index, index);
|
|
_removeChild(index);
|
|
emit childRemoved();
|
|
}
|
|
|
|
void Models::Item::_removeChild(int index)
|
|
{
|
|
Item* child = childItems[index];
|
|
|
|
QObject::disconnect(child, &Item::childChanged, this, &Item::childChanged);
|
|
QObject::disconnect(child, &Item::childIsAboutToBeInserted, this, &Item::childIsAboutToBeInserted);
|
|
QObject::disconnect(child, &Item::childInserted, this, &Item::childInserted);
|
|
QObject::disconnect(child, &Item::childIsAboutToBeRemoved, this, &Item::childIsAboutToBeRemoved);
|
|
QObject::disconnect(child, &Item::childRemoved, this, &Item::childRemoved);
|
|
QObject::disconnect(child, &Item::childIsAboutToBeMoved, this, &Item::childIsAboutToBeMoved);
|
|
QObject::disconnect(child, &Item::childMoved, this, &Item::childMoved);
|
|
|
|
childItems.erase(childItems.begin() + index);
|
|
child->parent = nullptr;
|
|
}
|
|
|
|
|
|
void Models::Item::changed(int col)
|
|
{
|
|
if (parent != nullptr) {
|
|
emit childChanged(this, row(), col);
|
|
}
|
|
}
|
|
|
|
void Models::Item::toOfflineState()
|
|
{
|
|
for (std::deque<Item*>::iterator itr = childItems.begin(), end = childItems.end(); itr != end; ++itr) {
|
|
Item* it = *itr;
|
|
it->toOfflineState();
|
|
}
|
|
}
|
|
|
|
const Models::Account * Models::Item::getParentAccount() const
|
|
{
|
|
const Item* p = this;
|
|
|
|
while (p != nullptr && p->type != Item::account) {
|
|
p = p->parentItemConst();
|
|
}
|
|
|
|
return static_cast<const Account*>(p);
|
|
}
|
|
|
|
QString Models::Item::getAccountJid() const
|
|
{
|
|
const Account* acc = getParentAccount();
|
|
if (acc == nullptr) {
|
|
return "";
|
|
}
|
|
return acc->getLogin() + "@" + acc->getServer();
|
|
}
|
|
|
|
QString Models::Item::getAccountResource() const
|
|
{
|
|
const Account* acc = getParentAccount();
|
|
if (acc == nullptr) {
|
|
return "";
|
|
}
|
|
return acc->getResource();
|
|
}
|
|
|
|
QString Models::Item::getAccountName() const
|
|
{
|
|
const Account* acc = getParentAccount();
|
|
if (acc == nullptr) {
|
|
return "";
|
|
}
|
|
return acc->getName();
|
|
}
|
|
|
|
Shared::Availability Models::Item::getAccountAvailability() const
|
|
{
|
|
const Account* acc = getParentAccount();
|
|
if (acc == nullptr) {
|
|
return Shared::Availability::offline;
|
|
}
|
|
return acc->getAvailability();
|
|
}
|
|
|
|
Shared::ConnectionState Models::Item::getAccountConnectionState() const
|
|
{
|
|
const Account* acc = getParentAccount();
|
|
if (acc == nullptr) {
|
|
return Shared::ConnectionState::disconnected;
|
|
}
|
|
return acc->getState();
|
|
}
|
|
|
|
QString Models::Item::getDisplayedName() const
|
|
{
|
|
return name;
|
|
}
|
|
|
|
void Models::Item::onChildChanged(Models::Item* item, int row, int col)
|
|
{
|
|
Item* parent = item->parentItem();
|
|
if (parent != nullptr && parent == this) {
|
|
if (item->columnInvolvedInDisplay(col)) {
|
|
int newRow = 0;
|
|
std::deque<Item*>::const_iterator before = childItems.begin();
|
|
|
|
Type ct = item->type;
|
|
if (ct == reference) {
|
|
ct = static_cast<Reference*>(item)->dereference()->type;
|
|
}
|
|
while (before != childItems.end()) {
|
|
Item* bfr = *before;
|
|
Type bt = bfr->type;
|
|
if (bt == reference) {
|
|
bt = static_cast<Reference*>(bfr)->dereference()->type;
|
|
}
|
|
if (bt > ct) {
|
|
break;
|
|
} else if (bt == ct && bfr->getDisplayedName() > item->getDisplayedName()) {
|
|
break;
|
|
}
|
|
newRow++;
|
|
before++;
|
|
}
|
|
|
|
if (newRow != row || (before != childItems.end() && *before != item)) {
|
|
emit childIsAboutToBeMoved(this, row, row, this, newRow);
|
|
std::deque<Item*>::const_iterator old = childItems.begin();
|
|
old += row;
|
|
childItems.erase(old);
|
|
childItems.insert(before, item);
|
|
emit childMoved();
|
|
}
|
|
}
|
|
}
|
|
emit childChanged(item, row, col);
|
|
}
|
|
|
|
bool Models::Item::columnInvolvedInDisplay(int col)
|
|
{
|
|
return col == 0;
|
|
}
|
|
|
|
void Models::Item::addReference(Models::Reference* ref)
|
|
{
|
|
references.insert(ref);
|
|
}
|
|
|
|
void Models::Item::removeReference(Models::Reference* ref)
|
|
{
|
|
std::set<Reference*>::const_iterator itr = references.find(ref);
|
|
if (itr != references.end()) {
|
|
references.erase(itr);
|
|
}
|
|
}
|
|
|
|
int Models::Item::getContact(const QString& jid) const
|
|
{
|
|
int index = -1;
|
|
for (std::deque<Item*>::size_type i = 0; i < childItems.size(); ++i) {
|
|
const Models::Item* item = childItems[i];
|
|
const Contact* cnt = nullptr;
|
|
if (item->type == Item::reference) {
|
|
item = static_cast<const Reference*>(item)->dereferenceConst();
|
|
}
|
|
|
|
if (item->type == Item::contact) {
|
|
cnt = static_cast<const Contact*>(item);
|
|
if (cnt->getJid() == jid) {
|
|
index = i;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return index;
|
|
}
|
|
|
|
std::set<Models::Reference *>::size_type Models::Item::referencesCount() const
|
|
{
|
|
return references.size();
|
|
}
|