-
Nicolas Werner authoredNicolas Werner authored
Code owners
Assign users and groups as approvers for specific file changes. Learn more.
roommodel.cpp 24.49 KiB
#include "roommodel.h"
#include <QGuiApplication>
#include <QMetaType>
#include <QSharedPointer>
#include <QtMath>
#include <QDebug>
#include "client.h"
#include "debug_out.h"
Q_DECLARE_METATYPE(std::vector<mtx::events::collections::TimelineEvents>);
Q_DECLARE_METATYPE(std::vector<mtx::events::collections::StateEvents>);
Q_DECLARE_METATYPE(QSharedPointer<Room>);
using namespace mtx::events;
namespace {
template <class T> std::string eventUrl(const Event<T> &) { return ""; }
template <class T> auto eventUrl(const mtx::events::RoomEvent<T> &e) -> decltype(e.content.url) {
return e.content.url;
}
template <class T> std::string eventBody(const Event<T> &) { return ""; }
template <class T> auto eventBody(const mtx::events::RoomEvent<T> &e) -> decltype(e.content.body) {
return e.content.body;
}
template <class T> uint64_t eventHeight(const Event<T> &) { return -1; }
template <class T> auto eventHeight(const mtx::events::RoomEvent<T> &e) -> decltype(e.content.info.h) {
return e.content.info.h;
}
template <class T> uint64_t eventWidth(const Event<T> &) { return -1; }
template <class T> auto eventWidth(const mtx::events::RoomEvent<T> &e) -> decltype(e.content.info.w) {
return e.content.info.w;
}
template <class T> double eventPropHeight(const mtx::events::RoomEvent<T> &e) {
auto w = eventWidth(e);
if (w == 0)
w = 1;
return eventHeight(e) / (double)w;
}
std::string eventBody(const StateEvent<state::Topic> &e) { return e.content.topic; }
std::string eventBody(const StateEvent<state::Name> &e) { return e.content.name; }
std::string eventBody(const StateEvent<state::Member> &e) {
switch (e.content.membership) {
case state::Membership::Invite:
return QCoreApplication::translate("Room", "member_invited: %1 %2")
.arg(QString::fromStdString(e.state_key))
.arg(QString::fromStdString(e.content.display_name))
.toStdString();
case state::Membership::Ban:
return QCoreApplication::translate("Room", "member_banned: %1 %2")
.arg(QString::fromStdString(e.state_key))
.arg(QString::fromStdString(e.content.display_name))
.toStdString();
case state::Membership::Leave:
return QCoreApplication::translate("Room", "member_left: %1")
.arg(QString::fromStdString(e.state_key))
.toStdString();
case state::Membership::Knock:
return QCoreApplication::translate("Room", "member_knocked: %1 %2")
.arg(QString::fromStdString(e.state_key))
.arg(QString::fromStdString(e.content.display_name))
.toStdString();
case state::Membership::Join:
default:
return QCoreApplication::translate("Room", "member_joined: %1 %2") .arg(QString::fromStdString(e.state_key))
.arg(QString::fromStdString(e.content.display_name))
.toStdString();
}
}
template <class T> std::string eventFormattedBody(const Event<T> &) { return ""; }
template <class T> auto eventFormattedBody(const mtx::events::RoomEvent<T> &e) -> decltype(e.content.formatted_body) {
auto temp = e.content.formatted_body;
if (!temp.empty()) {
auto pos = temp.find("<mx-reply>");
if (pos != std::string::npos)
temp.erase(pos, std::string("<mx-reply>").size());
pos = temp.find("</mx-reply>");
if (pos != std::string::npos)
temp.erase(pos, std::string("</mx-reply>").size());
return temp;
} else
return e.content.body;
}
template <class T> auto eventUserId(const mtx::events::RoomEvent<T> &e) -> std::string { return e.sender; }
template <class T> auto eventTimestamp(const mtx::events::Event<T> &e) -> uint64_t { return 0; }
template <class T> auto eventTimestamp(const mtx::events::RoomEvent<T> &e) -> uint64_t { return e.origin_server_ts; }
// template <class T> auto eventEventId(const mtx::events::Event<T> &e) -> std::string { return ""; }
template <class T> auto eventEventId(const mtx::events::RoomEvent<T> &e) -> std::string { return e.event_id; }
template <class T>::EventType::Type toRoomEventType(const Event<T> &e) {
using mtx::events::EventType;
switch (e.type) {
case EventType::RoomKeyRequest:
return ::EventType::KeyRequest;
case EventType::RoomAliases:
return ::EventType::Aliases;
case EventType::RoomAvatar:
return ::EventType::Avatar;
case EventType::RoomCanonicalAlias:
return ::EventType::CanonicalAlias;
case EventType::RoomCreate:
return ::EventType::Create;
case EventType::RoomEncrypted:
return ::EventType::Encrypted;
case EventType::RoomEncryption:
return ::EventType::Encryption;
case EventType::RoomGuestAccess:
return ::EventType::GuestAccess;
case EventType::RoomHistoryVisibility:
return ::EventType::HistoryVisibility;
case EventType::RoomJoinRules:
return ::EventType::JoinRules;
case EventType::RoomMember:
return ::EventType::Member;
case EventType::RoomMessage:
return ::EventType::UnknownMessage;
case EventType::RoomName:
return ::EventType::Name;
case EventType::RoomPowerLevels:
return ::EventType::PowerLevels;
case EventType::RoomTopic:
return ::EventType::Topic;
case EventType::RoomTombstone:
return ::EventType::Tombstone;
case EventType::RoomRedaction:
return ::EventType::Redaction;
case EventType::RoomPinnedEvents:
return ::EventType::PinnedEvents;
case EventType::Sticker:
return ::EventType::Sticker;
case EventType::Tag: return ::EventType::Tag;
case EventType::Unsupported:
default:
return ::EventType::Unsupported;
}
}
::EventType::Type toRoomEventType(const Event<mtx::events::msg::Audio> &e) { return ::EventType::AudioMessage; }
::EventType::Type toRoomEventType(const Event<mtx::events::msg::Emote> &e) { return ::EventType::EmoteMessage; }
::EventType::Type toRoomEventType(const Event<mtx::events::msg::File> &e) { return ::EventType::FileMessage; }
::EventType::Type toRoomEventType(const Event<mtx::events::msg::Image> &e) { return ::EventType::ImageMessage; }
// ::EventType::Type toRoomEventType(const Event<mtx::events::msg::Location> &e) { return
// ::EventType::LocationMessage; }
::EventType::Type toRoomEventType(const Event<mtx::events::msg::Notice> &e) { return ::EventType::NoticeMessage; }
::EventType::Type toRoomEventType(const Event<mtx::events::msg::Text> &e) { return ::EventType::TextMessage; }
::EventType::Type toRoomEventType(const Event<mtx::events::msg::Video> &e) { return ::EventType::VideoMessage; }
} // namespace
Room::Room(QObject *parent) : loadingOlderMessages(false) {
Q_UNUSED(parent);
connect(this, &Room::newEvents, this, &Room::addEvents, Qt::QueuedConnection);
connect(this, &Room::newTags, this, &Room::setTags, Qt::QueuedConnection);
connect(this, &Room::newUnreadState, this, &Room::setUnread, Qt::QueuedConnection);
connect(this, &Room::lastReadSig, this, &Room::lastReadSlot, Qt::AutoConnection);
connect(this, &Room::markReadSig, this, &Room::markReadSlot, Qt::AutoConnection);
this->moveToThread(QGuiApplication::instance()->thread());
}
std::string Room::name() const {
if (!name_.isEmpty()) {
return name_.toStdString();
}
if (!canonical_alias_.isEmpty()) {
return canonical_alias_.toStdString();
}
std::string heroes;
for (const auto &m : members) {
if (!heroes.empty())
heroes += ", ";
if (m != http::client().user_id().to_string()) {
std::string hero_name = memberInfos.at(m).display_name;
heroes += hero_name.empty() ? m : hero_name;
}
}
if (!heroes.empty()) {
return heroes;
}
return QCoreApplication::translate("Room", "Empty Room").toStdString();
}
void Room::addEvents(std::vector<mtx::events::collections::StateEvents> state,
std::vector<mtx::events::collections::TimelineEvents> timeline, std::string prev_batch,
std::string next_batch) {
qDebug() << "p: " << QString::fromStdString(prev_batch);
qDebug() << "n: " << QString::fromStdString(next_batch);
qDebug() << "tp: " << QString::fromStdString(this->prev_batch);
qDebug() << "tn: " << QString::fromStdString(this->next_batch);
using namespace mtx::events;
if (this->prev_batch == next_batch) {
qDebug() << "New events at beginning of timeline";
for (const auto &event : timeline) {
std::string event_id = std::visit([](const auto &e) -> std::string { return eventEventId(e); }, event);
if (!event_id.empty() && eventIds.count(event_id)) {
for (int i = 0; i < (int)this->events.size(); i++) {
if (std::visit([](const auto &e) -> std::string { return eventEventId(e); }, this->events[i]) ==
event_id) {
beginRemoveRows(QModelIndex(), i, i); this->events.erase(this->events.begin() + i);
endRemoveRows();
break;
}
}
}
}
if (!timeline.empty()) {
beginInsertRows(QModelIndex(), (int)0, (int)timeline.size() - 1);
this->events.insert(this->events.begin(), timeline.begin(), timeline.end());
endInsertRows();
}
this->prev_batch = prev_batch;
} else {
auto applyEvent = [this](const auto &e) {
this->eventIds.insert(e.event_id);
if constexpr (std::is_same_v<StateEvent<state::Aliases>, std::decay_t<decltype(e)>>) {
if (this->canonical_alias_.isEmpty() && !e.content.aliases.empty())
this->canonical_alias_ = QString::fromStdString(e.content.aliases.front());
} else if constexpr (std::is_same_v<StateEvent<state::Avatar>, std::decay_t<decltype(e)>>) {
this->avatar_url_ = QString::fromStdString(e.content.url);
} else if constexpr (std::is_same_v<StateEvent<state::CanonicalAlias>, std::decay_t<decltype(e)>>) {
this->canonical_alias_ = QString::fromStdString(e.content.alias);
} else if constexpr (std::is_same_v<StateEvent<state::Create>, std::decay_t<decltype(e)>>) {
this->members.insert(e.content.creator);
} else if constexpr (std::is_same_v<StateEvent<state::Encryption>, std::decay_t<decltype(e)>>) {
} else if constexpr (std::is_same_v<StateEvent<state::GuestAccess>, std::decay_t<decltype(e)>>) {
} else if constexpr (std::is_same_v<StateEvent<state::HistoryVisibility>, std::decay_t<decltype(e)>>) {
} else if constexpr (std::is_same_v<StateEvent<state::JoinRules>, std::decay_t<decltype(e)>>) {
this->join_rule = e.content.join_rule;
} else if constexpr (std::is_same_v<StateEvent<state::Member>, std::decay_t<decltype(e)>>) {
switch (e.content.membership) {
case state::Membership::Join:
case state::Membership::Invite:
this->members.insert(e.state_key);
this->memberInfos[e.state_key] =
MemberInfo{e.content.avatar_url, e.content.display_name, e.state_key};
break;
case state::Membership::Knock:
this->memberInfos[e.state_key] =
MemberInfo{e.content.avatar_url, e.content.display_name, e.state_key};
break;
case state::Membership::Ban:
case state::Membership::Leave:
this->members.erase(e.state_key);
break;
}
} else if constexpr (std::is_same_v<StateEvent<state::Name>, std::decay_t<decltype(e)>>) {
this->name_ = QString::fromStdString(e.content.name);
emit roomNameChanged(name_);
} else if constexpr (std::is_same_v<StateEvent<state::PinnedEvents>, std::decay_t<decltype(e)>>) {
} else if constexpr (std::is_same_v<StateEvent<state::PowerLevels>, std::decay_t<decltype(e)>>) {
} else if constexpr (std::is_same_v<StateEvent<state::Topic>, std::decay_t<decltype(e)>>) {
this->topic_ = QString::fromStdString(e.content.topic);
} else if constexpr (std::is_same_v<StateEvent<state::Tombstone>, std::decay_t<decltype(e)>>) {
this->replacement_room_ = QString::fromStdString(e.content.replacement_room);
} else if constexpr (std::is_same_v<EncryptedEvent<msg::Encrypted>, std::decay_t<decltype(e)>>) {
} else if constexpr (std::is_same_v<RedactionEvent<msg::Redaction>, std::decay_t<decltype(e)>>) {
} else if constexpr (std::is_same_v<Sticker, std::decay_t<decltype(e)>>) {
} else if constexpr (std::is_same_v<RoomEvent<msg::Redacted>, std::decay_t<decltype(e)>>) {
} else if constexpr (std::is_same_v<RoomEvent<msg::Audio>, std::decay_t<decltype(e)>>) {
} else if constexpr (std::is_same_v<RoomEvent<msg::Emote>, std::decay_t<decltype(e)>>) {
} else if constexpr (std::is_same_v<RoomEvent<msg::File>, std::decay_t<decltype(e)>>) {
} else if constexpr (std::is_same_v<RoomEvent<msg::Image>, std::decay_t<decltype(e)>>) {
} else if constexpr (std::is_same_v<RoomEvent<msg::Notice>, std::decay_t<decltype(e)>>) {
}
else if constexpr (std::is_same_v<RoomEvent<msg::Text>, std::decay_t<decltype(e)>>) { } else if constexpr (std::is_same_v<RoomEvent<msg::Video>, std::decay_t<decltype(e)>>) {
}
auto body = QString::fromStdString(eventBody(e));
if (!body.isEmpty()) {
this->msgInfo.body = body;
this->msgInfo.userid = QString::fromStdString(e.sender);
// QString::fromStdString(std::visit([](const auto &e) -> std::string { return eventUserId(e); }, e));
this->msgInfo.datetime = QDateTime::fromMSecsSinceEpoch(e.origin_server_ts);
}
};
for (const mtx::events::collections::StateEvents &e : state)
std::visit(applyEvent, e);
// applyEvent(e.subset<mtx::events::StateEvent<mtx::events::state::Aliases>,
// mtx::events::StateEvent<mtx::events::state::Avatar>,
// mtx::events::StateEvent<mtx::events::state::CanonicalAlias>,
// mtx::events::StateEvent<mtx::events::state::Create>,
// mtx::events::StateEvent<mtx::events::state::Encryption>,
// mtx::events::StateEvent<mtx::events::state::GuestAccess>,
// mtx::events::StateEvent<mtx::events::state::HistoryVisibility>,
// mtx::events::StateEvent<mtx::events::state::JoinRules>,
// mtx::events::StateEvent<mtx::events::state::Member>,
// mtx::events::StateEvent<mtx::events::state::Name>,
// mtx::events::StateEvent<mtx::events::state::PinnedEvents>,
// mtx::events::StateEvent<mtx::events::state::PowerLevels>,
// mtx::events::StateEvent<mtx::events::state::Tombstone>,
// mtx::events::StateEvent<mtx::events::state::Topic>>());
for (const mtx::events::collections::TimelineEvents &e : timeline)
std::visit(applyEvent, e);
if (!timeline.empty()) {
qDebug() << "New events at end of timeline";
beginInsertRows(QModelIndex(), (int)this->events.size(), (int)this->events.size() + timeline.size() - 1);
this->events.insert(this->events.end(), timeline.begin(), timeline.end());
endInsertRows();
}
this->next_batch = next_batch;
}
if (this->prev_batch.empty())
this->prev_batch = prev_batch;
if (this->next_batch.empty())
this->next_batch = next_batch;
}
void Room::fetchOlderMessages() {
if (this->loadingOlderMessages.exchange(true)) {
qDebug() << "Already loading older messages";
return;
}
mtx::http::MessagesOpts opts = {};
opts.from = this->prev_batch;
opts.limit = 100;
opts.room_id = this->id;
http::client().messages(opts, [this](const mtx::responses::Messages &res, mtx::http::RequestErr err) {
if (err) {
qDebug() << "failed to retrieve messages: " << *err;
this->loadingOlderMessages = false;
return;
}
emit newEvents({}, {res.chunk.rbegin(), res.chunk.rend()}, res.end, res.start);
this->loadingOlderMessages = false;
});
}
void Room::sendTextMessage(QString message) {
using mtx::events::EventType;
mtx::events::msg::Text text;
text.body = message.trimmed().toStdString();
http::client().send_room_message<msg::Text, EventType::RoomMessage>(
this->id, http::client().generate_txn_id(), text,
[this](const mtx::responses::EventId &res, mtx::http::RequestErr err) {
if (err) {
qDebug() << "failed to send message: " << *err;
return;
}
qDebug() << "send event as: $" << QString::fromStdString(res.event_id.to_string());
});
}
QHash<int, QByteArray> Room::roleNames() const {
QHash<int, QByteArray> roles;
roles[Type] = "Type";
roles[Body] = "Body";
roles[FormattedBody] = "FormattedBody";
roles[UserId] = "UserId";
roles[UserName] = "UserName";
roles[Timestamp] = "Timestamp";
roles[Url] = "Url";
roles[Height] = "Height";
roles[Width] = "Width";
roles[ProportionalHeight] = "ProportionalHeight";
return roles;
}
int Room::rowCount(const QModelIndex &parent) const { return (int)events.size(); }
QVariant Room::data(const QModelIndex &index, int role) const {
if (index.row() > (int)events.size() || index.row() < 0)
return QVariant();
auto event = events.at(index.row());
switch (role) {
case Type:
return std::visit([](const auto &e) -> ::EventType::Type { return toRoomEventType(e); }, event);
case Body:
return QString::fromStdString(std::visit([](const auto &e) -> std::string { return eventBody(e); }, event));
case FormattedBody:
return QString::fromStdString(
std::visit([](const auto &e) -> std::string { return eventFormattedBody(e); }, event));
case UserId:
return QString::fromStdString(std::visit([](const auto &e) -> std::string { return eventUserId(e); }, event));
case UserName:
return QString::fromStdString(std::visit(
[this](const auto &e) -> std::string {
try {
return this->memberInfos.at(eventUserId(e)).display_name;
} catch (...) {
return "";
}
},
event));
case Timestamp:
return QDateTime::fromMSecsSinceEpoch(
std::visit([](const auto &e) -> uint64_t { return eventTimestamp(e); }, event));
case Url:
return QString::fromStdString(std::visit([](const auto &e) -> std::string { return eventUrl(e); }, event));
case Height:
return std::visit([](const auto &e) -> uint64_t { return eventHeight(e); }, event);
case Width:
return std::visit([](const auto &e) -> uint64_t { return eventWidth(e); }, event);
case ProportionalHeight:
return std::visit([](const auto &e) -> double { return eventPropHeight(e); }, event);
default: return QVariant();
}
}
QString Room::userIdToUserName(QString id) {
try {
return QString::fromStdString(this->memberInfos.at(id.toStdString()).display_name);
} catch (...) {
return "";
}
}
// from nheko
QColor Room::userColor(QString id, QColor background) {
if (userColors.count(id))
return userColors.at(id);
auto luminance = [](const QColor &col) -> qreal {
int colRgb[3] = {col.red(), col.green(), col.blue()};
qreal lumRgb[3];
for (int i = 0; i < 3; i++) {
qreal v = colRgb[i] / 255.0;
v <= 0.03928 ? lumRgb[i] = v / 12.92 : lumRgb[i] = qPow((v + 0.055) / 1.055, 2.4);
}
auto lum = lumRgb[0] * 0.2126 + lumRgb[1] * 0.7152 + lumRgb[2] * 0.0722;
return lum;
};
auto computeContrast = [](const qreal &one, const qreal &two) -> qreal {
auto ratio = (one + 0.05) / (two + 0.05);
if (two > one) {
ratio = 1 / ratio;
}
return ratio;
};
auto hashQString = [](const QString &input) {
unsigned hash = 0;
for (int i = 0; i < input.length(); i++) {
hash = input.at(i).digitValue() + ((hash << 5) - hash);
}
return (int)hash;
};
const qreal backgroundLum = luminance(background);
// Create a color for the input
auto hash = hashQString(id);
// create a hue value based on the hash of the input.
auto userHue = qAbs(hash % 360);
// start with moderate saturation and lightness values.
auto sat = 220;
auto lightness = 125;
// converting to a QColor makes the luminance calc easier.
QColor inputColor = QColor::fromHsl(userHue, sat, lightness);
// calculate the initial luminance and contrast of the
// generated color. It's possible that no additional
// work will be necessary.
auto lum = luminance(inputColor);
auto contrast = computeContrast(lum, backgroundLum);
// If the contrast doesn't meet our criteria,
// try again and again until they do by modifying first
// the lightness and then the saturation of the color.
while (contrast < 5) {
// if our lightness is at it's bounds, try changing
// saturation instead.
if (lightness == 242 || lightness == 13) {
qreal newSat = qBound(26.0, sat * 1.25, 242.0);
inputColor.setHsl(userHue, qFloor(newSat), lightness);
auto tmpLum = luminance(inputColor);
auto higherContrast = computeContrast(tmpLum, backgroundLum);
if (higherContrast > contrast) {
contrast = higherContrast;
sat = newSat;
} else {
newSat = qBound(26.0, sat / 1.25, 242.0);
inputColor.setHsl(userHue, qFloor(newSat), lightness);
tmpLum = luminance(inputColor);
auto lowerContrast = computeContrast(tmpLum, backgroundLum);
if (lowerContrast > contrast) {
contrast = lowerContrast;
sat = newSat;
}
}
} else {
qreal newLightness = qBound(13.0, lightness * 1.25, 242.0);
inputColor.setHsl(userHue, sat, qFloor(newLightness));
auto tmpLum = luminance(inputColor);
auto higherContrast = computeContrast(tmpLum, backgroundLum);
// Check to make sure we have actually improved contrast
if (higherContrast > contrast) {
contrast = higherContrast;
lightness = newLightness;
// otherwise, try going the other way instead.
} else {
newLightness = qBound(13.0, lightness / 1.25, 242.0);
inputColor.setHsl(userHue, sat, qFloor(newLightness));
tmpLum = luminance(inputColor);
auto lowerContrast = computeContrast(tmpLum, backgroundLum);
if (lowerContrast > contrast) {
contrast = lowerContrast;
lightness = newLightness;
}
}
}
}
userColors[id] = inputColor;
return inputColor;
}
void Room::markRead(int index) { emit markReadSig(index); }
void Room::markReadSlot(int index) {
qDebug() << "called";
if (index < 0 || index >= (int)events.size())
return;
auto event_id = std::visit([](const auto &e) -> std::string { return eventEventId(e); }, events[index]);
http::client().read_event(id, event_id, [](mtx::http::RequestErr e) {
if (e)
qDebug() << "Error marking event as read: " << *e;
});
lastRead_ = event_id;
qDebug() << "marked " << QString::fromStdString(event_id) << " as read";}
int Room::lastRead() { return emit lastReadSig(); }
int Room::lastReadSlot() {
qDebug() << "called";
if (lastRead_.empty())
return 0;
for (size_t index = events.size(); index > 0; index--) {
auto event_id = std::visit([](const auto &e) -> std::string { return eventEventId(e); }, events[index - 1]);
if (event_id == lastRead_)
return index - 1;
}
qWarning() << "Last read event " << QString::fromStdString(lastRead_) << " not found in events";
return 0;
}