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/>.
|
|
|
|
*/
|
|
|
|
|
2017-10-21 18:53:15 +03:00
|
|
|
#include <QApplication>
|
2017-04-06 02:06:42 +03:00
|
|
|
#include <QDebug>
|
|
|
|
#include <QSettings>
|
2017-10-21 21:17:01 +03:00
|
|
|
#include <QtConcurrent>
|
2017-04-06 02:06:42 +03:00
|
|
|
|
2017-08-26 13:49:16 +03:00
|
|
|
#include "AvatarProvider.h"
|
2017-10-28 15:46:39 +03:00
|
|
|
#include "Cache.h"
|
2017-04-06 02:06:42 +03:00
|
|
|
#include "ChatPage.h"
|
2017-08-26 13:49:16 +03:00
|
|
|
#include "MainWindow.h"
|
2017-10-28 15:46:39 +03:00
|
|
|
#include "MatrixClient.h"
|
|
|
|
#include "OverlayModal.h"
|
|
|
|
#include "QuickSwitcher.h"
|
|
|
|
#include "RoomList.h"
|
|
|
|
#include "RoomSettings.h"
|
|
|
|
#include "RoomState.h"
|
|
|
|
#include "SideBarActions.h"
|
2017-05-19 19:55:38 +03:00
|
|
|
#include "Splitter.h"
|
2017-10-28 15:46:39 +03:00
|
|
|
#include "TextInputWidget.h"
|
2017-05-19 19:55:38 +03:00
|
|
|
#include "Theme.h"
|
2017-10-28 15:46:39 +03:00
|
|
|
#include "TopRoomBar.h"
|
|
|
|
#include "TypingDisplay.h"
|
2017-04-06 02:06:42 +03:00
|
|
|
#include "UserInfoWidget.h"
|
2017-12-30 18:29:57 +03:00
|
|
|
#include "UserSettingsPage.h"
|
2017-04-06 02:06:42 +03:00
|
|
|
|
2018-01-03 19:05:49 +03:00
|
|
|
#include "dialogs/ReadReceipts.h"
|
2017-11-30 14:53:28 +03:00
|
|
|
#include "timeline/TimelineViewManager.h"
|
|
|
|
|
2017-10-20 22:32:48 +03:00
|
|
|
constexpr int MAX_INITIAL_SYNC_FAILURES = 5;
|
2017-10-23 00:19:35 +03:00
|
|
|
constexpr int SYNC_RETRY_TIMEOUT = 10000;
|
2017-10-20 22:32:48 +03:00
|
|
|
|
2018-01-03 19:05:49 +03:00
|
|
|
ChatPage *ChatPage::instance_ = nullptr;
|
|
|
|
|
2017-12-30 18:29:57 +03:00
|
|
|
ChatPage::ChatPage(QSharedPointer<MatrixClient> client,
|
|
|
|
QSharedPointer<UserSettings> userSettings,
|
|
|
|
QWidget *parent)
|
2017-08-20 13:47:22 +03:00
|
|
|
: QWidget(parent)
|
|
|
|
, client_(client)
|
2017-12-30 18:29:57 +03:00
|
|
|
, userSettings_{userSettings}
|
2017-04-06 02:06:42 +03:00
|
|
|
{
|
2017-11-16 17:33:52 +03:00
|
|
|
setObjectName("chatPage");
|
2017-05-19 19:55:38 +03:00
|
|
|
|
2017-08-26 13:49:16 +03:00
|
|
|
topLayout_ = new QHBoxLayout(this);
|
|
|
|
topLayout_->setSpacing(0);
|
|
|
|
topLayout_->setMargin(0);
|
|
|
|
|
2018-01-09 16:07:32 +03:00
|
|
|
communitiesSideBar_ = new QWidget(this);
|
|
|
|
communitiesSideBar_->setFixedWidth(ui::sidebar::CommunitiesSidebarSize);
|
|
|
|
communitiesSideBarLayout_ = new QVBoxLayout(communitiesSideBar_);
|
|
|
|
communitiesSideBarLayout_->setSpacing(0);
|
|
|
|
communitiesSideBarLayout_->setMargin(0);
|
|
|
|
|
|
|
|
communitiesList_ = new CommunitiesList(client, this);
|
|
|
|
communitiesSideBarLayout_->addWidget(communitiesList_);
|
|
|
|
// communitiesSideBarLayout_->addStretch(1);
|
|
|
|
topLayout_->addWidget(communitiesSideBar_);
|
|
|
|
|
2017-08-26 13:49:16 +03:00
|
|
|
auto splitter = new Splitter(this);
|
|
|
|
splitter->setHandleWidth(0);
|
|
|
|
|
|
|
|
topLayout_->addWidget(splitter);
|
|
|
|
|
|
|
|
// SideBar
|
2017-11-09 00:09:15 +03:00
|
|
|
sideBar_ = new QFrame(this);
|
2017-12-17 18:49:22 +03:00
|
|
|
sideBar_->setMinimumWidth(ui::sidebar::NormalSize);
|
2017-08-26 13:49:16 +03:00
|
|
|
sideBarLayout_ = new QVBoxLayout(sideBar_);
|
|
|
|
sideBarLayout_->setSpacing(0);
|
|
|
|
sideBarLayout_->setMargin(0);
|
|
|
|
|
2018-01-09 16:07:32 +03:00
|
|
|
sideBarTopLayout_ = new QVBoxLayout();
|
|
|
|
sideBarTopLayout_->setSpacing(0);
|
|
|
|
sideBarTopLayout_->setMargin(0);
|
|
|
|
sideBarMainLayout_ = new QVBoxLayout();
|
|
|
|
sideBarMainLayout_->setSpacing(0);
|
|
|
|
sideBarMainLayout_->setMargin(0);
|
|
|
|
|
|
|
|
sideBarLayout_->addLayout(sideBarTopLayout_);
|
|
|
|
sideBarLayout_->addLayout(sideBarMainLayout_);
|
|
|
|
|
|
|
|
sideBarTopWidget_ = new QWidget(sideBar_);
|
|
|
|
sidebarActions_ = new SideBarActions(this);
|
2017-11-02 01:41:13 +03:00
|
|
|
connect(
|
|
|
|
sidebarActions_, &SideBarActions::showSettings, this, &ChatPage::showUserSettingsPage);
|
2017-12-10 16:22:01 +03:00
|
|
|
connect(
|
|
|
|
sidebarActions_, &SideBarActions::joinRoom, client_.data(), &MatrixClient::joinRoom);
|
2017-12-12 00:00:37 +03:00
|
|
|
connect(
|
|
|
|
sidebarActions_, &SideBarActions::createRoom, client_.data(), &MatrixClient::createRoom);
|
2017-10-15 22:08:51 +03:00
|
|
|
|
2017-11-09 00:09:15 +03:00
|
|
|
user_info_widget_ = new UserInfoWidget(sideBar_);
|
2017-12-30 18:29:57 +03:00
|
|
|
room_list_ = new RoomList(client, userSettings_, sideBar_);
|
2017-08-26 13:49:16 +03:00
|
|
|
|
2017-11-09 00:09:15 +03:00
|
|
|
sideBarLayout_->addWidget(user_info_widget_);
|
|
|
|
sideBarLayout_->addWidget(room_list_);
|
|
|
|
sideBarLayout_->addWidget(sidebarActions_);
|
2017-08-26 13:49:16 +03:00
|
|
|
|
2018-01-09 16:07:32 +03:00
|
|
|
sideBarTopWidgetLayout_ = new QVBoxLayout(sideBarTopWidget_);
|
|
|
|
sideBarTopWidgetLayout_->setSpacing(0);
|
|
|
|
sideBarTopWidgetLayout_->setMargin(0);
|
|
|
|
|
2017-08-26 13:49:16 +03:00
|
|
|
// Content
|
2017-11-16 17:33:52 +03:00
|
|
|
content_ = new QFrame(this);
|
|
|
|
content_->setObjectName("mainContent");
|
2017-08-26 13:49:16 +03:00
|
|
|
contentLayout_ = new QVBoxLayout(content_);
|
|
|
|
contentLayout_->setSpacing(0);
|
|
|
|
contentLayout_->setMargin(0);
|
|
|
|
|
2017-11-09 00:09:15 +03:00
|
|
|
top_bar_ = new TopRoomBar(this);
|
|
|
|
view_manager_ = new TimelineViewManager(client, this);
|
2017-08-26 13:49:16 +03:00
|
|
|
|
2017-11-09 00:09:15 +03:00
|
|
|
contentLayout_->addWidget(top_bar_);
|
|
|
|
contentLayout_->addWidget(view_manager_);
|
2017-08-26 13:49:16 +03:00
|
|
|
|
|
|
|
// Splitter
|
|
|
|
splitter->addWidget(sideBar_);
|
|
|
|
splitter->addWidget(content_);
|
2017-11-09 01:17:08 +03:00
|
|
|
splitter->setSizes({ui::sidebar::NormalSize, parent->width() - ui::sidebar::NormalSize});
|
2017-08-26 13:49:16 +03:00
|
|
|
|
2017-10-04 11:33:34 +03:00
|
|
|
text_input_ = new TextInputWidget(this);
|
|
|
|
typingDisplay_ = new TypingDisplay(this);
|
|
|
|
contentLayout_->addWidget(typingDisplay_);
|
2017-10-04 22:00:26 +03:00
|
|
|
contentLayout_->addWidget(text_input_);
|
2017-08-26 13:49:16 +03:00
|
|
|
|
2017-10-31 21:11:49 +03:00
|
|
|
typingRefresher_ = new QTimer(this);
|
|
|
|
typingRefresher_->setInterval(TYPING_REFRESH_TIMEOUT);
|
|
|
|
|
2017-08-26 13:49:16 +03:00
|
|
|
connect(user_info_widget_, SIGNAL(logout()), client_.data(), SLOT(logout()));
|
|
|
|
connect(client_.data(), SIGNAL(loggedOut()), this, SLOT(logout()));
|
|
|
|
|
2017-10-01 19:49:36 +03:00
|
|
|
connect(
|
|
|
|
top_bar_, &TopRoomBar::leaveRoom, this, [=]() { client_->leaveRoom(current_room_); });
|
2017-12-11 00:59:50 +03:00
|
|
|
connect(top_bar_, &TopRoomBar::inviteUsers, this, [=](QStringList users) {
|
|
|
|
for (int ii = 0; ii < users.size(); ++ii) {
|
|
|
|
QTimer::singleShot(ii * 1000, this, [=]() {
|
|
|
|
client_->inviteUser(current_room_, users.at(ii));
|
|
|
|
});
|
|
|
|
}
|
|
|
|
});
|
2017-10-01 19:49:36 +03:00
|
|
|
|
2017-10-04 11:33:34 +03:00
|
|
|
connect(room_list_, &RoomList::roomChanged, this, [=](const QString &roomid) {
|
|
|
|
QStringList users;
|
|
|
|
|
|
|
|
if (typingUsers_.contains(roomid))
|
|
|
|
users = typingUsers_[roomid];
|
|
|
|
|
|
|
|
typingDisplay_->setUsers(users);
|
|
|
|
});
|
2017-10-31 21:11:49 +03:00
|
|
|
connect(room_list_, &RoomList::roomChanged, text_input_, &TextInputWidget::stopTyping);
|
2017-10-04 11:33:34 +03:00
|
|
|
|
2017-08-26 13:49:16 +03:00
|
|
|
connect(room_list_, &RoomList::roomChanged, this, &ChatPage::changeTopRoomInfo);
|
|
|
|
connect(room_list_, &RoomList::roomChanged, text_input_, &TextInputWidget::focusLineEdit);
|
|
|
|
connect(
|
|
|
|
room_list_, &RoomList::roomChanged, view_manager_, &TimelineViewManager::setHistoryView);
|
|
|
|
|
2017-12-19 23:36:12 +03:00
|
|
|
connect(room_list_, &RoomList::acceptInvite, client_.data(), &MatrixClient::joinRoom);
|
|
|
|
connect(room_list_, &RoomList::declineInvite, client_.data(), &MatrixClient::leaveRoom);
|
|
|
|
|
2017-11-24 01:10:58 +03:00
|
|
|
connect(view_manager_,
|
|
|
|
&TimelineViewManager::clearRoomMessageCount,
|
|
|
|
room_list_,
|
|
|
|
&RoomList::clearRoomMessageCount);
|
|
|
|
|
2017-08-26 13:49:16 +03:00
|
|
|
connect(view_manager_,
|
|
|
|
&TimelineViewManager::unreadMessages,
|
|
|
|
this,
|
|
|
|
[=](const QString &roomid, int count) {
|
2018-01-13 18:15:47 +03:00
|
|
|
if (!roomSettings_.contains(roomid)) {
|
2017-08-26 13:49:16 +03:00
|
|
|
qWarning() << "RoomId does not have settings" << roomid;
|
|
|
|
room_list_->updateUnreadMessageCount(roomid, count);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2018-01-13 18:15:47 +03:00
|
|
|
if (roomSettings_[roomid]->isNotificationsEnabled())
|
2017-08-26 13:49:16 +03:00
|
|
|
room_list_->updateUnreadMessageCount(roomid, count);
|
|
|
|
});
|
|
|
|
|
2017-10-31 21:11:49 +03:00
|
|
|
connect(text_input_, &TextInputWidget::startedTyping, this, [=]() {
|
|
|
|
typingRefresher_->start();
|
|
|
|
client_->sendTypingNotification(current_room_);
|
|
|
|
});
|
|
|
|
|
|
|
|
connect(text_input_, &TextInputWidget::stoppedTyping, this, [=]() {
|
|
|
|
typingRefresher_->stop();
|
|
|
|
client_->removeTypingNotification(current_room_);
|
|
|
|
});
|
|
|
|
|
|
|
|
connect(typingRefresher_, &QTimer::timeout, this, [=]() {
|
|
|
|
client_->sendTypingNotification(current_room_);
|
|
|
|
});
|
|
|
|
|
2017-08-26 13:49:16 +03:00
|
|
|
connect(view_manager_,
|
|
|
|
&TimelineViewManager::updateRoomsLastMessage,
|
|
|
|
room_list_,
|
|
|
|
&RoomList::updateRoomDescription);
|
|
|
|
|
|
|
|
connect(room_list_,
|
|
|
|
SIGNAL(totalUnreadMessageCountUpdated(int)),
|
|
|
|
this,
|
|
|
|
SLOT(showUnreadMessageNotification(int)));
|
|
|
|
|
|
|
|
connect(text_input_,
|
|
|
|
SIGNAL(sendTextMessage(const QString &)),
|
|
|
|
view_manager_,
|
2017-11-15 19:38:50 +03:00
|
|
|
SLOT(queueTextMessage(const QString &)));
|
2017-08-26 13:49:16 +03:00
|
|
|
|
2017-09-03 11:43:45 +03:00
|
|
|
connect(text_input_,
|
|
|
|
SIGNAL(sendEmoteMessage(const QString &)),
|
|
|
|
view_manager_,
|
2017-11-15 19:38:50 +03:00
|
|
|
SLOT(queueEmoteMessage(const QString &)));
|
2017-09-03 11:43:45 +03:00
|
|
|
|
2017-10-08 22:38:38 +03:00
|
|
|
connect(text_input_,
|
|
|
|
&TextInputWidget::sendJoinRoomRequest,
|
|
|
|
client_.data(),
|
|
|
|
&MatrixClient::joinRoom);
|
|
|
|
|
2018-01-10 10:52:59 +03:00
|
|
|
connect(text_input_,
|
|
|
|
&TextInputWidget::uploadImage,
|
|
|
|
this,
|
|
|
|
[=](QSharedPointer<QIODevice> data, const QString &fn) {
|
|
|
|
client_->uploadImage(current_room_, data, fn);
|
|
|
|
});
|
2017-09-10 12:58:00 +03:00
|
|
|
|
2018-01-10 10:52:59 +03:00
|
|
|
connect(text_input_,
|
|
|
|
&TextInputWidget::uploadFile,
|
|
|
|
this,
|
|
|
|
[=](QSharedPointer<QIODevice> data, const QString &fn) {
|
|
|
|
client_->uploadFile(current_room_, data, fn);
|
|
|
|
});
|
2017-11-30 00:39:35 +03:00
|
|
|
|
2018-01-10 10:52:59 +03:00
|
|
|
connect(text_input_,
|
|
|
|
&TextInputWidget::uploadAudio,
|
|
|
|
this,
|
|
|
|
[=](QSharedPointer<QIODevice> data, const QString &fn) {
|
|
|
|
client_->uploadAudio(current_room_, data, fn);
|
|
|
|
});
|
2017-12-01 18:33:49 +03:00
|
|
|
|
2017-12-12 00:00:37 +03:00
|
|
|
connect(
|
|
|
|
client_.data(), &MatrixClient::roomCreationFailed, this, &ChatPage::showNotification);
|
2017-10-08 22:38:38 +03:00
|
|
|
connect(client_.data(), &MatrixClient::joinFailed, this, &ChatPage::showNotification);
|
2017-09-10 12:58:00 +03:00
|
|
|
connect(client_.data(),
|
|
|
|
&MatrixClient::imageUploaded,
|
|
|
|
this,
|
2018-01-10 10:52:59 +03:00
|
|
|
[=](QString roomid, QSharedPointer<QIODevice> data, QString filename, QString url) {
|
2017-09-10 12:58:00 +03:00
|
|
|
text_input_->hideUploadSpinner();
|
2018-01-10 10:52:59 +03:00
|
|
|
view_manager_->queueImageMessage(roomid, data, filename, url);
|
2017-09-10 12:58:00 +03:00
|
|
|
});
|
2017-11-30 00:39:35 +03:00
|
|
|
connect(client_.data(),
|
|
|
|
&MatrixClient::fileUploaded,
|
|
|
|
this,
|
|
|
|
[=](QString roomid, QString filename, QString url) {
|
|
|
|
text_input_->hideUploadSpinner();
|
|
|
|
view_manager_->queueFileMessage(roomid, filename, url);
|
|
|
|
});
|
2017-12-01 18:33:49 +03:00
|
|
|
connect(client_.data(),
|
|
|
|
&MatrixClient::audioUploaded,
|
|
|
|
this,
|
|
|
|
[=](QString roomid, QString filename, QString url) {
|
|
|
|
text_input_->hideUploadSpinner();
|
|
|
|
view_manager_->queueAudioMessage(roomid, filename, url);
|
|
|
|
});
|
2017-09-10 12:58:00 +03:00
|
|
|
|
2017-12-22 01:00:48 +03:00
|
|
|
connect(room_list_, &RoomList::roomAvatarChanged, this, &ChatPage::updateTopBarAvatar);
|
2017-08-26 13:49:16 +03:00
|
|
|
|
|
|
|
connect(client_.data(),
|
2017-12-04 19:41:19 +03:00
|
|
|
&MatrixClient::initialSyncCompleted,
|
2017-08-26 13:49:16 +03:00
|
|
|
this,
|
2017-12-04 19:41:19 +03:00
|
|
|
&ChatPage::initialSyncCompleted);
|
2017-10-20 22:32:48 +03:00
|
|
|
connect(client_.data(), &MatrixClient::initialSyncFailed, this, [=](const QString &msg) {
|
2017-10-21 21:17:01 +03:00
|
|
|
if (client_->getHomeServer().isEmpty()) {
|
|
|
|
deleteConfigs();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2017-10-20 22:32:48 +03:00
|
|
|
initialSyncFailures += 1;
|
|
|
|
|
|
|
|
if (initialSyncFailures >= MAX_INITIAL_SYNC_FAILURES) {
|
|
|
|
initialSyncFailures = 0;
|
|
|
|
|
|
|
|
deleteConfigs();
|
|
|
|
|
|
|
|
emit showLoginPage(msg);
|
|
|
|
emit contentLoaded();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
qWarning() << msg;
|
|
|
|
qWarning() << "Retrying initial sync";
|
|
|
|
|
|
|
|
client_->initialSync();
|
|
|
|
});
|
2017-12-04 19:41:19 +03:00
|
|
|
connect(client_.data(), &MatrixClient::syncCompleted, this, &ChatPage::syncCompleted);
|
|
|
|
connect(client_.data(), &MatrixClient::syncFailed, this, &ChatPage::syncFailed);
|
2017-08-26 13:49:16 +03:00
|
|
|
connect(client_.data(),
|
2017-12-03 03:47:37 +03:00
|
|
|
&MatrixClient::getOwnProfileResponse,
|
2017-08-26 13:49:16 +03:00
|
|
|
this,
|
2017-12-03 03:47:37 +03:00
|
|
|
&ChatPage::updateOwnProfileInfo);
|
2018-01-09 16:07:32 +03:00
|
|
|
connect(client_.data(),
|
|
|
|
SIGNAL(getOwnCommunitiesResponse(QList<QString>)),
|
|
|
|
this,
|
|
|
|
SLOT(updateOwnCommunitiesInfo(QList<QString>)));
|
|
|
|
connect(client_.data(),
|
|
|
|
&MatrixClient::communityProfileRetrieved,
|
|
|
|
this,
|
|
|
|
[=](QString communityId, QJsonObject profile) {
|
|
|
|
communityManager_[communityId]->parseProfile(profile);
|
|
|
|
});
|
|
|
|
connect(client_.data(),
|
|
|
|
&MatrixClient::communityRoomsRetrieved,
|
|
|
|
this,
|
|
|
|
[=](QString communityId, QJsonObject rooms) {
|
|
|
|
communityManager_[communityId]->parseRooms(rooms);
|
|
|
|
|
|
|
|
if (communityId == current_community_) {
|
|
|
|
if (communityId == "world") {
|
|
|
|
room_list_->setFilterRooms(false);
|
|
|
|
} else {
|
|
|
|
room_list_->setRoomFilter(
|
|
|
|
communityManager_[communityId]->getRoomList());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
});
|
|
|
|
|
2017-12-04 19:41:19 +03:00
|
|
|
connect(client_.data(), &MatrixClient::ownAvatarRetrieved, this, &ChatPage::setOwnAvatar);
|
2017-12-19 23:36:12 +03:00
|
|
|
connect(client_.data(), &MatrixClient::joinedRoom, this, [=](const QString &room_id) {
|
2017-10-08 22:38:38 +03:00
|
|
|
emit showNotification("You joined the room.");
|
2017-12-19 23:36:12 +03:00
|
|
|
removeInvite(room_id);
|
2017-10-08 22:38:38 +03:00
|
|
|
});
|
2017-12-11 00:59:50 +03:00
|
|
|
connect(client_.data(), &MatrixClient::invitedUser, this, [=](QString, QString user) {
|
|
|
|
emit showNotification(QString("Invited user %1").arg(user));
|
|
|
|
});
|
2017-12-12 00:00:37 +03:00
|
|
|
connect(client_.data(), &MatrixClient::roomCreated, this, [=](QString room_id) {
|
|
|
|
emit showNotification(QString("Room %1 created").arg(room_id));
|
|
|
|
});
|
2017-12-04 19:41:19 +03:00
|
|
|
connect(client_.data(), &MatrixClient::leftRoom, this, &ChatPage::removeRoom);
|
2017-08-26 13:49:16 +03:00
|
|
|
|
2017-10-08 21:35:37 +03:00
|
|
|
showContentTimer_ = new QTimer(this);
|
|
|
|
showContentTimer_->setSingleShot(true);
|
|
|
|
connect(showContentTimer_, &QTimer::timeout, this, [=]() {
|
|
|
|
consensusTimer_->stop();
|
|
|
|
emit contentLoaded();
|
|
|
|
});
|
|
|
|
|
2017-10-07 20:50:32 +03:00
|
|
|
consensusTimer_ = new QTimer(this);
|
|
|
|
connect(consensusTimer_, &QTimer::timeout, this, [=]() {
|
|
|
|
if (view_manager_->hasLoaded()) {
|
|
|
|
// Remove the spinner overlay.
|
|
|
|
emit contentLoaded();
|
2017-10-08 21:35:37 +03:00
|
|
|
showContentTimer_->stop();
|
2017-10-07 20:50:32 +03:00
|
|
|
consensusTimer_->stop();
|
|
|
|
}
|
|
|
|
});
|
|
|
|
|
2018-01-09 16:07:32 +03:00
|
|
|
connect(communitiesList_,
|
|
|
|
&CommunitiesList::communityChanged,
|
|
|
|
this,
|
|
|
|
[=](const QString &communityId) {
|
|
|
|
current_community_ = communityId;
|
|
|
|
if (communityId == "world") {
|
|
|
|
room_list_->setFilterRooms(false);
|
|
|
|
} else {
|
|
|
|
room_list_->setRoomFilter(
|
|
|
|
communityManager_[communityId]->getRoomList());
|
|
|
|
}
|
|
|
|
});
|
|
|
|
|
2018-01-09 22:57:41 +03:00
|
|
|
setGroupViewState(userSettings_->isGroupViewEnabled());
|
|
|
|
|
|
|
|
connect(userSettings_.data(),
|
|
|
|
&UserSettings::groupViewStateChanged,
|
|
|
|
this,
|
|
|
|
&ChatPage::setGroupViewState);
|
|
|
|
|
2017-08-26 13:49:16 +03:00
|
|
|
AvatarProvider::init(client);
|
2018-01-03 19:05:49 +03:00
|
|
|
|
|
|
|
instance_ = this;
|
2017-04-06 02:06:42 +03:00
|
|
|
}
|
|
|
|
|
2017-08-20 13:47:22 +03:00
|
|
|
void
|
|
|
|
ChatPage::logout()
|
2017-04-09 02:17:04 +03:00
|
|
|
{
|
2017-10-20 22:32:48 +03:00
|
|
|
deleteConfigs();
|
|
|
|
|
|
|
|
resetUI();
|
|
|
|
|
|
|
|
emit close();
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
ChatPage::resetUI()
|
|
|
|
{
|
|
|
|
room_avatars_.clear();
|
|
|
|
room_list_->clear();
|
2018-01-13 18:15:47 +03:00
|
|
|
roomSettings_.clear();
|
|
|
|
roomStates_.clear();
|
2017-10-20 22:32:48 +03:00
|
|
|
top_bar_->reset();
|
|
|
|
user_info_widget_->reset();
|
|
|
|
view_manager_->clearAll();
|
|
|
|
AvatarProvider::clear();
|
2017-10-21 16:46:11 +03:00
|
|
|
|
|
|
|
showUnreadMessageNotification(0);
|
2017-10-20 22:32:48 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
ChatPage::deleteConfigs()
|
|
|
|
{
|
2017-08-26 13:49:16 +03:00
|
|
|
QSettings settings;
|
|
|
|
settings.beginGroup("auth");
|
|
|
|
settings.remove("");
|
|
|
|
settings.endGroup();
|
|
|
|
settings.beginGroup("client");
|
|
|
|
settings.remove("");
|
|
|
|
settings.endGroup();
|
|
|
|
settings.beginGroup("notifications");
|
|
|
|
settings.remove("");
|
|
|
|
settings.endGroup();
|
|
|
|
|
2017-08-26 14:31:23 +03:00
|
|
|
cache_->deleteData();
|
|
|
|
|
2017-08-26 13:49:16 +03:00
|
|
|
client_->reset();
|
2017-04-09 02:17:04 +03:00
|
|
|
}
|
|
|
|
|
2017-08-20 13:47:22 +03:00
|
|
|
void
|
|
|
|
ChatPage::bootstrap(QString userid, QString homeserver, QString token)
|
2017-04-06 02:06:42 +03:00
|
|
|
{
|
2017-08-26 13:49:16 +03:00
|
|
|
client_->setServer(homeserver);
|
|
|
|
client_->setAccessToken(token);
|
|
|
|
client_->getOwnProfile();
|
2018-01-09 16:07:32 +03:00
|
|
|
client_->getOwnCommunities();
|
2017-08-26 13:49:16 +03:00
|
|
|
|
2017-10-03 21:16:31 +03:00
|
|
|
cache_ = QSharedPointer<Cache>(new Cache(userid));
|
2017-12-22 01:00:48 +03:00
|
|
|
room_list_->setCache(cache_);
|
2017-10-03 21:16:31 +03:00
|
|
|
|
2017-08-26 13:49:16 +03:00
|
|
|
try {
|
2017-10-03 21:16:31 +03:00
|
|
|
cache_->setup();
|
|
|
|
|
2017-12-10 13:51:44 +03:00
|
|
|
if (!cache_->isFormatValid()) {
|
|
|
|
cache_->deleteData();
|
|
|
|
cache_->setup();
|
|
|
|
cache_->setCurrentFormat();
|
|
|
|
}
|
|
|
|
|
2017-10-03 21:16:31 +03:00
|
|
|
if (cache_->isInitialized()) {
|
|
|
|
loadStateFromCache();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
} catch (const lmdb::error &e) {
|
|
|
|
qCritical() << "Cache failure" << e.what();
|
|
|
|
cache_->unmount();
|
|
|
|
cache_->deleteData();
|
|
|
|
qInfo() << "Falling back to initial sync ...";
|
2017-08-26 13:49:16 +03:00
|
|
|
}
|
|
|
|
|
2017-10-03 21:16:31 +03:00
|
|
|
client_->initialSync();
|
2017-04-06 02:06:42 +03:00
|
|
|
}
|
|
|
|
|
2017-08-20 13:47:22 +03:00
|
|
|
void
|
|
|
|
ChatPage::setOwnAvatar(const QPixmap &img)
|
2017-04-06 02:06:42 +03:00
|
|
|
{
|
2017-08-26 13:49:16 +03:00
|
|
|
user_info_widget_->setAvatar(img.toImage());
|
2017-04-06 02:06:42 +03:00
|
|
|
}
|
|
|
|
|
2017-08-20 13:47:22 +03:00
|
|
|
void
|
|
|
|
ChatPage::syncFailed(const QString &msg)
|
2017-04-11 02:35:09 +03:00
|
|
|
{
|
2017-09-30 15:52:14 +03:00
|
|
|
// Stop if sync is not active. e.g user is logged out.
|
|
|
|
if (client_->getHomeServer().isEmpty())
|
|
|
|
return;
|
|
|
|
|
2017-08-26 13:49:16 +03:00
|
|
|
qWarning() << "Sync error:" << msg;
|
2017-10-23 00:19:35 +03:00
|
|
|
QTimer::singleShot(SYNC_RETRY_TIMEOUT, this, [=]() { client_->sync(); });
|
2017-04-11 02:35:09 +03:00
|
|
|
}
|
|
|
|
|
2017-08-20 13:47:22 +03:00
|
|
|
void
|
2017-12-04 19:41:19 +03:00
|
|
|
ChatPage::syncCompleted(const mtx::responses::Sync &response)
|
2017-04-06 02:06:42 +03:00
|
|
|
{
|
2017-12-04 19:41:19 +03:00
|
|
|
updateJoinedRooms(response.rooms.join);
|
|
|
|
removeLeftRooms(response.rooms.leave);
|
2017-08-26 13:49:16 +03:00
|
|
|
|
2017-12-04 19:41:19 +03:00
|
|
|
const auto nextBatchToken = QString::fromStdString(response.next_batch);
|
|
|
|
|
2018-01-13 18:15:47 +03:00
|
|
|
auto stateDiff = generateMembershipDifference(response.rooms.join, roomStates_);
|
2017-12-04 19:41:19 +03:00
|
|
|
QtConcurrent::run(cache_.data(), &Cache::setState, nextBatchToken, stateDiff);
|
2017-12-19 23:36:12 +03:00
|
|
|
QtConcurrent::run(cache_.data(), &Cache::setInvites, response.rooms.invite);
|
2017-08-26 13:49:16 +03:00
|
|
|
|
2018-01-13 18:15:47 +03:00
|
|
|
room_list_->sync(roomStates_, roomSettings_);
|
2017-12-19 23:36:12 +03:00
|
|
|
room_list_->syncInvites(response.rooms.invite);
|
|
|
|
|
2017-12-04 19:41:19 +03:00
|
|
|
view_manager_->sync(response.rooms);
|
2017-08-26 13:49:16 +03:00
|
|
|
|
2017-12-04 19:41:19 +03:00
|
|
|
client_->setNextBatchToken(nextBatchToken);
|
2017-10-20 21:21:04 +03:00
|
|
|
client_->sync();
|
2017-04-06 02:06:42 +03:00
|
|
|
}
|
|
|
|
|
2017-08-20 13:47:22 +03:00
|
|
|
void
|
2017-12-04 19:41:19 +03:00
|
|
|
ChatPage::initialSyncCompleted(const mtx::responses::Sync &response)
|
2017-04-06 02:06:42 +03:00
|
|
|
{
|
2017-12-04 19:41:19 +03:00
|
|
|
auto joined = response.rooms.join;
|
2017-04-06 02:06:42 +03:00
|
|
|
|
2017-12-04 19:41:19 +03:00
|
|
|
for (auto it = joined.cbegin(); it != joined.cend(); ++it) {
|
2018-01-13 18:15:47 +03:00
|
|
|
auto roomState = QSharedPointer<RoomState>(new RoomState);
|
2017-05-07 17:15:38 +03:00
|
|
|
|
2017-08-26 13:49:16 +03:00
|
|
|
// Build the current state from the timeline and state events.
|
2018-01-13 18:15:47 +03:00
|
|
|
roomState->updateFromEvents(it->second.state.events);
|
|
|
|
roomState->updateFromEvents(it->second.timeline.events);
|
2017-07-29 11:49:00 +03:00
|
|
|
|
2017-08-26 13:49:16 +03:00
|
|
|
// Remove redundant memberships.
|
2018-01-13 18:15:47 +03:00
|
|
|
roomState->removeLeaveMemberships();
|
2017-05-07 17:15:38 +03:00
|
|
|
|
2017-08-26 13:49:16 +03:00
|
|
|
// Resolve room name and avatar. e.g in case of one-to-one chats.
|
2018-01-13 18:15:47 +03:00
|
|
|
roomState->resolveName();
|
|
|
|
roomState->resolveAvatar();
|
2017-05-07 17:15:38 +03:00
|
|
|
|
2017-12-04 19:41:19 +03:00
|
|
|
const auto room_id = QString::fromStdString(it->first);
|
|
|
|
|
2018-01-13 18:15:47 +03:00
|
|
|
roomStates_.insert(room_id, roomState);
|
|
|
|
roomSettings_.insert(room_id,
|
|
|
|
QSharedPointer<RoomSettings>(new RoomSettings(room_id)));
|
2017-05-26 21:34:16 +03:00
|
|
|
|
2018-01-13 18:15:47 +03:00
|
|
|
for (const auto membership : roomState->memberships) {
|
2017-12-04 19:41:19 +03:00
|
|
|
updateUserDisplayName(membership.second);
|
|
|
|
updateUserAvatarUrl(membership.second);
|
2017-08-26 13:49:16 +03:00
|
|
|
}
|
2017-10-21 18:53:15 +03:00
|
|
|
|
|
|
|
QApplication::processEvents();
|
2017-08-26 13:49:16 +03:00
|
|
|
}
|
2017-05-26 21:34:16 +03:00
|
|
|
|
2017-12-04 19:41:19 +03:00
|
|
|
QtConcurrent::run(cache_.data(),
|
|
|
|
&Cache::setState,
|
|
|
|
QString::fromStdString(response.next_batch),
|
2018-01-13 18:15:47 +03:00
|
|
|
roomStates_);
|
2017-12-19 23:36:12 +03:00
|
|
|
QtConcurrent::run(cache_.data(), &Cache::setInvites, response.rooms.invite);
|
2017-10-21 21:17:01 +03:00
|
|
|
|
2017-08-26 13:49:16 +03:00
|
|
|
// Populate timelines with messages.
|
2017-12-04 19:41:19 +03:00
|
|
|
view_manager_->initialize(response.rooms);
|
2017-05-07 17:15:38 +03:00
|
|
|
|
2017-08-26 13:49:16 +03:00
|
|
|
// Initialize room list.
|
2018-01-13 18:15:47 +03:00
|
|
|
room_list_->setInitialRooms(roomSettings_, roomStates_);
|
2017-12-19 23:36:12 +03:00
|
|
|
room_list_->syncInvites(response.rooms.invite);
|
2017-07-29 11:49:00 +03:00
|
|
|
|
2017-12-04 19:41:19 +03:00
|
|
|
client_->setNextBatchToken(QString::fromStdString(response.next_batch));
|
2017-10-20 21:21:04 +03:00
|
|
|
client_->sync();
|
2017-04-06 02:06:42 +03:00
|
|
|
|
2017-08-26 13:49:16 +03:00
|
|
|
emit contentLoaded();
|
2017-04-06 02:06:42 +03:00
|
|
|
}
|
|
|
|
|
2017-08-20 13:47:22 +03:00
|
|
|
void
|
|
|
|
ChatPage::updateTopBarAvatar(const QString &roomid, const QPixmap &img)
|
2017-04-06 02:06:42 +03:00
|
|
|
{
|
2017-08-26 13:49:16 +03:00
|
|
|
room_avatars_.insert(roomid, img);
|
2017-04-06 02:06:42 +03:00
|
|
|
|
2017-08-26 13:49:16 +03:00
|
|
|
if (current_room_ != roomid)
|
|
|
|
return;
|
2017-04-06 02:06:42 +03:00
|
|
|
|
2017-08-26 13:49:16 +03:00
|
|
|
top_bar_->updateRoomAvatar(img.toImage());
|
2017-04-06 02:06:42 +03:00
|
|
|
}
|
|
|
|
|
2017-08-20 13:47:22 +03:00
|
|
|
void
|
|
|
|
ChatPage::updateOwnProfileInfo(const QUrl &avatar_url, const QString &display_name)
|
2017-04-06 02:06:42 +03:00
|
|
|
{
|
2017-08-26 13:49:16 +03:00
|
|
|
QSettings settings;
|
|
|
|
auto userid = settings.value("auth/user_id").toString();
|
2017-04-06 02:06:42 +03:00
|
|
|
|
2017-08-26 13:49:16 +03:00
|
|
|
user_info_widget_->setUserId(userid);
|
|
|
|
user_info_widget_->setDisplayName(display_name);
|
2017-04-06 02:06:42 +03:00
|
|
|
|
2017-08-26 13:49:16 +03:00
|
|
|
if (avatar_url.isValid())
|
|
|
|
client_->fetchOwnAvatar(avatar_url);
|
2017-04-06 02:06:42 +03:00
|
|
|
}
|
|
|
|
|
2018-01-09 16:07:32 +03:00
|
|
|
void
|
|
|
|
ChatPage::updateOwnCommunitiesInfo(const QList<QString> &own_communities)
|
|
|
|
{
|
|
|
|
for (int i = 0; i < own_communities.size(); i++) {
|
|
|
|
QSharedPointer<Community> community = QSharedPointer<Community>(new Community());
|
|
|
|
|
|
|
|
communityManager_[own_communities[i]] = community;
|
|
|
|
}
|
|
|
|
|
|
|
|
communitiesList_->setCommunities(communityManager_);
|
|
|
|
}
|
|
|
|
|
2017-08-20 13:47:22 +03:00
|
|
|
void
|
|
|
|
ChatPage::changeTopRoomInfo(const QString &room_id)
|
2017-04-06 02:06:42 +03:00
|
|
|
{
|
2018-01-13 18:15:47 +03:00
|
|
|
if (!roomStates_.contains(room_id))
|
2017-08-26 13:49:16 +03:00
|
|
|
return;
|
2017-04-06 02:06:42 +03:00
|
|
|
|
2018-01-13 18:15:47 +03:00
|
|
|
auto state = roomStates_[room_id];
|
2017-05-07 17:15:38 +03:00
|
|
|
|
2018-01-13 18:15:47 +03:00
|
|
|
top_bar_->updateRoomName(state->getName());
|
|
|
|
top_bar_->updateRoomTopic(state->getTopic());
|
|
|
|
top_bar_->setRoomSettings(roomSettings_[room_id]);
|
2017-05-07 17:15:38 +03:00
|
|
|
|
2017-08-26 13:49:16 +03:00
|
|
|
if (room_avatars_.contains(room_id))
|
|
|
|
top_bar_->updateRoomAvatar(room_avatars_.value(room_id).toImage());
|
|
|
|
else
|
2018-01-13 18:15:47 +03:00
|
|
|
top_bar_->updateRoomAvatarFromName(state->getName());
|
2017-04-06 02:06:42 +03:00
|
|
|
|
2017-08-26 13:49:16 +03:00
|
|
|
current_room_ = room_id;
|
2017-04-06 02:06:42 +03:00
|
|
|
}
|
|
|
|
|
2017-08-20 13:47:22 +03:00
|
|
|
void
|
|
|
|
ChatPage::showUnreadMessageNotification(int count)
|
2017-04-15 19:04:02 +03:00
|
|
|
{
|
2017-08-26 13:49:16 +03:00
|
|
|
emit unreadMessages(count);
|
2017-04-15 19:04:02 +03:00
|
|
|
|
2017-08-26 13:49:16 +03:00
|
|
|
// TODO: Make the default title a const.
|
|
|
|
if (count == 0)
|
|
|
|
emit changeWindowTitle("nheko");
|
|
|
|
else
|
|
|
|
emit changeWindowTitle(QString("nheko (%1)").arg(count));
|
2017-05-07 17:15:38 +03:00
|
|
|
}
|
|
|
|
|
2017-08-20 13:47:22 +03:00
|
|
|
void
|
|
|
|
ChatPage::loadStateFromCache()
|
2017-07-29 11:49:00 +03:00
|
|
|
{
|
2017-08-26 13:49:16 +03:00
|
|
|
qDebug() << "Restoring state from cache";
|
2017-07-29 11:49:00 +03:00
|
|
|
|
2017-10-03 21:16:31 +03:00
|
|
|
qDebug() << "Restored nextBatchToken" << cache_->nextBatchToken();
|
|
|
|
client_->setNextBatchToken(cache_->nextBatchToken());
|
2017-07-29 11:49:00 +03:00
|
|
|
|
2017-08-26 13:49:16 +03:00
|
|
|
// Fetch all the joined room's state.
|
|
|
|
auto rooms = cache_->states();
|
2017-07-29 11:49:00 +03:00
|
|
|
|
2017-10-28 20:46:34 +03:00
|
|
|
for (auto it = rooms.constBegin(); it != rooms.constEnd(); ++it) {
|
2018-01-13 18:15:47 +03:00
|
|
|
auto roomState = QSharedPointer<RoomState>(new RoomState(it.value()));
|
2017-07-29 11:49:00 +03:00
|
|
|
|
2017-08-26 13:49:16 +03:00
|
|
|
// Clean up and prepare state for use.
|
2018-01-13 18:15:47 +03:00
|
|
|
roomState->removeLeaveMemberships();
|
|
|
|
roomState->resolveName();
|
|
|
|
roomState->resolveAvatar();
|
2017-07-29 11:49:00 +03:00
|
|
|
|
2017-08-26 13:49:16 +03:00
|
|
|
// Save the current room state.
|
2018-01-13 18:15:47 +03:00
|
|
|
roomStates_.insert(it.key(), roomState);
|
2017-07-29 11:49:00 +03:00
|
|
|
|
2017-08-26 13:49:16 +03:00
|
|
|
// Create or restore the settings for this room.
|
2018-01-13 18:15:47 +03:00
|
|
|
roomSettings_.insert(it.key(),
|
|
|
|
QSharedPointer<RoomSettings>(new RoomSettings(it.key())));
|
2017-07-29 11:49:00 +03:00
|
|
|
|
2017-08-26 13:49:16 +03:00
|
|
|
// Resolve user avatars.
|
2018-01-13 18:15:47 +03:00
|
|
|
for (const auto membership : roomState->memberships) {
|
2017-12-04 19:41:19 +03:00
|
|
|
updateUserDisplayName(membership.second);
|
|
|
|
updateUserAvatarUrl(membership.second);
|
2017-08-26 13:49:16 +03:00
|
|
|
}
|
|
|
|
}
|
2017-07-29 11:49:00 +03:00
|
|
|
|
2017-08-26 13:49:16 +03:00
|
|
|
// Initializing empty timelines.
|
|
|
|
view_manager_->initialize(rooms.keys());
|
2017-07-29 11:49:00 +03:00
|
|
|
|
2017-08-26 13:49:16 +03:00
|
|
|
// Initialize room list from the restored state and settings.
|
2018-01-13 18:15:47 +03:00
|
|
|
room_list_->setInitialRooms(roomSettings_, roomStates_);
|
2017-12-19 23:36:12 +03:00
|
|
|
room_list_->syncInvites(cache_->invites());
|
2017-07-29 11:49:00 +03:00
|
|
|
|
2017-10-07 20:50:32 +03:00
|
|
|
// Check periodically if the timelines have been loaded.
|
2017-10-08 21:35:37 +03:00
|
|
|
consensusTimer_->start(CONSENSUS_TIMEOUT);
|
|
|
|
|
|
|
|
// Show the content if consensus can't be achieved.
|
|
|
|
showContentTimer_->start(SHOW_CONTENT_TIMEOUT);
|
2017-07-29 11:49:00 +03:00
|
|
|
|
2017-10-08 21:35:37 +03:00
|
|
|
// Start receiving events.
|
2017-10-20 21:21:04 +03:00
|
|
|
client_->sync();
|
2017-07-29 11:49:00 +03:00
|
|
|
}
|
|
|
|
|
2017-08-20 13:47:22 +03:00
|
|
|
void
|
|
|
|
ChatPage::showQuickSwitcher()
|
2017-08-15 21:06:27 +03:00
|
|
|
{
|
2017-10-07 20:09:34 +03:00
|
|
|
if (quickSwitcher_.isNull()) {
|
|
|
|
quickSwitcher_ = QSharedPointer<QuickSwitcher>(
|
|
|
|
new QuickSwitcher(this),
|
|
|
|
[=](QuickSwitcher *switcher) { switcher->deleteLater(); });
|
2017-08-26 13:49:16 +03:00
|
|
|
|
2017-10-07 20:09:34 +03:00
|
|
|
connect(quickSwitcher_.data(),
|
2017-08-26 13:49:16 +03:00
|
|
|
&QuickSwitcher::roomSelected,
|
|
|
|
room_list_,
|
|
|
|
&RoomList::highlightSelectedRoom);
|
2017-10-07 20:09:34 +03:00
|
|
|
|
|
|
|
connect(quickSwitcher_.data(), &QuickSwitcher::closing, this, [=]() {
|
|
|
|
if (!this->quickSwitcherModal_.isNull())
|
2017-08-26 13:49:16 +03:00
|
|
|
this->quickSwitcherModal_->fadeOut();
|
2017-11-03 09:54:17 +03:00
|
|
|
this->text_input_->setFocus(Qt::FocusReason::PopupFocusReason);
|
2017-08-26 13:49:16 +03:00
|
|
|
});
|
|
|
|
}
|
|
|
|
|
2017-10-07 20:09:34 +03:00
|
|
|
if (quickSwitcherModal_.isNull()) {
|
|
|
|
quickSwitcherModal_ = QSharedPointer<OverlayModal>(
|
|
|
|
new OverlayModal(MainWindow::instance(), quickSwitcher_.data()),
|
|
|
|
[=](OverlayModal *modal) { modal->deleteLater(); });
|
2017-08-26 13:49:16 +03:00
|
|
|
quickSwitcherModal_->setDuration(0);
|
2017-11-22 22:13:22 +03:00
|
|
|
quickSwitcherModal_->setColor(QColor(30, 30, 30, 170));
|
2017-08-26 13:49:16 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
QMap<QString, QString> rooms;
|
|
|
|
|
2018-01-13 18:15:47 +03:00
|
|
|
for (auto it = roomStates_.constBegin(); it != roomStates_.constEnd(); ++it) {
|
2017-12-04 19:41:19 +03:00
|
|
|
QString deambiguator =
|
2018-01-13 18:15:47 +03:00
|
|
|
QString::fromStdString(it.value()->canonical_alias.content.alias);
|
2017-11-03 09:54:17 +03:00
|
|
|
if (deambiguator == "")
|
|
|
|
deambiguator = it.key();
|
2018-01-13 18:15:47 +03:00
|
|
|
rooms.insert(it.value()->getName() + " (" + deambiguator + ")", it.key());
|
2017-11-03 09:54:17 +03:00
|
|
|
}
|
2017-08-26 13:49:16 +03:00
|
|
|
|
|
|
|
quickSwitcher_->setRoomList(rooms);
|
|
|
|
quickSwitcherModal_->fadeIn();
|
2017-08-15 21:06:27 +03:00
|
|
|
}
|
|
|
|
|
2017-10-01 19:49:36 +03:00
|
|
|
void
|
|
|
|
ChatPage::addRoom(const QString &room_id)
|
|
|
|
{
|
2018-01-13 18:15:47 +03:00
|
|
|
if (!roomStates_.contains(room_id)) {
|
|
|
|
auto room_state = QSharedPointer<RoomState>(new RoomState);
|
2017-10-01 19:49:36 +03:00
|
|
|
|
2018-01-13 18:15:47 +03:00
|
|
|
roomStates_.insert(room_id, room_state);
|
|
|
|
roomSettings_.insert(room_id,
|
|
|
|
QSharedPointer<RoomSettings>(new RoomSettings(room_id)));
|
2017-10-01 19:49:36 +03:00
|
|
|
|
2018-01-13 18:15:47 +03:00
|
|
|
room_list_->addRoom(roomSettings_, roomStates_[room_id], room_id);
|
2017-10-01 19:49:36 +03:00
|
|
|
room_list_->highlightSelectedRoom(room_id);
|
2017-10-08 22:38:38 +03:00
|
|
|
|
|
|
|
changeTopRoomInfo(room_id);
|
2017-10-01 19:49:36 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
ChatPage::removeRoom(const QString &room_id)
|
|
|
|
{
|
2018-01-13 18:15:47 +03:00
|
|
|
roomStates_.remove(room_id);
|
|
|
|
roomSettings_.remove(room_id);
|
2017-10-01 19:49:36 +03:00
|
|
|
try {
|
|
|
|
cache_->removeRoom(room_id);
|
2017-12-19 23:36:12 +03:00
|
|
|
cache_->removeInvite(room_id);
|
2017-10-01 19:49:36 +03:00
|
|
|
} catch (const lmdb::error &e) {
|
|
|
|
qCritical() << "The cache couldn't be updated: " << e.what();
|
|
|
|
// TODO: Notify the user.
|
|
|
|
cache_->unmount();
|
2017-10-03 21:16:31 +03:00
|
|
|
cache_->deleteData();
|
2017-10-01 19:49:36 +03:00
|
|
|
}
|
|
|
|
room_list_->removeRoom(room_id, room_id == current_room_);
|
|
|
|
}
|
|
|
|
|
2017-12-19 23:36:12 +03:00
|
|
|
void
|
|
|
|
ChatPage::removeInvite(const QString &room_id)
|
|
|
|
{
|
|
|
|
try {
|
|
|
|
cache_->removeInvite(room_id);
|
|
|
|
} catch (const lmdb::error &e) {
|
|
|
|
qCritical() << "The cache couldn't be updated: " << e.what();
|
|
|
|
// TODO: Notify the user.
|
|
|
|
cache_->unmount();
|
|
|
|
cache_->deleteData();
|
|
|
|
}
|
|
|
|
|
|
|
|
room_list_->removeRoom(room_id, room_id == current_room_);
|
|
|
|
}
|
|
|
|
|
2017-10-04 11:33:34 +03:00
|
|
|
void
|
2017-12-04 19:41:19 +03:00
|
|
|
ChatPage::updateTypingUsers(const QString &roomid, const std::vector<std::string> &user_ids)
|
2017-10-04 11:33:34 +03:00
|
|
|
{
|
|
|
|
QStringList users;
|
|
|
|
|
2017-10-31 21:11:49 +03:00
|
|
|
QSettings settings;
|
|
|
|
QString user_id = settings.value("auth/user_id").toString();
|
|
|
|
|
|
|
|
for (const auto uid : user_ids) {
|
2017-12-04 19:41:19 +03:00
|
|
|
auto user = QString::fromStdString(uid);
|
|
|
|
|
|
|
|
if (user == user_id)
|
2017-10-31 21:11:49 +03:00
|
|
|
continue;
|
2017-12-04 19:41:19 +03:00
|
|
|
|
|
|
|
users.append(TimelineViewManager::displayName(user));
|
2017-10-31 21:11:49 +03:00
|
|
|
}
|
2017-10-04 11:33:34 +03:00
|
|
|
|
|
|
|
users.sort();
|
|
|
|
|
2017-10-31 21:11:49 +03:00
|
|
|
if (current_room_ == roomid) {
|
2017-10-04 11:33:34 +03:00
|
|
|
typingDisplay_->setUsers(users);
|
2017-10-31 21:11:49 +03:00
|
|
|
}
|
2017-10-04 11:33:34 +03:00
|
|
|
|
|
|
|
typingUsers_.insert(roomid, users);
|
|
|
|
}
|
|
|
|
|
2017-10-28 20:46:34 +03:00
|
|
|
void
|
2017-12-04 19:41:19 +03:00
|
|
|
ChatPage::updateUserAvatarUrl(const mtx::events::StateEvent<mtx::events::state::Member> &membership)
|
2017-10-28 20:46:34 +03:00
|
|
|
{
|
2017-12-22 17:02:08 +03:00
|
|
|
auto uid = QString::fromStdString(membership.state_key);
|
2017-12-04 19:41:19 +03:00
|
|
|
auto url = QString::fromStdString(membership.content.avatar_url);
|
2017-10-28 20:46:34 +03:00
|
|
|
|
2017-12-04 19:41:19 +03:00
|
|
|
if (!url.isEmpty())
|
2017-10-28 20:46:34 +03:00
|
|
|
AvatarProvider::setAvatarUrl(uid, url);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2017-12-04 19:41:19 +03:00
|
|
|
ChatPage::updateUserDisplayName(
|
|
|
|
const mtx::events::StateEvent<mtx::events::state::Member> &membership)
|
2017-10-28 20:46:34 +03:00
|
|
|
{
|
2017-12-04 19:41:19 +03:00
|
|
|
auto displayName = QString::fromStdString(membership.content.display_name);
|
|
|
|
auto stateKey = QString::fromStdString(membership.state_key);
|
2017-10-28 20:46:34 +03:00
|
|
|
|
|
|
|
if (!displayName.isEmpty())
|
2017-12-04 19:41:19 +03:00
|
|
|
TimelineViewManager::DISPLAY_NAMES.insert(stateKey, displayName);
|
2017-10-28 20:46:34 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2017-12-04 19:41:19 +03:00
|
|
|
ChatPage::removeLeftRooms(const std::map<std::string, mtx::responses::LeftRoom> &rooms)
|
2017-10-28 20:46:34 +03:00
|
|
|
{
|
2017-12-04 19:41:19 +03:00
|
|
|
for (auto it = rooms.cbegin(); it != rooms.cend(); ++it) {
|
|
|
|
const auto room_id = QString::fromStdString(it->first);
|
|
|
|
|
2018-01-13 18:15:47 +03:00
|
|
|
if (roomStates_.contains(room_id))
|
2017-12-04 19:41:19 +03:00
|
|
|
removeRoom(room_id);
|
2017-10-28 20:46:34 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2017-12-04 19:41:19 +03:00
|
|
|
ChatPage::updateJoinedRooms(const std::map<std::string, mtx::responses::JoinedRoom> &rooms)
|
2017-10-28 20:46:34 +03:00
|
|
|
{
|
2017-12-04 19:41:19 +03:00
|
|
|
for (auto it = rooms.cbegin(); it != rooms.cend(); ++it) {
|
|
|
|
const auto roomid = QString::fromStdString(it->first);
|
|
|
|
|
|
|
|
updateTypingUsers(roomid, it->second.ephemeral.typing);
|
2017-10-28 20:46:34 +03:00
|
|
|
|
2018-01-03 19:05:49 +03:00
|
|
|
if (it->second.ephemeral.receipts.size() > 0)
|
|
|
|
QtConcurrent::run(cache_.data(),
|
|
|
|
&Cache::updateReadReceipt,
|
|
|
|
it->first,
|
|
|
|
it->second.ephemeral.receipts);
|
|
|
|
|
2017-12-04 19:41:19 +03:00
|
|
|
const auto newStateEvents = it->second.state;
|
|
|
|
const auto newTimelineEvents = it->second.timeline;
|
2017-10-28 20:46:34 +03:00
|
|
|
|
|
|
|
// Merge the new updates for rooms that we are tracking.
|
2018-01-13 18:15:47 +03:00
|
|
|
if (roomStates_.contains(roomid)) {
|
|
|
|
auto oldState = roomStates_[roomid];
|
2017-12-04 19:41:19 +03:00
|
|
|
oldState->updateFromEvents(newStateEvents.events);
|
|
|
|
oldState->updateFromEvents(newTimelineEvents.events);
|
2017-10-28 20:46:34 +03:00
|
|
|
oldState->resolveName();
|
|
|
|
oldState->resolveAvatar();
|
|
|
|
} else {
|
|
|
|
// Build the current state from the timeline and state events.
|
2018-01-13 18:15:47 +03:00
|
|
|
auto roomState = QSharedPointer<RoomState>(new RoomState);
|
|
|
|
roomState->updateFromEvents(newStateEvents.events);
|
|
|
|
roomState->updateFromEvents(newTimelineEvents.events);
|
2017-10-28 20:46:34 +03:00
|
|
|
|
|
|
|
// Resolve room name and avatar. e.g in case of one-to-one chats.
|
2018-01-13 18:15:47 +03:00
|
|
|
roomState->resolveName();
|
|
|
|
roomState->resolveAvatar();
|
2017-10-28 20:46:34 +03:00
|
|
|
|
2018-01-13 18:15:47 +03:00
|
|
|
roomStates_.insert(roomid, roomState);
|
2017-10-28 20:46:34 +03:00
|
|
|
|
2018-01-13 18:15:47 +03:00
|
|
|
roomSettings_.insert(
|
2017-12-04 19:41:19 +03:00
|
|
|
roomid, QSharedPointer<RoomSettings>(new RoomSettings(roomid)));
|
2017-10-28 20:46:34 +03:00
|
|
|
|
2017-12-04 19:41:19 +03:00
|
|
|
view_manager_->addRoom(it->second, roomid);
|
2017-10-28 20:46:34 +03:00
|
|
|
}
|
|
|
|
|
2017-12-04 19:41:19 +03:00
|
|
|
updateUserMetadata(newStateEvents.events);
|
|
|
|
updateUserMetadata(newTimelineEvents.events);
|
2017-10-28 20:46:34 +03:00
|
|
|
|
2017-12-04 19:41:19 +03:00
|
|
|
if (roomid == current_room_)
|
|
|
|
changeTopRoomInfo(roomid);
|
2017-10-28 20:46:34 +03:00
|
|
|
|
|
|
|
QApplication::processEvents();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-01-13 18:15:47 +03:00
|
|
|
QMap<QString, QSharedPointer<RoomState>>
|
2017-12-04 19:41:19 +03:00
|
|
|
ChatPage::generateMembershipDifference(
|
|
|
|
const std::map<std::string, mtx::responses::JoinedRoom> &rooms,
|
2018-01-13 18:15:47 +03:00
|
|
|
const QMap<QString, QSharedPointer<RoomState>> &states) const
|
2017-10-28 20:46:34 +03:00
|
|
|
{
|
2018-01-13 18:15:47 +03:00
|
|
|
QMap<QString, QSharedPointer<RoomState>> stateDiff;
|
2017-10-28 20:46:34 +03:00
|
|
|
|
2017-12-04 19:41:19 +03:00
|
|
|
for (auto it = rooms.cbegin(); it != rooms.cend(); ++it) {
|
|
|
|
const auto room_id = QString::fromStdString(it->first);
|
|
|
|
|
|
|
|
if (!states.contains(room_id))
|
2017-10-28 20:46:34 +03:00
|
|
|
continue;
|
|
|
|
|
2017-12-04 19:41:19 +03:00
|
|
|
auto all_memberships = getMemberships(it->second.state.events);
|
|
|
|
auto timelineMemberships = getMemberships(it->second.timeline.events);
|
2017-10-28 20:46:34 +03:00
|
|
|
|
2017-12-04 19:41:19 +03:00
|
|
|
// We have to process first the state events and then the timeline.
|
|
|
|
for (auto mm = timelineMemberships.cbegin(); mm != timelineMemberships.cend(); ++mm)
|
|
|
|
all_memberships.emplace(mm->first, mm->second);
|
2017-10-28 20:46:34 +03:00
|
|
|
|
2018-01-13 18:15:47 +03:00
|
|
|
auto local = QSharedPointer<RoomState>(new RoomState);
|
|
|
|
local->aliases = states[room_id]->aliases;
|
|
|
|
local->avatar = states[room_id]->avatar;
|
|
|
|
local->canonical_alias = states[room_id]->canonical_alias;
|
|
|
|
local->history_visibility = states[room_id]->history_visibility;
|
|
|
|
local->join_rules = states[room_id]->join_rules;
|
|
|
|
local->name = states[room_id]->name;
|
|
|
|
local->power_levels = states[room_id]->power_levels;
|
|
|
|
local->topic = states[room_id]->topic;
|
|
|
|
local->memberships = all_memberships;
|
2017-12-04 19:41:19 +03:00
|
|
|
|
|
|
|
stateDiff.insert(room_id, local);
|
2017-10-28 20:46:34 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
return stateDiff;
|
|
|
|
}
|
|
|
|
|
2018-01-03 19:05:49 +03:00
|
|
|
void
|
|
|
|
ChatPage::showReadReceipts(const QString &event_id)
|
|
|
|
{
|
|
|
|
if (receiptsDialog_.isNull()) {
|
|
|
|
receiptsDialog_ = QSharedPointer<dialogs::ReadReceipts>(
|
|
|
|
new dialogs::ReadReceipts(this),
|
|
|
|
[=](dialogs::ReadReceipts *dialog) { dialog->deleteLater(); });
|
|
|
|
}
|
|
|
|
|
|
|
|
if (receiptsModal_.isNull()) {
|
|
|
|
receiptsModal_ = QSharedPointer<OverlayModal>(
|
|
|
|
new OverlayModal(MainWindow::instance(), receiptsDialog_.data()),
|
|
|
|
[=](OverlayModal *modal) { modal->deleteLater(); });
|
|
|
|
receiptsModal_->setDuration(0);
|
|
|
|
receiptsModal_->setColor(QColor(30, 30, 30, 170));
|
|
|
|
}
|
|
|
|
|
|
|
|
receiptsDialog_->addUsers(cache_->readReceipts(event_id, current_room_));
|
|
|
|
receiptsModal_->fadeIn();
|
|
|
|
}
|
|
|
|
|
2018-01-09 22:57:41 +03:00
|
|
|
void
|
|
|
|
ChatPage::setGroupViewState(bool isEnabled)
|
|
|
|
{
|
|
|
|
if (!isEnabled) {
|
|
|
|
communitiesList_->communityChanged("world");
|
|
|
|
communitiesSideBar_->hide();
|
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
communitiesSideBar_->show();
|
|
|
|
}
|
|
|
|
|
2017-10-20 21:21:04 +03:00
|
|
|
ChatPage::~ChatPage() {}
|