matrixion/include/timeline/TimelineView.h

312 lines
10 KiB
C
Raw Normal View History

2017-04-06 02:06:42 +03:00
/*
* nheko Copyright (C) 2017 Konstantinos Sideris <siderisk@auth.gr>
*
* 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/>.
*/
#pragma once
2017-04-06 02:06:42 +03:00
2017-11-30 00:39:35 +03:00
#include <QApplication>
#include <QDebug>
2017-10-28 15:46:39 +03:00
#include <QLayout>
2017-04-06 02:06:42 +03:00
#include <QList>
#include <QQueue>
2017-04-06 02:06:42 +03:00
#include <QScrollArea>
#include <QStyle>
#include <QStyleOption>
2017-04-06 02:06:42 +03:00
#include <mtx/events.hpp>
#include <mtx/responses/messages.hpp>
#include "MatrixClient.h"
#include "ScrollBar.h"
2017-11-30 00:39:35 +03:00
#include "TimelineItem.h"
2017-10-27 22:20:33 +03:00
class FloatingButton;
2017-10-28 15:46:39 +03:00
struct DescInfo;
2017-10-27 22:20:33 +03:00
// Contains info about a message shown in the history view
// but not yet confirmed by the homeserver through sync.
2017-10-15 22:08:51 +03:00
struct PendingMessage
{
mtx::events::MessageType ty;
2017-08-26 11:33:26 +03:00
int txn_id;
QString body;
QString filename;
2017-08-26 11:33:26 +03:00
QString event_id;
TimelineItem *widget;
PendingMessage(mtx::events::MessageType ty,
2017-11-15 19:42:21 +03:00
int txn_id,
QString body,
QString filename,
QString event_id,
TimelineItem *widget)
: ty(ty)
, txn_id(txn_id)
2017-08-26 11:33:26 +03:00
, body(body)
, filename(filename)
2017-08-26 11:33:26 +03:00
, event_id(event_id)
, widget(widget)
2017-10-15 22:08:51 +03:00
{}
};
// In which place new TimelineItems should be inserted.
2017-10-15 22:08:51 +03:00
enum class TimelineDirection
{
2017-08-26 11:33:26 +03:00
Top,
Bottom,
};
class TimelineView : public QWidget
2017-04-06 02:06:42 +03:00
{
2017-08-26 11:33:26 +03:00
Q_OBJECT
2017-04-06 02:06:42 +03:00
public:
TimelineView(const mtx::responses::Timeline &timeline,
2017-08-26 11:33:26 +03:00
QSharedPointer<MatrixClient> client,
const QString &room_id,
QWidget *parent = 0);
TimelineView(QSharedPointer<MatrixClient> client,
const QString &room_id,
QWidget *parent = 0);
// Add new events at the end of the timeline.
int addEvents(const mtx::responses::Timeline &timeline);
void addUserMessage(mtx::events::MessageType ty, const QString &msg);
2017-11-30 00:39:35 +03:00
template<class Widget, mtx::events::MessageType MsgType>
void addUserMessage(const QString &url,
const QString &filename,
const QSharedPointer<QIODevice> data = Q_NULLPTR);
2017-08-26 11:33:26 +03:00
void updatePendingMessage(int txn_id, QString event_id);
void scrollDown();
void addDateSeparator(QDateTime datetime, int position);
2017-04-06 02:06:42 +03:00
public slots:
2017-08-26 11:33:26 +03:00
void sliderRangeChanged(int min, int max);
void sliderMoved(int position);
void fetchHistory();
2017-08-26 11:33:26 +03:00
// Add old events at the top of the timeline.
void addBackwardsEvents(const QString &room_id, const mtx::responses::Messages &msgs);
2017-04-06 02:06:42 +03:00
2017-10-07 20:50:32 +03:00
// Whether or not the initial batch has been loaded.
bool hasLoaded() { return scroll_layout_->count() > 1 || isTimelineFinished; }
2017-10-07 20:50:32 +03:00
void handleFailedMessage(int txnid);
private slots:
void sendNextPendingMessage();
signals:
2017-08-26 11:33:26 +03:00
void updateLastTimelineMessage(const QString &user, const DescInfo &info);
void clearUnreadMessageCount(const QString &room_id);
protected:
void paintEvent(QPaintEvent *event) override;
void showEvent(QShowEvent *event) override;
bool event(QEvent *event) override;
2017-04-06 02:06:42 +03:00
private:
using TimelineEvent = mtx::events::collections::TimelineEvents;
2017-08-26 11:33:26 +03:00
void init();
void addTimelineItem(TimelineItem *item, TimelineDirection direction);
void updateLastSender(const QString &user_id, TimelineDirection direction);
void notifyForLastEvent();
void notifyForLastEvent(const TimelineEvent &event);
void readLastEvent() const;
bool isScrollbarActivated() { return scroll_area_->verticalScrollBar()->value() != 0; }
QString getLastEventId() const;
QString getEventSender(const mtx::events::collections::TimelineEvents &event) const;
template<class Event, class Widget>
TimelineItem *processMessageEvent(const Event &event, TimelineDirection direction);
// TODO: Remove this eventually.
template<class Event>
TimelineItem *processMessageEvent(const Event &event, TimelineDirection direction);
// For events with custom display widgets.
template<class Event, class Widget>
TimelineItem *createTimelineItem(const Event &event, bool withSender);
// For events without custom display widgets.
// TODO: All events should have custom widgets.
template<class Event>
TimelineItem *createTimelineItem(const Event &event, bool withSender);
2017-10-01 12:11:33 +03:00
// Used to determine whether or not we should prefix a message with the
// sender's name.
2017-08-26 11:33:26 +03:00
bool isSenderRendered(const QString &user_id, TimelineDirection direction);
2017-11-15 19:42:21 +03:00
bool isPendingMessage(const QString &txnid, const QString &sender, const QString &userid);
void removePendingMessage(const QString &txnid);
bool isDuplicate(const QString &event_id) { return eventIds_.contains(event_id); }
2017-04-06 02:06:42 +03:00
void handleNewUserMessage(PendingMessage msg);
2017-08-26 11:33:26 +03:00
// Return nullptr if the event couldn't be parsed.
TimelineItem *parseMessageEvent(const mtx::events::collections::TimelineEvents &event,
TimelineDirection direction);
2017-08-26 11:33:26 +03:00
QVBoxLayout *top_layout_;
QVBoxLayout *scroll_layout_;
2017-04-06 02:06:42 +03:00
2017-08-26 11:33:26 +03:00
QScrollArea *scroll_area_;
ScrollBar *scrollbar_;
QWidget *scroll_widget_;
2017-04-06 02:06:42 +03:00
2017-08-26 11:33:26 +03:00
QString lastSender_;
QString firstSender_;
QString room_id_;
QString prev_batch_token_;
QString local_user_;
bool isPaginationInProgress_ = false;
// Keeps track whether or not the user has visited the view.
2017-10-09 01:32:25 +03:00
bool isInitialized = false;
bool isTimelineFinished = false;
bool isInitialSync = true;
const int SCROLL_BAR_GAP = 200;
2017-08-26 11:33:26 +03:00
QTimer *paginationTimer_;
2017-08-26 11:33:26 +03:00
int scroll_height_ = 0;
int previous_max_height_ = 0;
2017-08-26 11:33:26 +03:00
int oldPosition_;
int oldHeight_;
2017-10-27 22:20:33 +03:00
FloatingButton *scrollDownBtn_;
TimelineDirection lastMessageDirection_;
//! Messages received by sync not added to the timeline.
std::vector<TimelineEvent> bottomMessages_;
//! Render the given timeline events to the bottom of the timeline.
void renderBottomEvents(const std::vector<TimelineEvent> &events);
//! Decide if the given timeline event can be rendered.
inline bool isViewable(const TimelineEvent &event) const;
//! Decide if the given event should trigger a notification.
inline bool isNotifiable(const TimelineEvent &event) const;
2017-08-26 11:33:26 +03:00
// The events currently rendered. Used for duplicate detection.
QMap<QString, bool> eventIds_;
QQueue<PendingMessage> pending_msgs_;
QList<PendingMessage> pending_sent_msgs_;
2017-08-26 11:33:26 +03:00
QSharedPointer<MatrixClient> client_;
2017-04-06 02:06:42 +03:00
};
2017-11-30 00:39:35 +03:00
template<class Widget, mtx::events::MessageType MsgType>
2017-11-30 00:39:35 +03:00
void
TimelineView::addUserMessage(const QString &url,
const QString &filename,
const QSharedPointer<QIODevice> data)
2017-11-30 00:39:35 +03:00
{
auto with_sender = lastSender_ != local_user_;
2017-11-30 00:39:35 +03:00
auto widget = new Widget(client_, url, data, filename, this);
2017-11-30 00:39:35 +03:00
TimelineItem *view_item =
new TimelineItem(widget, local_user_, with_sender, scroll_widget_);
2017-11-30 00:39:35 +03:00
scroll_layout_->addWidget(view_item);
lastMessageDirection_ = TimelineDirection::Bottom;
QApplication::processEvents();
lastSender_ = local_user_;
2017-11-30 00:39:35 +03:00
int txn_id = client_->incrementTransactionId();
PendingMessage message(MsgType, txn_id, url, filename, "", view_item);
handleNewUserMessage(message);
}
2017-11-30 13:55:30 +03:00
template<class Event>
TimelineItem *
TimelineView::createTimelineItem(const Event &event, bool withSender)
{
TimelineItem *item = new TimelineItem(event, withSender, scroll_widget_);
return item;
}
template<class Event, class Widget>
TimelineItem *
TimelineView::createTimelineItem(const Event &event, bool withSender)
{
auto eventWidget = new Widget(client_, event);
auto item = new TimelineItem(eventWidget, event, withSender, scroll_widget_);
return item;
}
template<class Event>
TimelineItem *
TimelineView::processMessageEvent(const Event &event, TimelineDirection direction)
{
const auto event_id = QString::fromStdString(event.event_id);
const auto sender = QString::fromStdString(event.sender);
if (isDuplicate(event_id))
return nullptr;
eventIds_[event_id] = true;
const QString txnid = QString::fromStdString(event.unsigned_data.transaction_id);
if (!txnid.isEmpty() && isPendingMessage(txnid, sender, local_user_)) {
removePendingMessage(txnid);
return nullptr;
}
auto with_sender = isSenderRendered(sender, direction);
updateLastSender(sender, direction);
return createTimelineItem<Event>(event, with_sender);
}
template<class Event, class Widget>
TimelineItem *
TimelineView::processMessageEvent(const Event &event, TimelineDirection direction)
{
const auto event_id = QString::fromStdString(event.event_id);
const auto sender = QString::fromStdString(event.sender);
if (isDuplicate(event_id))
return nullptr;
eventIds_[event_id] = true;
const QString txnid = QString::fromStdString(event.unsigned_data.transaction_id);
if (!txnid.isEmpty() && isPendingMessage(txnid, sender, local_user_)) {
removePendingMessage(txnid);
return nullptr;
}
auto with_sender = isSenderRendered(sender, direction);
updateLastSender(sender, direction);
return createTimelineItem<Event, Widget>(event, with_sender);
}