matrixion/src/timeline/TimelineModel.h

291 lines
8.8 KiB
C
Raw Normal View History

2019-08-31 00:20:53 +03:00
#pragma once
#include <QAbstractListModel>
#include <QColor>
#include <QDate>
2019-08-31 23:43:31 +03:00
#include <QHash>
2019-09-18 23:58:25 +03:00
#include <QSet>
2019-08-31 00:20:53 +03:00
#include <mtxclient/http/errors.hpp>
#include "CacheCryptoStructs.h"
2020-07-10 00:15:22 +03:00
#include "EventStore.h"
namespace mtx::http {
using RequestErr = const std::optional<mtx::http::ClientError> &;
}
2020-01-31 08:12:02 +03:00
namespace mtx::responses {
struct Timeline;
struct Messages;
struct ClaimKeys;
}
2020-04-13 17:22:30 +03:00
struct RelatedInfo;
namespace qml_mtx_events {
Q_NAMESPACE
enum EventType
{
// Unsupported event
Unsupported,
/// m.room_key_request
KeyRequest,
/// m.reaction,
Reaction,
/// m.room.aliases
Aliases,
/// m.room.avatar
Avatar,
/// m.room.canonical_alias
CanonicalAlias,
/// m.room.create
RoomCreate,
/// m.room.encrypted.
Encrypted,
/// m.room.encryption.
Encryption,
/// m.room.guest_access
RoomGuestAccess,
/// m.room.history_visibility
RoomHistoryVisibility,
/// m.room.join_rules
RoomJoinRules,
/// m.room.member
Member,
/// m.room.name
Name,
/// m.room.power_levels
PowerLevels,
/// m.room.tombstone
Tombstone,
/// m.room.topic
Topic,
/// m.room.redaction
Redaction,
/// m.room.pinned_events
PinnedEvents,
// m.sticker
Sticker,
// m.tag
Tag,
/// m.room.message
AudioMessage,
EmoteMessage,
FileMessage,
ImageMessage,
LocationMessage,
NoticeMessage,
TextMessage,
VideoMessage,
2019-09-09 22:42:33 +03:00
Redacted,
UnknownMessage,
};
Q_ENUM_NS(EventType)
2019-09-18 23:58:25 +03:00
enum EventState
{
//! The plaintext message was received by the server.
Received,
//! At least one of the participants has read the message.
Read,
//! The client sent the message. Not yet received.
Sent,
//! When the message is loaded from cache or backfill.
Empty,
};
Q_ENUM_NS(EventState)
}
2019-09-19 23:44:25 +03:00
class StateKeeper
{
public:
StateKeeper(std::function<void()> &&fn)
: fn_(std::move(fn))
{}
~StateKeeper() { fn_(); }
private:
std::function<void()> fn_;
};
2019-09-08 17:50:32 +03:00
struct DecryptionResult
{
//! The decrypted content as a normal plaintext event.
mtx::events::collections::TimelineEvents event;
//! Whether or not the decryption was successful.
bool isDecrypted = false;
};
2019-10-03 19:07:01 +03:00
class TimelineViewManager;
2019-08-31 00:20:53 +03:00
class TimelineModel : public QAbstractListModel
{
Q_OBJECT
2019-09-18 21:34:30 +03:00
Q_PROPERTY(
int currentIndex READ currentIndex WRITE setCurrentIndex NOTIFY currentIndexChanged)
2020-01-17 03:25:14 +03:00
Q_PROPERTY(std::vector<QString> typingUsers READ typingUsers WRITE updateTypingUsers NOTIFY
typingUsersChanged)
2020-04-13 17:22:30 +03:00
Q_PROPERTY(QString reply READ reply WRITE setReply NOTIFY replyChanged RESET resetReply)
2020-05-01 08:40:27 +03:00
Q_PROPERTY(
bool paginationInProgress READ paginationInProgress NOTIFY paginationInProgressChanged)
2019-08-31 00:20:53 +03:00
public:
2020-02-04 23:16:04 +03:00
explicit TimelineModel(TimelineViewManager *manager,
QString room_id,
QObject *parent = nullptr);
2019-08-31 00:20:53 +03:00
enum Roles
{
Section,
2019-08-31 00:20:53 +03:00
Type,
2020-01-23 22:59:17 +03:00
TypeString,
IsOnlyEmoji,
2019-08-31 00:20:53 +03:00
Body,
FormattedBody,
UserId,
UserName,
Timestamp,
Url,
2019-10-09 01:36:03 +03:00
ThumbnailUrl,
Blurhash,
2019-09-29 11:45:35 +03:00
Filename,
2019-10-04 02:10:46 +03:00
Filesize,
2019-09-29 11:45:35 +03:00
MimeType,
Height,
Width,
ProportionalHeight,
2019-09-08 16:26:46 +03:00
Id,
2019-09-18 23:58:25 +03:00
State,
2019-09-20 00:02:56 +03:00
IsEncrypted,
IsRoomEncrypted,
ReplyTo,
2020-05-04 14:14:54 +03:00
Reactions,
RoomId,
RoomName,
RoomTopic,
2020-01-04 01:21:33 +03:00
Dump,
2019-08-31 00:20:53 +03:00
};
QHash<int, QByteArray> roleNames() const override;
int rowCount(const QModelIndex &parent = QModelIndex()) const override;
QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override;
2020-07-10 00:15:22 +03:00
QVariant data(const mtx::events::collections::TimelineEvents &event, int role) const;
2019-08-31 00:20:53 +03:00
bool canFetchMore(const QModelIndex &) const override;
void fetchMore(const QModelIndex &) override;
Q_INVOKABLE QString displayName(QString id) const;
2019-09-07 23:22:07 +03:00
Q_INVOKABLE QString avatarUrl(QString id) const;
Q_INVOKABLE QString formatDateSeparator(QDate date) const;
2020-01-17 03:25:14 +03:00
Q_INVOKABLE QString formatTypingUsers(const std::vector<QString> &users, QColor bg);
2020-01-23 22:34:04 +03:00
Q_INVOKABLE QString formatMemberEvent(QString id);
Q_INVOKABLE QString formatJoinRuleEvent(QString id);
Q_INVOKABLE QString formatHistoryVisibilityEvent(QString id);
Q_INVOKABLE QString formatGuestAccessEvent(QString id);
Q_INVOKABLE QString formatPowerLevelEvent(QString id);
2019-10-03 19:07:01 +03:00
2019-09-07 03:01:44 +03:00
Q_INVOKABLE QString escapeEmoji(QString str) const;
2019-09-08 16:26:46 +03:00
Q_INVOKABLE void viewRawMessage(QString id) const;
Q_INVOKABLE void viewDecryptedRawMessage(QString id) const;
Q_INVOKABLE void openUserProfile(QString userid) const;
2019-09-11 01:54:40 +03:00
Q_INVOKABLE void replyAction(QString id);
Q_INVOKABLE void readReceiptsAction(QString id) const;
2019-09-29 13:29:17 +03:00
Q_INVOKABLE void redactEvent(QString id);
2019-09-18 21:34:30 +03:00
Q_INVOKABLE int idToIndex(QString id) const;
Q_INVOKABLE QString indexToId(int index) const;
2019-12-03 04:26:41 +03:00
Q_INVOKABLE void cacheMedia(QString eventId);
Q_INVOKABLE bool saveMedia(QString eventId) const;
2020-04-24 02:21:20 +03:00
void updateLastMessage();
2019-08-31 23:43:31 +03:00
void addEvents(const mtx::responses::Timeline &events);
template<class T>
void sendMessage(const T &msg);
2020-04-13 17:22:30 +03:00
RelatedInfo relatedInfo(QString id);
2019-08-31 23:43:31 +03:00
public slots:
2019-10-03 23:39:56 +03:00
void setCurrentIndex(int index);
2019-09-18 21:34:30 +03:00
int currentIndex() const { return idToIndex(currentId); }
void markEventsAsRead(const std::vector<QString> &event_ids);
2020-07-10 00:15:22 +03:00
QVariantMap getDump(QString eventId, QString relatedTo) const;
2020-01-17 03:25:14 +03:00
void updateTypingUsers(const std::vector<QString> &users)
{
if (this->typingUsers_ != users) {
this->typingUsers_ = users;
emit typingUsersChanged(typingUsers_);
}
}
std::vector<QString> typingUsers() const { return typingUsers_; }
bool paginationInProgress() const { return m_paginationInProgress; }
2020-04-13 17:22:30 +03:00
QString reply() const { return reply_; }
void setReply(QString newReply)
{
if (reply_ != newReply) {
reply_ = newReply;
emit replyChanged(reply_);
}
}
void resetReply()
{
if (!reply_.isEmpty()) {
reply_ = "";
emit replyChanged(reply_);
}
}
2020-04-24 02:21:20 +03:00
void setDecryptDescription(bool decrypt) { decryptDescription = decrypt; }
2020-04-13 17:22:30 +03:00
private slots:
void addPendingMessage(mtx::events::collections::TimelineEvents event);
signals:
2019-09-18 21:34:30 +03:00
void currentIndexChanged(int index);
2019-09-29 13:29:17 +03:00
void redactionFailed(QString id);
void eventRedacted(QString id);
2019-12-03 04:26:41 +03:00
void mediaCached(QString mxcUrl, QString cacheUrl);
void newEncryptedImage(mtx::crypto::EncryptedFile encryptionInfo);
2020-01-17 03:25:14 +03:00
void typingUsersChanged(std::vector<QString> users);
2020-04-13 17:22:30 +03:00
void replyChanged(QString reply);
void paginationInProgressChanged(const bool);
2020-07-18 18:43:49 +03:00
void newMessageToSend(mtx::events::collections::TimelineEvents event);
void addPendingMessageToStore(mtx::events::collections::TimelineEvents event);
2019-08-31 00:20:53 +03:00
private:
2020-07-18 18:43:49 +03:00
void sendEncryptedMessage(const std::string txn_id, nlohmann::json content);
2019-09-19 23:44:25 +03:00
void handleClaimedKeys(std::shared_ptr<StateKeeper> keeper,
const std::map<std::string, std::string> &room_key,
const std::map<std::string, DevicePublicKeys> &pks,
const std::string &user_id,
const mtx::responses::ClaimKeys &res,
mtx::http::RequestErr err);
void readEvent(const std::string &id);
2019-09-08 17:50:32 +03:00
void setPaginationInProgress(const bool paginationInProgress);
QSet<QString> read;
2019-08-31 00:20:53 +03:00
2020-07-10 00:15:22 +03:00
mutable EventStore events;
QString room_id_;
2020-05-01 08:40:27 +03:00
bool decryptDescription = true;
bool m_paginationInProgress = false;
2019-09-18 21:34:30 +03:00
QString currentId;
2020-04-13 17:22:30 +03:00
QString reply_;
2020-01-17 03:25:14 +03:00
std::vector<QString> typingUsers_;
2019-10-03 19:07:01 +03:00
TimelineViewManager *manager_;
friend struct SendMessageVisitor;
2019-08-31 00:20:53 +03:00
};
template<class T>
void
TimelineModel::sendMessage(const T &msg)
{
2019-09-18 23:58:25 +03:00
mtx::events::RoomEvent<T> msgCopy = {};
msgCopy.content = msg;
emit newMessageToSend(msgCopy);
}