rnhmjoj
/
nheko
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Merge pull request #474 from Jedi18/room_settings_qml 

Shifted Room Settings Dialog to QML
This commit is contained in:
DeepBlueV7.X 2021-02-19 08:43:03 +00:00 committed by GitHub
parent 9f7dc5488e f76f7b7f8a
commit 744feabeca
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
17 changed files with 1109 additions and 1038 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
CMakeLists.txt
View File

@ -257,7 +257,6 @@ set(SRC_FILES
src/dialogs/PreviewUploadOverlay.cpp
src/dialogs/ReCaptcha.cpp
src/dialogs/ReadReceipts.cpp
src/dialogs/RoomSettings.cpp
# Emoji
src/emoji/EmojiModel.cpp
@ -295,6 +294,7 @@ set(SRC_FILES
src/ui/ThemeManager.cpp
src/ui/ToggleButton.cpp
src/ui/UserProfile.cpp
src/ui/RoomSettings.cpp
src/AvatarProvider.cpp
src/BlurhashProvider.cpp
@ -473,7 +473,6 @@ qt5_wrap_cpp(MOC_HEADERS
src/dialogs/RawMessage.h
src/dialogs/ReCaptcha.h
src/dialogs/ReadReceipts.h
src/dialogs/RoomSettings.h
# Emoji
src/emoji/EmojiModel.h
@ -509,6 +508,7 @@ qt5_wrap_cpp(MOC_HEADERS
src/ui/Theme.h
src/ui/ThemeManager.h
src/ui/UserProfile.h
src/ui/RoomSettings.h
src/notifications/Manager.h

271
resources/qml/RoomSettings.qml Normal file
View File

@ -0,0 +1,271 @@
import QtQuick 2.9
import QtQuick.Controls 2.3
import QtQuick.Layouts 1.2
import QtQuick.Window 2.3
import QtQuick.Dialogs 1.2
import im.nheko 1.0
ApplicationWindow {
id: roomSettingsDialog
property var roomSettings
x: MainWindow.x + (MainWindow.width / 2) - (width / 2)
y: MainWindow.y + (MainWindow.height / 2) - (height / 2)
minimumWidth: 420
minimumHeight: 650
palette: colors
color: colors.window
modality: Qt.WindowModal
Shortcut {
sequence: StandardKey.Cancel
onActivated: roomSettingsDialog.close()
}
ColumnLayout {
id: contentLayout1
anchors.fill: parent
anchors.margins: 10
spacing: 10
Avatar {
url: roomSettings.roomAvatarUrl.replace("mxc://", "image://MxcImage/")
height: 130
width: 130
Layout.alignment: Qt.AlignHCenter
onClicked: {
if(roomSettings.canChangeAvatar) {
roomSettings.updateAvatar();
}
}
}
BusyIndicator {
Layout.alignment: Qt.AlignHCenter
running: roomSettings.isLoading
visible: roomSettings.isLoading
}
Text {
id: errorText
text: "Error Text"
color: "red"
visible: opacity > 0
opacity: 0
Layout.alignment: Qt.AlignHCenter
}
SequentialAnimation {
id: hideErrorAnimation
running: false
PauseAnimation {
duration: 4000
}
NumberAnimation {
target: errorText
property: 'opacity'
to: 0
duration: 1000
}
}
Connections{
target: roomSettings
onDisplayError: {
errorText.text = errorMessage
errorText.opacity = 1
hideErrorAnimation.restart()
}
}
ColumnLayout {
Layout.alignment: Qt.AlignHCenter
MatrixText {
text: roomSettings.roomName
font.pixelSize: 24
Layout.alignment: Qt.AlignHCenter
}
MatrixText {
text: "%1 member(s)".arg(roomSettings.memberCount)
Layout.alignment: Qt.AlignHCenter
}
}
ImageButton {
Layout.alignment: Qt.AlignHCenter
image: ":/icons/icons/ui/edit.png"
visible: roomSettings.canChangeNameAndTopic
onClicked: roomSettings.openEditModal()
}
ScrollView {
Layout.maximumHeight: 75
ScrollBar.horizontal.policy: ScrollBar.AlwaysOff
Layout.alignment: Qt.AlignHCenter
Layout.fillWidth: true
TextArea {
text: roomSettings.roomTopic
wrapMode: TextEdit.WordWrap
readOnly: true
background: null
selectByMouse: true
color: colors.text
horizontalAlignment: TextEdit.AlignHCenter
}
}
GridLayout {
columns: 2
rowSpacing: 10
MatrixText {
text: "SETTINGS"
font.bold: true
}
Item {
Layout.fillWidth: true
}
MatrixText {
text: "Notifications"
Layout.fillWidth: true
}
ComboBox {
model: [ "Muted", "Mentions only", "All messages" ]
currentIndex: roomSettings.notifications
onActivated: {
roomSettings.changeNotifications(index)
}
Layout.fillWidth: true
}
MatrixText {
text: "Room access"
Layout.fillWidth: true
}
ComboBox {
enabled: roomSettings.canChangeJoinRules
model: [ "Anyone and guests", "Anyone", "Invited users" ]
currentIndex: roomSettings.accessJoinRules
onActivated: {
roomSettings.changeAccessRules(index)
}
Layout.fillWidth: true
}
MatrixText {
text: "Encryption"
}
ToggleButton {
id: encryptionToggle
checked: roomSettings.isEncryptionEnabled
onClicked: {
if(roomSettings.isEncryptionEnabled) {
checked=true;
return;
}
confirmEncryptionDialog.open();
}
Layout.alignment: Qt.AlignRight
}
MessageDialog {
id: confirmEncryptionDialog
title: qsTr("End-to-End Encryption")
text: qsTr("Encryption is currently experimental and things might break unexpectedly. <br>
Please take note that it can't be disabled afterwards.")
modality: Qt.WindowModal
icon: StandardIcon.Question
onAccepted: {
if(roomSettings.isEncryptionEnabled) {
return;
}
roomSettings.enableEncryption();
}
onRejected: {
encryptionToggle.checked = false
}
standardButtons: Dialog.Ok | Dialog.Cancel
}
MatrixText {
visible: roomSettings.isEncryptionEnabled
text: "Respond to key requests"
}
ToggleButton {
visible: roomSettings.isEncryptionEnabled
ToolTip.text: qsTr("Whether or not the client should respond automatically with the session keys
upon request. Use with caution, this is a temporary measure to test the
E2E implementation until device verification is completed.")
checked: roomSettings.respondsToKeyRequests
onClicked: {
roomSettings.changeKeyRequestsPreference(checked)
}
Layout.alignment: Qt.AlignRight
}
Item {
// for adding extra space between sections
Layout.fillWidth: true
}
Item {
// for adding extra space between sections
Layout.fillWidth: true
}
MatrixText {
text: "INFO"
font.bold: true
}
Item {
Layout.fillWidth: true
}
MatrixText {
text: "Internal ID"
}
MatrixText {
text: roomSettings.roomId
font.pixelSize: 14
Layout.alignment: Qt.AlignRight
}
MatrixText {
text: "Room Version"
}
MatrixText {
text: roomSettings.roomVersion
font.pixelSize: 14
Layout.alignment: Qt.AlignRight
}
}
Button {
Layout.alignment: Qt.AlignRight
text: "Ok"
onClicked: close()
}
}
}

18
resources/qml/TimelineView.qml
View File

@ -52,6 +52,14 @@ Page {
}
Component {
id: roomSettingsComponent
RoomSettings {
}
}
Component {
id: mobileCallInviteDialog
@ -175,6 +183,16 @@ Page {
}
}
Connections {
target: TimelineManager.timeline
onOpenRoomSettingsDialog: {
var roomSettings = roomSettingsComponent.createObject(timelineRoot, {
"roomSettings": settings
});
roomSettings.show();
}
}
Connections {
target: CallManager
onNewInviteState: {

36
resources/qml/ToggleButton.qml Normal file
View File

@ -0,0 +1,36 @@
import QtQuick 2.5
import QtQuick 2.12
import QtQuick.Controls 2.12
import im.nheko 1.0
Switch {
id: toggleButton
implicitWidth: indicatorItem.width
indicator: Item {
id: indicatorItem
implicitWidth: 48
implicitHeight: 24
y: parent.height / 2 - height / 2
Rectangle {
height: 3 * parent.height/4
radius: height/2
width: parent.width - height
x: radius
y: parent.height / 2 - height / 2
color: toggleButton.checked ? "skyblue" : "grey"
border.color: "#cccccc"
}
Rectangle {
x: toggleButton.checked ? parent.width - width : 0
y: parent.height / 2 - height / 2
width: parent.height
height: width
radius: width/2
color: toggleButton.down ? "whitesmoke" : "whitesmoke"
border.color: "#ebebeb"
}
}
}

6
resources/qml/TopBar.qml
View File

@ -15,7 +15,7 @@ Rectangle {
MouseArea {
anchors.fill: parent
onClicked: TimelineManager.openRoomSettings()
onClicked: TimelineManager.timeline.openRoomSettings()
}
GridLayout {
@ -68,7 +68,7 @@ Rectangle {
MouseArea {
anchors.fill: parent
onClicked: TimelineManager.openRoomSettings()
onClicked: TimelineManager.timeline.openRoomSettings()
}
}
@ -114,7 +114,7 @@ Rectangle {
MenuItem {
text: qsTr("Settings")
onTriggered: TimelineManager.openRoomSettings()
onTriggered: TimelineManager.timeline.openRoomSettings()
}
}

1
resources/qml/UserProfile.qml
View File

@ -118,7 +118,6 @@ ApplicationWindow {
}
}
}
}
MatrixText {

2
resources/res.qrc
View File

@ -128,6 +128,7 @@
<file>qml/EncryptionIndicator.qml</file>
<file>qml/ImageButton.qml</file>
<file>qml/MatrixText.qml</file>
<file>qml/ToggleButton.qml</file>
<file>qml/MessageInput.qml</file>
<file>qml/MessageView.qml</file>
<file>qml/NhekoBusyIndicator.qml</file>
@ -139,6 +140,7 @@
<file>qml/TimelineRow.qml</file>
<file>qml/TopBar.qml</file>
<file>qml/TypingIndicator.qml</file>
<file>qml/RoomSettings.qml</file>
<file>qml/emoji/EmojiButton.qml</file>
<file>qml/emoji/EmojiPicker.qml</file>
<file>qml/UserProfile.qml</file>

9
src/MainWindow.cpp
View File

@ -51,7 +51,6 @@
#include "dialogs/Logout.h"
#include "dialogs/MemberList.h"
#include "dialogs/ReadReceipts.h"
#include "dialogs/RoomSettings.h"
MainWindow *MainWindow::instance_ = nullptr;
@ -363,14 +362,6 @@ MainWindow::hasActiveUser()
settings.contains(prefix + "auth/user_id");
}
void
MainWindow::openRoomSettings(const QString &room_id)
{
auto dialog = new dialogs::RoomSettings(room_id, this);
showDialog(dialog);
}
void
MainWindow::openMemberListDialog(const QString &room_id)
{

2
src/MainWindow.h
View File

@ -54,7 +54,6 @@ class LeaveRoom;
class Logout;
class MemberList;
class ReCaptcha;
class RoomSettings;
}
class MainWindow : public QMainWindow
@ -78,7 +77,6 @@ public:
std::function<void(const mtx::requests::CreateRoom &request)> callback);
void openJoinRoomDialog(std::function<void(const QString &room_id)> callback);
void openLogoutDialog();
void openRoomSettings(const QString &room_id);
void openMemberListDialog(const QString &room_id);
void openReadReceiptsDialog(const QString &event_id);

865
src/dialogs/RoomSettings.cpp
View File

@ -1,865 +0,0 @@
#include "dialogs/RoomSettings.h"
#include <QApplication>
#include <QComboBox>
#include <QEvent>
#include <QFileDialog>
#include <QFontDatabase>
#include <QImageReader>
#include <QLabel>
#include <QMessageBox>
#include <QMimeDatabase>
#include <QPainter>
#include <QPixmap>
#include <QPushButton>
#include <QShortcut>
#include <QShowEvent>
#include <QStandardPaths>
#include <QStyleOption>
#include <QVBoxLayout>
#include <mtx/responses/common.hpp>
#include <mtx/responses/media.hpp>
#include "Cache.h"
#include "ChatPage.h"
#include "Config.h"
#include "Logging.h"
#include "MatrixClient.h"
#include "Utils.h"
#include "ui/Avatar.h"
#include "ui/FlatButton.h"
#include "ui/LoadingIndicator.h"
#include "ui/Painter.h"
#include "ui/TextField.h"
#include "ui/ToggleButton.h"
using namespace dialogs;
using namespace mtx::events;
constexpr int BUTTON_SIZE = 36;
constexpr int BUTTON_RADIUS = BUTTON_SIZE / 2;
constexpr int WIDGET_MARGIN = 20;
constexpr int TOP_WIDGET_MARGIN = 2 * WIDGET_MARGIN;
constexpr int WIDGET_SPACING = 15;
constexpr int TEXT_SPACING = 4;
constexpr int BUTTON_SPACING = 2 * TEXT_SPACING;
bool
ClickableFilter::eventFilter(QObject *obj, QEvent *event)
{
if (event->type() == QEvent::MouseButtonRelease) {
emit clicked();
return true;
}
return QObject::eventFilter(obj, event);
}
EditModal::EditModal(const QString &roomId, QWidget *parent)
: QWidget(parent)
, roomId_{roomId}
{
setAutoFillBackground(true);
setAttribute(Qt::WA_DeleteOnClose, true);
setWindowFlags(Qt::Tool | Qt::WindowStaysOnTopHint);
setWindowModality(Qt::WindowModal);
QFont largeFont;
largeFont.setPointSizeF(largeFont.pointSizeF() * 1.4);
setMinimumWidth(conf::window::minModalWidth);
setSizePolicy(QSizePolicy::Maximum, QSizePolicy::Maximum);
auto layout = new QVBoxLayout(this);
applyBtn_ = new QPushButton(tr("Apply"), this);
cancelBtn_ = new QPushButton(tr("Cancel"), this);
cancelBtn_->setDefault(true);
auto btnLayout = new QHBoxLayout;
btnLayout->addStretch(1);
btnLayout->setSpacing(15);
btnLayout->addWidget(cancelBtn_);
btnLayout->addWidget(applyBtn_);
nameInput_ = new TextField(this);
nameInput_->setLabel(tr("Name").toUpper());
topicInput_ = new TextField(this);
topicInput_->setLabel(tr("Topic").toUpper());
errorField_ = new QLabel(this);
errorField_->setWordWrap(true);
errorField_->hide();
layout->addWidget(nameInput_);
layout->addWidget(topicInput_);
layout->addLayout(btnLayout, 1);
auto labelLayout = new QHBoxLayout;
labelLayout->setAlignment(Qt::AlignHCenter);
labelLayout->addWidget(errorField_);
layout->addLayout(labelLayout);
connect(applyBtn_, &QPushButton::clicked, this, &EditModal::applyClicked);
connect(cancelBtn_, &QPushButton::clicked, this, &EditModal::close);
auto window = QApplication::activeWindow();
auto center = window->frameGeometry().center();
move(center.x() - (width() * 0.5), center.y() - (height() * 0.5));
}
void
EditModal::topicEventSent()
{
errorField_->hide();
close();
}
void
EditModal::nameEventSent(const QString &name)
{
errorField_->hide();
emit nameChanged(name);
close();
}
void
EditModal::error(const QString &msg)
{
errorField_->setText(msg);
errorField_->show();
}
void
EditModal::applyClicked()
{
// Check if the values are changed from the originals.
auto newName = nameInput_->text().trimmed();
auto newTopic = topicInput_->text().trimmed();
errorField_->hide();
if (newName == initialName_ && newTopic == initialTopic_) {
close();
return;
}
using namespace mtx::events;
auto proxy = std::make_shared<ThreadProxy>();
connect(proxy.get(), &ThreadProxy::topicEventSent, this, &EditModal::topicEventSent);
connect(proxy.get(), &ThreadProxy::nameEventSent, this, &EditModal::nameEventSent);
connect(proxy.get(), &ThreadProxy::error, this, &EditModal::error);
if (newName != initialName_ && !newName.isEmpty()) {
state::Name body;
body.name = newName.toStdString();
http::client()->send_state_event(
roomId_.toStdString(),
body,
[proxy, newName](const mtx::responses::EventId &, mtx::http::RequestErr err) {
if (err) {
emit proxy->error(
QString::fromStdString(err->matrix_error.error));
return;
}
emit proxy->nameEventSent(newName);
});
}
if (newTopic != initialTopic_ && !newTopic.isEmpty()) {
state::Topic body;
body.topic = newTopic.toStdString();
http::client()->send_state_event(
roomId_.toStdString(),
body,
[proxy](const mtx::responses::EventId &, mtx::http::RequestErr err) {
if (err) {
emit proxy->error(
QString::fromStdString(err->matrix_error.error));
return;
}
emit proxy->topicEventSent();
});
}
}
void
EditModal::setFields(const QString &roomName, const QString &roomTopic)
{
initialName_ = roomName;
initialTopic_ = roomTopic;
nameInput_->setText(roomName);
topicInput_->setText(roomTopic);
}
RoomSettings::RoomSettings(const QString &room_id, QWidget *parent)
: QFrame(parent)
, room_id_{std::move(room_id)}
{
retrieveRoomInfo();
setAutoFillBackground(true);
setWindowFlags(Qt::Tool | Qt::WindowStaysOnTopHint);
setWindowModality(Qt::WindowModal);
setAttribute(Qt::WA_DeleteOnClose, true);
QFont largeFont;
largeFont.setPointSizeF(largeFont.pointSizeF() * 1.5);
setMinimumWidth(conf::window::minModalWidth);
setSizePolicy(QSizePolicy::Maximum, QSizePolicy::Maximum);
auto layout = new QVBoxLayout(this);
layout->setSpacing(WIDGET_SPACING);
layout->setContentsMargins(WIDGET_MARGIN, TOP_WIDGET_MARGIN, WIDGET_MARGIN, WIDGET_MARGIN);
QFont font;
font.setWeight(QFont::Medium);
auto settingsLabel = new QLabel(tr("Settings").toUpper(), this);
settingsLabel->setFont(font);
auto infoLabel = new QLabel(tr("Info").toUpper(), this);
infoLabel->setFont(font);
QFont monospaceFont = QFontDatabase::systemFont(QFontDatabase::FixedFont);
auto roomIdLabel = new QLabel(room_id, this);
roomIdLabel->setTextInteractionFlags(Qt::TextSelectableByMouse);
roomIdLabel->setFont(monospaceFont);
auto roomIdLayout = new QHBoxLayout;
roomIdLayout->setMargin(0);
roomIdLayout->addWidget(new QLabel(tr("Internal ID"), this),
Qt::AlignBottom | Qt::AlignLeft);
roomIdLayout->addWidget(roomIdLabel, 0, Qt::AlignBottom | Qt::AlignRight);
auto roomVersionLabel = new QLabel(QString::fromStdString(info_.version), this);
roomVersionLabel->setTextInteractionFlags(Qt::TextSelectableByMouse);
roomVersionLabel->setFont(monospaceFont);
auto roomVersionLayout = new QHBoxLayout;
roomVersionLayout->setMargin(0);
roomVersionLayout->addWidget(new QLabel(tr("Room Version"), this),
Qt::AlignBottom | Qt::AlignLeft);
roomVersionLayout->addWidget(roomVersionLabel, 0, Qt::AlignBottom | Qt::AlignRight);
auto notifLabel = new QLabel(tr("Notifications"), this);
notifCombo = new QComboBox(this);
notifCombo->addItem(tr(
"Muted")); //{"conditions":[{"kind":"event_match","key":"room_id","pattern":"!jxlRxnrZCsjpjDubDX:matrix.org"}],"actions":["dont_notify"]}
notifCombo->addItem(tr("Mentions only")); // {"actions":["dont_notify"]}
notifCombo->addItem(tr("All messages")); // delete rule
connect(this, &RoomSettings::notifChanged, notifCombo, &QComboBox::setCurrentIndex);
http::client()->get_pushrules(
"global",
"override",
room_id_.toStdString(),
[this](const mtx::pushrules::PushRule &rule, mtx::http::RequestErr &err) {
if (err) {
if (err->status_code == boost::beast::http::status::not_found)
http::client()->get_pushrules(
"global",
"room",
room_id_.toStdString(),
[this](const mtx::pushrules::PushRule &rule,
mtx::http::RequestErr &err) {
if (err) {
emit notifChanged(2); // all messages
return;
}
if (rule.enabled)
emit notifChanged(1); // mentions only
});
return;
}
if (rule.enabled)
emit notifChanged(0); // muted
else
emit notifChanged(2); // all messages
});
connect(notifCombo, QOverload<int>::of(&QComboBox::activated), [this](int index) {
std::string room_id = room_id_.toStdString();
if (index == 0) {
// mute room
// delete old rule first, then add new rule
mtx::pushrules::PushRule rule;
rule.actions = {mtx::pushrules::actions::dont_notify{}};
mtx::pushrules::PushCondition condition;
condition.kind = "event_match";
condition.key = "room_id";
condition.pattern = room_id;
rule.conditions = {condition};
http::client()->put_pushrules(
"global",
"override",
room_id,
rule,
[room_id](mtx::http::RequestErr &err) {
if (err)
nhlog::net()->error(
"failed to set pushrule for room {}: {} {}",
room_id,
static_cast<int>(err->status_code),
err->matrix_error.error);
http::client()->delete_pushrules(
"global", "room", room_id, [room_id](mtx::http::RequestErr &) {
});
});
} else if (index == 1) {
// mentions only
// delete old rule first, then add new rule
mtx::pushrules::PushRule rule;
rule.actions = {mtx::pushrules::actions::dont_notify{}};
http::client()->put_pushrules(
"global", "room", room_id, rule, [room_id](mtx::http::RequestErr &err) {
if (err)
nhlog::net()->error(
"failed to set pushrule for room {}: {} {}",
room_id,
static_cast<int>(err->status_code),
err->matrix_error.error);
http::client()->delete_pushrules(
"global",
"override",
room_id,
[room_id](mtx::http::RequestErr &) {});
});
} else {
// all messages
http::client()->delete_pushrules(
"global", "override", room_id, [room_id](mtx::http::RequestErr &) {
http::client()->delete_pushrules(
"global", "room", room_id, [room_id](mtx::http::RequestErr &) {
});
});
}
});
auto notifOptionLayout_ = new QHBoxLayout;
notifOptionLayout_->setMargin(0);
notifOptionLayout_->addWidget(notifLabel, Qt::AlignBottom | Qt::AlignLeft);
notifOptionLayout_->addWidget(notifCombo, 0, Qt::AlignBottom | Qt::AlignRight);
auto accessLabel = new QLabel(tr("Room access"), this);
accessCombo = new QComboBox(this);
accessCombo->addItem(tr("Anyone and guests"));
accessCombo->addItem(tr("Anyone"));
accessCombo->addItem(tr("Invited users"));
accessCombo->setDisabled(
!canChangeJoinRules(room_id_.toStdString(), utils::localUser().toStdString()));
connect(accessCombo, QOverload<int>::of(&QComboBox::activated), [this](int index) {
using namespace mtx::events::state;
auto guest_access = [](int index) -> state::GuestAccess {
state::GuestAccess event;
if (index == 0)
event.guest_access = state::AccessState::CanJoin;
else
event.guest_access = state::AccessState::Forbidden;
return event;
}(index);
auto join_rule = [](int index) -> state::JoinRules {
state::JoinRules event;
switch (index) {
case 0:
case 1:
event.join_rule = state::JoinRule::Public;
break;
default:
event.join_rule = state::JoinRule::Invite;
}
return event;
}(index);
updateAccessRules(room_id_.toStdString(), join_rule, guest_access);
});
if (info_.join_rule == state::JoinRule::Public) {
if (info_.guest_access) {
accessCombo->setCurrentIndex(0);
} else {
accessCombo->setCurrentIndex(1);
}
} else {
accessCombo->setCurrentIndex(2);
}
auto accessOptionLayout = new QHBoxLayout();
accessOptionLayout->setMargin(0);
accessOptionLayout->addWidget(accessLabel, Qt::AlignBottom | Qt::AlignLeft);
accessOptionLayout->addWidget(accessCombo, 0, Qt::AlignBottom | Qt::AlignRight);
auto encryptionLabel = new QLabel(tr("Encryption"), this);
encryptionToggle_ = new Toggle(this);
auto encryptionOptionLayout = new QHBoxLayout;
encryptionOptionLayout->setMargin(0);
encryptionOptionLayout->addWidget(encryptionLabel, Qt::AlignBottom | Qt::AlignLeft);
encryptionOptionLayout->addWidget(encryptionToggle_, 0, Qt::AlignBottom | Qt::AlignRight);
auto keyRequestsLabel = new QLabel(tr("Respond to key requests"), this);
keyRequestsLabel->setToolTipDuration(6000);
keyRequestsLabel->setToolTip(
tr("Whether or not the client should respond automatically with the session keys\n"
" upon request. Use with caution, this is a temporary measure to test the\n"
" E2E implementation until device verification is completed."));
keyRequestsToggle_ = new Toggle(this);
connect(keyRequestsToggle_, &Toggle::toggled, this, [this](bool isOn) {
utils::setKeyRequestsPreference(room_id_, isOn);
});
auto keyRequestsLayout = new QHBoxLayout;
keyRequestsLayout->setMargin(0);
keyRequestsLayout->setSpacing(0);
keyRequestsLayout->addWidget(keyRequestsLabel, Qt::AlignBottom | Qt::AlignLeft);
keyRequestsLayout->addWidget(keyRequestsToggle_, 0, Qt::AlignBottom | Qt::AlignRight);
connect(encryptionToggle_, &Toggle::toggled, this, [this, keyRequestsLabel](bool isOn) {
if (!isOn || usesEncryption_)
return;
QMessageBox msgBox;
msgBox.setIcon(QMessageBox::Question);
msgBox.setWindowTitle(tr("End-to-End Encryption"));
msgBox.setText(tr(
"Encryption is currently experimental and things might break unexpectedly. <br>"
"Please take note that it can't be disabled afterwards."));
msgBox.setStandardButtons(QMessageBox::Ok | QMessageBox::Cancel);
msgBox.setDefaultButton(QMessageBox::Save);
int ret = msgBox.exec();
switch (ret) {
case QMessageBox::Ok: {
encryptionToggle_->setState(true);
encryptionToggle_->setEnabled(false);
enableEncryption();
keyRequestsToggle_->show();
keyRequestsLabel->show();
break;
}
default: {
break;
}
}
});
// Disable encryption button.
if (usesEncryption_) {
encryptionToggle_->setState(true);
encryptionToggle_->setEnabled(false);
keyRequestsToggle_->setState(utils::respondsToKeyRequests(room_id_));
} else {
encryptionToggle_->setState(false);
keyRequestsLabel->hide();
keyRequestsToggle_->hide();
}
// Hide encryption option for public rooms.
if (!usesEncryption_ && (info_.join_rule == state::JoinRule::Public)) {
encryptionToggle_->hide();
encryptionLabel->hide();
keyRequestsLabel->hide();
keyRequestsToggle_->hide();
}
avatar_ = new Avatar(this, 128);
avatar_->setLetter(utils::firstChar(QString::fromStdString(info_.name)));
if (!info_.avatar_url.empty())
avatar_->setImage(QString::fromStdString(info_.avatar_url));
if (canChangeAvatar(room_id_.toStdString(), utils::localUser().toStdString())) {
auto filter = new ClickableFilter(this);
avatar_->installEventFilter(filter);
avatar_->setCursor(Qt::PointingHandCursor);
connect(filter, &ClickableFilter::clicked, this, &RoomSettings::updateAvatar);
}
roomNameLabel_ = new QLabel(QString::fromStdString(info_.name), this);
roomNameLabel_->setFont(largeFont);
auto membersLabel = new QLabel(tr("%n member(s)", "", (int)info_.member_count), this);
auto textLayout = new QVBoxLayout;
textLayout->addWidget(roomNameLabel_);
textLayout->addWidget(membersLabel);
textLayout->setAlignment(roomNameLabel_, Qt::AlignCenter | Qt::AlignTop);
textLayout->setAlignment(membersLabel, Qt::AlignCenter | Qt::AlignTop);
textLayout->setSpacing(TEXT_SPACING);
textLayout->setMargin(0);
setupEditButton();
errorLabel_ = new QLabel(this);
errorLabel_->setAlignment(Qt::AlignCenter);
errorLabel_->hide();
spinner_ = new LoadingIndicator(this);
spinner_->setFixedHeight(30);
spinner_->setFixedWidth(30);
spinner_->hide();
auto spinnerLayout = new QVBoxLayout;
spinnerLayout->addWidget(spinner_);
spinnerLayout->setAlignment(Qt::AlignCenter);
spinnerLayout->setMargin(0);
spinnerLayout->setSpacing(0);
auto okBtn = new QPushButton("OK", this);
auto buttonLayout = new QHBoxLayout();
buttonLayout->setSpacing(15);
buttonLayout->addStretch(1);
buttonLayout->addWidget(okBtn);
layout->addWidget(avatar_, Qt::AlignCenter | Qt::AlignTop);
layout->addLayout(textLayout);
layout->addLayout(btnLayout_);
layout->addWidget(settingsLabel, Qt::AlignLeft);
layout->addLayout(notifOptionLayout_);
layout->addLayout(accessOptionLayout);
layout->addLayout(encryptionOptionLayout);
layout->addLayout(keyRequestsLayout);
layout->addWidget(infoLabel, Qt::AlignLeft);
layout->addLayout(roomIdLayout);
layout->addLayout(roomVersionLayout);
layout->addWidget(errorLabel_);
layout->addLayout(buttonLayout);
layout->addLayout(spinnerLayout);
layout->addStretch(1);
connect(this, &RoomSettings::enableEncryptionError, this, [this](const QString &msg) {
encryptionToggle_->setState(false);
keyRequestsToggle_->setState(false);
keyRequestsToggle_->setEnabled(false);
keyRequestsToggle_->hide();
emit ChatPage::instance()->showNotification(msg);
});
connect(this, &RoomSettings::showErrorMessage, this, [this](const QString &msg) {
if (!errorLabel_)
return;
stopLoadingSpinner();
errorLabel_->show();
errorLabel_->setText(msg);
});
connect(this, &RoomSettings::accessRulesUpdated, this, [this]() {
stopLoadingSpinner();
resetErrorLabel();
});
auto closeShortcut = new QShortcut(QKeySequence(QKeySequence::Cancel), this);
connect(closeShortcut, &QShortcut::activated, this, &RoomSettings::close);
connect(okBtn, &QPushButton::clicked, this, &RoomSettings::close);
}
void
RoomSettings::setupEditButton()
{
btnLayout_ = new QHBoxLayout;
btnLayout_->setSpacing(BUTTON_SPACING);
btnLayout_->setMargin(0);
if (!canChangeNameAndTopic(room_id_.toStdString(), utils::localUser().toStdString()))
return;
QIcon editIcon;
editIcon.addFile(":/icons/icons/ui/edit.png");
editFieldsBtn_ = new FlatButton(this);
editFieldsBtn_->setFixedSize(BUTTON_SIZE, BUTTON_SIZE);
editFieldsBtn_->setCornerRadius(BUTTON_RADIUS);
editFieldsBtn_->setIcon(editIcon);
editFieldsBtn_->setIcon(editIcon);
editFieldsBtn_->setIconSize(QSize(BUTTON_RADIUS, BUTTON_RADIUS));
connect(editFieldsBtn_, &QPushButton::clicked, this, [this]() {
retrieveRoomInfo();
auto modal = new EditModal(room_id_, this);
modal->setFields(QString::fromStdString(info_.name),
QString::fromStdString(info_.topic));
modal->raise();
modal->show();
connect(modal, &EditModal::nameChanged, this, [this](const QString &newName) {
if (roomNameLabel_)
roomNameLabel_->setText(newName);
});
});
btnLayout_->addStretch(1);
btnLayout_->addWidget(editFieldsBtn_);
btnLayout_->addStretch(1);
}
void
RoomSettings::retrieveRoomInfo()
{
try {
usesEncryption_ = cache::isRoomEncrypted(room_id_.toStdString());
info_ = cache::singleRoomInfo(room_id_.toStdString());
setAvatar();
} catch (const lmdb::error &) {
nhlog::db()->warn("failed to retrieve room info from cache: {}",
room_id_.toStdString());
}
}
void
RoomSettings::enableEncryption()
{
const auto room_id = room_id_.toStdString();
http::client()->enable_encryption(
room_id, [room_id, this](const mtx::responses::EventId &, mtx::http::RequestErr err) {
if (err) {
int status_code = static_cast<int>(err->status_code);
nhlog::net()->warn("failed to enable encryption in room ({}): {} {}",
room_id,
err->matrix_error.error,
status_code);
emit enableEncryptionError(
tr("Failed to enable encryption: %1")
.arg(QString::fromStdString(err->matrix_error.error)));
return;
}
nhlog::net()->info("enabled encryption on room ({})", room_id);
});
}
void
RoomSettings::showEvent(QShowEvent *event)
{
resetErrorLabel();
stopLoadingSpinner();
QWidget::showEvent(event);
}
bool
RoomSettings::canChangeJoinRules(const std::string &room_id, const std::string &user_id) const
{
try {
return cache::hasEnoughPowerLevel({EventType::RoomJoinRules}, room_id, user_id);
} catch (const lmdb::error &e) {
nhlog::db()->warn("lmdb error: {}", e.what());
}
return false;
}
bool
RoomSettings::canChangeNameAndTopic(const std::string &room_id, const std::string &user_id) const
{
try {
return cache::hasEnoughPowerLevel(
{EventType::RoomName, EventType::RoomTopic}, room_id, user_id);
} catch (const lmdb::error &e) {
nhlog::db()->warn("lmdb error: {}", e.what());
}
return false;
}
bool
RoomSettings::canChangeAvatar(const std::string &room_id, const std::string &user_id) const
{
try {
return cache::hasEnoughPowerLevel({EventType::RoomAvatar}, room_id, user_id);
} catch (const lmdb::error &e) {
nhlog::db()->warn("lmdb error: {}", e.what());
}
return false;
}
void
RoomSettings::updateAccessRules(const std::string &room_id,
const mtx::events::state::JoinRules &join_rule,
const mtx::events::state::GuestAccess &guest_access)
{
startLoadingSpinner();
resetErrorLabel();
http::client()->send_state_event(
room_id,
join_rule,
[this, room_id, guest_access](const mtx::responses::EventId &,
mtx::http::RequestErr err) {
if (err) {
nhlog::net()->warn("failed to send m.room.join_rule: {} {}",
static_cast<int>(err->status_code),
err->matrix_error.error);
emit showErrorMessage(QString::fromStdString(err->matrix_error.error));
return;
}
http::client()->send_state_event(
room_id,
guest_access,
[this](const mtx::responses::EventId &, mtx::http::RequestErr err) {
if (err) {
nhlog::net()->warn("failed to send m.room.guest_access: {} {}",
static_cast<int>(err->status_code),
err->matrix_error.error);
emit showErrorMessage(
QString::fromStdString(err->matrix_error.error));
return;
}
emit accessRulesUpdated();
});
});
}
void
RoomSettings::stopLoadingSpinner()
{
if (spinner_) {
spinner_->stop();
spinner_->hide();
}
}
void
RoomSettings::startLoadingSpinner()
{
if (spinner_) {
spinner_->start();
spinner_->show();
}
}
void
RoomSettings::displayErrorMessage(const QString &msg)
{
stopLoadingSpinner();
errorLabel_->show();
errorLabel_->setText(msg);
}
void
RoomSettings::setAvatar()
{
stopLoadingSpinner();
if (avatar_)
avatar_->setImage(QString::fromStdString(info_.avatar_url));
}
void
RoomSettings::resetErrorLabel()
{
if (errorLabel_) {
errorLabel_->hide();
errorLabel_->clear();
}
}
void
RoomSettings::updateAvatar()
{
const QString picturesFolder =
QStandardPaths::writableLocation(QStandardPaths::PicturesLocation);
const QString fileName = QFileDialog::getOpenFileName(
this, tr("Select an avatar"), picturesFolder, tr("All Files (*)"));
if (fileName.isEmpty())
return;
QMimeDatabase db;
QMimeType mime = db.mimeTypeForFile(fileName, QMimeDatabase::MatchContent);
const auto format = mime.name().split("/")[0];
QFile file{fileName, this};
if (format != "image") {
displayErrorMessage(tr("The selected file is not an image"));
return;
}
if (!file.open(QIODevice::ReadOnly)) {
displayErrorMessage(tr("Error while reading file: %1").arg(file.errorString()));
return;
}
if (spinner_) {
startLoadingSpinner();
resetErrorLabel();
}
// Events emitted from the http callbacks (different threads) will
// be queued back into the UI thread through this proxy object.
auto proxy = std::make_shared<ThreadProxy>();
connect(proxy.get(), &ThreadProxy::error, this, &RoomSettings::displayErrorMessage);
connect(proxy.get(), &ThreadProxy::avatarChanged, this, &RoomSettings::setAvatar);
const auto bin = file.peek(file.size());
const auto payload = std::string(bin.data(), bin.size());
const auto dimensions = QImageReader(&file).size();
// First we need to create a new mxc URI
// (i.e upload media to the Matrix content repository) for the new avatar.
http::client()->upload(
payload,
mime.name().toStdString(),
QFileInfo(fileName).fileName().toStdString(),
[proxy = std::move(proxy),
dimensions,
payload,
mimetype = mime.name().toStdString(),
size = payload.size(),
room_id = room_id_.toStdString(),
content = std::move(bin)](const mtx::responses::ContentURI &res,
mtx::http::RequestErr err) {
if (err) {
emit proxy->error(
tr("Failed to upload image: %s")
.arg(QString::fromStdString(err->matrix_error.error)));
return;
}
using namespace mtx::events;
state::Avatar avatar_event;
avatar_event.image_info.w = dimensions.width();
avatar_event.image_info.h = dimensions.height();
avatar_event.image_info.mimetype = mimetype;
avatar_event.image_info.size = size;
avatar_event.url = res.content_uri;
http::client()->send_state_event(
room_id,
avatar_event,
[content = std::move(content), proxy = std::move(proxy)](
const mtx::responses::EventId &, mtx::http::RequestErr err) {
if (err) {
emit proxy->error(
tr("Failed to upload image: %s")
.arg(QString::fromStdString(err->matrix_error.error)));
return;
}
emit proxy->avatarChanged();
});
});
}

150
src/dialogs/RoomSettings.h
View File

@ -1,150 +0,0 @@
#pragma once
#include <QFrame>
#include <QImage>
#include <mtx/events/guest_access.hpp>
#include "CacheStructs.h"
class Avatar;
class FlatButton;
class QPushButton;
class QComboBox;
class QHBoxLayout;
class QShowEvent;
class LoadingIndicator;
class QLayout;
class QPixmap;
class TextField;
class TextField;
class Toggle;
class QLabel;
class QEvent;
class ClickableFilter : public QObject
{
Q_OBJECT
public:
explicit ClickableFilter(QWidget *parent)
: QObject(parent)
{}
signals:
void clicked();
protected:
bool eventFilter(QObject *obj, QEvent *event) override;
};
/// Convenience class which connects events emmited from threads
/// outside of main with the UI code.
class ThreadProxy : public QObject
{
Q_OBJECT
signals:
void error(const QString &msg);
void avatarChanged();
void nameEventSent(const QString &);
void topicEventSent();
};
class EditModal : public QWidget
{
Q_OBJECT
public:
EditModal(const QString &roomId, QWidget *parent = nullptr);
void setFields(const QString &roomName, const QString &roomTopic);
signals:
void nameChanged(const QString &roomName);
private slots:
void topicEventSent();
void nameEventSent(const QString &name);
void error(const QString &msg);
void applyClicked();
private:
QString roomId_;
QString initialName_;
QString initialTopic_;
QLabel *errorField_;
TextField *nameInput_;
TextField *topicInput_;
QPushButton *applyBtn_;
QPushButton *cancelBtn_;
};
namespace dialogs {
class RoomSettings : public QFrame
{
Q_OBJECT
public:
RoomSettings(const QString &room_id, QWidget *parent = nullptr);
signals:
void enableEncryptionError(const QString &msg);
void showErrorMessage(const QString &msg);
void accessRulesUpdated();
void notifChanged(int index);
protected:
void showEvent(QShowEvent *event) override;
private slots:
//! The file dialog opens so the user can select and upload a new room avatar.
void updateAvatar();
private:
//! Whether the user has enough power level to send m.room.join_rules events.
bool canChangeJoinRules(const std::string &room_id, const std::string &user_id) const;
//! Whether the user has enough power level to send m.room.name & m.room.topic events.
bool canChangeNameAndTopic(const std::string &room_id, const std::string &user_id) const;
//! Whether the user has enough power level to send m.room.avatar event.
bool canChangeAvatar(const std::string &room_id, const std::string &user_id) const;
void updateAccessRules(const std::string &room_id,
const mtx::events::state::JoinRules &,
const mtx::events::state::GuestAccess &);
void stopLoadingSpinner();
void startLoadingSpinner();
void resetErrorLabel();
void displayErrorMessage(const QString &msg);
void setAvatar();
void setupEditButton();
//! Retrieve the current room information from cache.
void retrieveRoomInfo();
void enableEncryption();
Avatar *avatar_ = nullptr;
bool usesEncryption_ = false;
QHBoxLayout *btnLayout_;
FlatButton *editFieldsBtn_ = nullptr;
RoomInfo info_;
QString room_id_;
QImage avatarImg_;
QLabel *roomNameLabel_ = nullptr;
QLabel *errorLabel_ = nullptr;
LoadingIndicator *spinner_ = nullptr;
QComboBox *notifCombo = nullptr;
QComboBox *accessCombo = nullptr;
Toggle *encryptionToggle_ = nullptr;
Toggle *keyRequestsToggle_ = nullptr;
};
} // dialogs

8
src/timeline/TimelineModel.cpp
View File

@ -836,6 +836,14 @@ TimelineModel::openUserProfile(QString userid, bool global)
emit openProfile(userProfile);
}
void
TimelineModel::openRoomSettings()
{
RoomSettings *settings = new RoomSettings(roomId(), this);
connect(this, &TimelineModel::roomAvatarUrlChanged, settings, &RoomSettings::avatarChanged);
openRoomSettingsDialog(settings);
}
void
TimelineModel::replyAction(QString id)
{

3
src/timeline/TimelineModel.h
View File

@ -11,6 +11,7 @@
#include "CacheCryptoStructs.h"
#include "EventStore.h"
#include "InputBar.h"
#include "ui/RoomSettings.h"
#include "ui/UserProfile.h"
namespace mtx::http {
@ -216,6 +217,7 @@ public:
Q_INVOKABLE void viewRawMessage(QString id) const;
Q_INVOKABLE void viewDecryptedRawMessage(QString id) const;
Q_INVOKABLE void openUserProfile(QString userid, bool global = false);
Q_INVOKABLE void openRoomSettings();
Q_INVOKABLE void editAction(QString id);
Q_INVOKABLE void replyAction(QString id);
Q_INVOKABLE void readReceiptsAction(QString id) const;
@ -307,6 +309,7 @@ signals:
void newCallEvent(const mtx::events::collections::TimelineEvents &event);
void openProfile(UserProfile *profile);
void openRoomSettingsDialog(RoomSettings *settings);
void newMessageToSend(mtx::events::collections::TimelineEvents event);
void addPendingMessageToStore(mtx::events::collections::TimelineEvents event);

11
src/timeline/TimelineViewManager.cpp
View File

@ -128,6 +128,12 @@ TimelineViewManager::TimelineViewManager(CallManager *callManager, ChatPage *par
0,
"UserProfileModel",
"UserProfile needs to be instantiated on the C++ side");
qmlRegisterUncreatableType<RoomSettings>(
"im.nheko",
1,
0,
"RoomSettingsModel",
"Room Settings needs to be instantiated on the C++ side");
static auto self = this;
qmlRegisterSingletonType<MainWindow>(
@ -387,11 +393,6 @@ TimelineViewManager::openLeaveRoomDialog() const
{
MainWindow::instance()->openLeaveRoomDialog(timeline_->roomId());
}
void
TimelineViewManager::openRoomSettings() const
{
MainWindow::instance()->openRoomSettings(timeline_->roomId());
}
void
TimelineViewManager::verifyUser(QString userid)

1
src/timeline/TimelineViewManager.h
View File

@ -70,7 +70,6 @@ public:
Q_INVOKABLE void openInviteUsersDialog();
Q_INVOKABLE void openMemberListDialog() const;
Q_INVOKABLE void openLeaveRoomDialog() const;
Q_INVOKABLE void openRoomSettings() const;
Q_INVOKABLE void removeVerificationFlow(DeviceVerificationFlow *flow);
void verifyUser(QString userid);

625
src/ui/RoomSettings.cpp Normal file
View File

@ -0,0 +1,625 @@
#include "RoomSettings.h"
#include <QApplication>
#include <QFileDialog>
#include <QHBoxLayout>
#include <QImageReader>
#include <QMimeDatabase>
#include <QStandardPaths>
#include <QVBoxLayout>
#include <mtx/responses/common.hpp>
#include <mtx/responses/media.hpp>
#include "Cache.h"
#include "Config.h"
#include "Logging.h"
#include "MatrixClient.h"
#include "Utils.h"
#include "ui/TextField.h"
using namespace mtx::events;
EditModal::EditModal(const QString &roomId, QWidget *parent)
: QWidget(parent)
, roomId_{roomId}
{
setAutoFillBackground(true);
setAttribute(Qt::WA_DeleteOnClose, true);
setWindowFlags(Qt::Tool | Qt::WindowStaysOnTopHint);
setWindowModality(Qt::WindowModal);
QFont largeFont;
largeFont.setPointSizeF(largeFont.pointSizeF() * 1.4);
setMinimumWidth(conf::window::minModalWidth);
setSizePolicy(QSizePolicy::Maximum, QSizePolicy::Maximum);
auto layout = new QVBoxLayout(this);
applyBtn_ = new QPushButton(tr("Apply"), this);
cancelBtn_ = new QPushButton(tr("Cancel"), this);
cancelBtn_->setDefault(true);
auto btnLayout = new QHBoxLayout;
btnLayout->addStretch(1);
btnLayout->setSpacing(15);
btnLayout->addWidget(cancelBtn_);
btnLayout->addWidget(applyBtn_);
nameInput_ = new TextField(this);
nameInput_->setLabel(tr("Name").toUpper());
topicInput_ = new TextField(this);
topicInput_->setLabel(tr("Topic").toUpper());
errorField_ = new QLabel(this);
errorField_->setWordWrap(true);
errorField_->hide();
layout->addWidget(nameInput_);
layout->addWidget(topicInput_);
layout->addLayout(btnLayout, 1);
auto labelLayout = new QHBoxLayout;
labelLayout->setAlignment(Qt::AlignHCenter);
labelLayout->addWidget(errorField_);
layout->addLayout(labelLayout);
connect(applyBtn_, &QPushButton::clicked, this, &EditModal::applyClicked);
connect(cancelBtn_, &QPushButton::clicked, this, &EditModal::close);
auto window = QApplication::activeWindow();
if (window != nullptr) {
auto center = window->frameGeometry().center();
move(center.x() - (width() * 0.5), center.y() - (height() * 0.5));
}
}
void
EditModal::topicEventSent(const QString &topic)
{
errorField_->hide();
emit topicChanged(topic);
close();
}
void
EditModal::nameEventSent(const QString &name)
{
errorField_->hide();
emit nameChanged(name);
close();
}
void
EditModal::error(const QString &msg)
{
errorField_->setText(msg);
errorField_->show();
}
void
EditModal::applyClicked()
{
// Check if the values are changed from the originals.
auto newName = nameInput_->text().trimmed();
auto newTopic = topicInput_->text().trimmed();
errorField_->hide();
if (newName == initialName_ && newTopic == initialTopic_) {
close();
return;
}
using namespace mtx::events;
auto proxy = std::make_shared<ThreadProxy>();
connect(proxy.get(), &ThreadProxy::topicEventSent, this, &EditModal::topicEventSent);
connect(proxy.get(), &ThreadProxy::nameEventSent, this, &EditModal::nameEventSent);
connect(proxy.get(), &ThreadProxy::error, this, &EditModal::error);
if (newName != initialName_ && !newName.isEmpty()) {
state::Name body;
body.name = newName.toStdString();
http::client()->send_state_event(
roomId_.toStdString(),
body,
[proxy, newName](const mtx::responses::EventId &, mtx::http::RequestErr err) {
if (err) {
emit proxy->error(
QString::fromStdString(err->matrix_error.error));
return;
}
emit proxy->nameEventSent(newName);
});
}
if (newTopic != initialTopic_ && !newTopic.isEmpty()) {
state::Topic body;
body.topic = newTopic.toStdString();
http::client()->send_state_event(
roomId_.toStdString(),
body,
[proxy, newTopic](const mtx::responses::EventId &, mtx::http::RequestErr err) {
if (err) {
emit proxy->error(
QString::fromStdString(err->matrix_error.error));
return;
}
emit proxy->topicEventSent(newTopic);
});
}
}
void
EditModal::setFields(const QString &roomName, const QString &roomTopic)
{
initialName_ = roomName;
initialTopic_ = roomTopic;
nameInput_->setText(roomName);
topicInput_->setText(roomTopic);
}
RoomSettings::RoomSettings(QString roomid, QObject *parent)
: QObject(parent)
, roomid_{std::move(roomid)}
{
retrieveRoomInfo();
// get room setting notifications
http::client()->get_pushrules(
"global",
"override",
roomid_.toStdString(),
[this](const mtx::pushrules::PushRule &rule, mtx::http::RequestErr &err) {
if (err) {
if (err->status_code == boost::beast::http::status::not_found)
http::client()->get_pushrules(
"global",
"room",
roomid_.toStdString(),
[this](const mtx::pushrules::PushRule &rule,
mtx::http::RequestErr &err) {
if (err) {
notifications_ = 2; // all messages
emit notificationsChanged();
return;
}
if (rule.enabled) {
notifications_ = 1; // mentions only
emit notificationsChanged();
}
});
return;
}
if (rule.enabled) {
notifications_ = 0; // muted
emit notificationsChanged();
} else {
notifications_ = 2; // all messages
emit notificationsChanged();
}
});
// access rules
if (info_.join_rule == state::JoinRule::Public) {
if (info_.guest_access) {
accessRules_ = 0;
} else {
accessRules_ = 1;
}
} else {
accessRules_ = 2;
}
emit accessJoinRulesChanged();
}
QString
RoomSettings::roomName() const
{
return QString::fromStdString(info_.name);
}
QString
RoomSettings::roomTopic() const
{
return QString::fromStdString(info_.topic);
}
QString
RoomSettings::roomId() const
{
return roomid_;
}
QString
RoomSettings::roomVersion() const
{
return QString::fromStdString(info_.version);
}
bool
RoomSettings::isLoading() const
{
return isLoading_;
}
QString
RoomSettings::roomAvatarUrl()
{
return QString::fromStdString(info_.avatar_url);
}
int
RoomSettings::memberCount() const
{
return info_.member_count;
}
void
RoomSettings::retrieveRoomInfo()
{
try {
usesEncryption_ = cache::isRoomEncrypted(roomid_.toStdString());
info_ = cache::singleRoomInfo(roomid_.toStdString());
} catch (const lmdb::error &) {
nhlog::db()->warn("failed to retrieve room info from cache: {}",
roomid_.toStdString());
}
}
int
RoomSettings::notifications()
{
return notifications_;
}
int
RoomSettings::accessJoinRules()
{
return accessRules_;
}
bool
RoomSettings::respondsToKeyRequests()
{
return usesEncryption_ && utils::respondsToKeyRequests(roomid_);
}
void
RoomSettings::changeKeyRequestsPreference(bool isOn)
{
utils::setKeyRequestsPreference(roomid_, isOn);
emit keyRequestsChanged();
}
void
RoomSettings::enableEncryption()
{
if (usesEncryption_)
return;
const auto room_id = roomid_.toStdString();
http::client()->enable_encryption(
room_id, [room_id, this](const mtx::responses::EventId &, mtx::http::RequestErr err) {
if (err) {
int status_code = static_cast<int>(err->status_code);
nhlog::net()->warn("failed to enable encryption in room ({}): {} {}",
room_id,
err->matrix_error.error,
status_code);
emit displayError(
tr("Failed to enable encryption: %1")
.arg(QString::fromStdString(err->matrix_error.error)));
usesEncryption_ = false;
emit encryptionChanged();
return;
}
nhlog::net()->info("enabled encryption on room ({})", room_id);
});
usesEncryption_ = true;
emit encryptionChanged();
}
bool
RoomSettings::canChangeJoinRules() const
{
try {
return cache::hasEnoughPowerLevel({EventType::RoomJoinRules},
roomid_.toStdString(),
utils::localUser().toStdString());
} catch (const lmdb::error &e) {
nhlog::db()->warn("lmdb error: {}", e.what());
}
return false;
}
bool
RoomSettings::canChangeNameAndTopic() const
{
try {
return cache::hasEnoughPowerLevel({EventType::RoomName, EventType::RoomTopic},
roomid_.toStdString(),
utils::localUser().toStdString());
} catch (const lmdb::error &e) {
nhlog::db()->warn("lmdb error: {}", e.what());
}
return false;
}
bool
RoomSettings::canChangeAvatar() const
{
try {
return cache::hasEnoughPowerLevel(
{EventType::RoomAvatar}, roomid_.toStdString(), utils::localUser().toStdString());
} catch (const lmdb::error &e) {
nhlog::db()->warn("lmdb error: {}", e.what());
}
return false;
}
bool
RoomSettings::isEncryptionEnabled() const
{
return usesEncryption_;
}
void
RoomSettings::openEditModal()
{
retrieveRoomInfo();
auto modal = new EditModal(roomid_);
modal->setFields(QString::fromStdString(info_.name), QString::fromStdString(info_.topic));
modal->raise();
modal->show();
connect(modal, &EditModal::nameChanged, this, [this](const QString &newName) {
info_.name = newName.toStdString();
emit roomNameChanged();
});
connect(modal, &EditModal::topicChanged, this, [this](const QString &newTopic) {
info_.topic = newTopic.toStdString();
emit roomTopicChanged();
});
}
void
RoomSettings::changeNotifications(int currentIndex)
{
notifications_ = currentIndex;
std::string room_id = roomid_.toStdString();
if (notifications_ == 0) {
// mute room
// delete old rule first, then add new rule
mtx::pushrules::PushRule rule;
rule.actions = {mtx::pushrules::actions::dont_notify{}};
mtx::pushrules::PushCondition condition;
condition.kind = "event_match";
condition.key = "room_id";
condition.pattern = room_id;
rule.conditions = {condition};
http::client()->put_pushrules(
"global", "override", room_id, rule, [room_id](mtx::http::RequestErr &err) {
if (err)
nhlog::net()->error("failed to set pushrule for room {}: {} {}",
room_id,
static_cast<int>(err->status_code),
err->matrix_error.error);
http::client()->delete_pushrules(
"global", "room", room_id, [room_id](mtx::http::RequestErr &) {});
});
} else if (notifications_ == 1) {
// mentions only
// delete old rule first, then add new rule
mtx::pushrules::PushRule rule;
rule.actions = {mtx::pushrules::actions::dont_notify{}};
http::client()->put_pushrules(
"global", "room", room_id, rule, [room_id](mtx::http::RequestErr &err) {
if (err)
nhlog::net()->error("failed to set pushrule for room {}: {} {}",
room_id,
static_cast<int>(err->status_code),
err->matrix_error.error);
http::client()->delete_pushrules(
"global", "override", room_id, [room_id](mtx::http::RequestErr &) {});
});
} else {
// all messages
http::client()->delete_pushrules(
"global", "override", room_id, [room_id](mtx::http::RequestErr &) {
http::client()->delete_pushrules(
"global", "room", room_id, [room_id](mtx::http::RequestErr &) {});
});
}
}
void
RoomSettings::changeAccessRules(int index)
{
using namespace mtx::events::state;
auto guest_access = [](int index) -> state::GuestAccess {
state::GuestAccess event;
if (index == 0)
event.guest_access = state::AccessState::CanJoin;
else
event.guest_access = state::AccessState::Forbidden;
return event;
}(index);
auto join_rule = [](int index) -> state::JoinRules {
state::JoinRules event;
switch (index) {
case 0:
case 1:
event.join_rule = state::JoinRule::Public;
break;
default:
event.join_rule = state::JoinRule::Invite;
}
return event;
}(index);
updateAccessRules(roomid_.toStdString(), join_rule, guest_access);
}
void
RoomSettings::updateAccessRules(const std::string &room_id,
const mtx::events::state::JoinRules &join_rule,
const mtx::events::state::GuestAccess &guest_access)
{
isLoading_ = true;
emit loadingChanged();
http::client()->send_state_event(
room_id,
join_rule,
[this, room_id, guest_access](const mtx::responses::EventId &,
mtx::http::RequestErr err) {
if (err) {
nhlog::net()->warn("failed to send m.room.join_rule: {} {}",
static_cast<int>(err->status_code),
err->matrix_error.error);
emit displayError(QString::fromStdString(err->matrix_error.error));
isLoading_ = false;
emit loadingChanged();
return;
}
http::client()->send_state_event(
room_id,
guest_access,
[this](const mtx::responses::EventId &, mtx::http::RequestErr err) {
if (err) {
nhlog::net()->warn("failed to send m.room.guest_access: {} {}",
static_cast<int>(err->status_code),
err->matrix_error.error);
emit displayError(
QString::fromStdString(err->matrix_error.error));
}
isLoading_ = false;
emit loadingChanged();
});
});
}
void
RoomSettings::stopLoading()
{
isLoading_ = false;
emit loadingChanged();
}
void
RoomSettings::avatarChanged()
{
retrieveRoomInfo();
emit avatarUrlChanged();
}
void
RoomSettings::updateAvatar()
{
const QString picturesFolder =
QStandardPaths::writableLocation(QStandardPaths::PicturesLocation);
const QString fileName = QFileDialog::getOpenFileName(
nullptr, tr("Select an avatar"), picturesFolder, tr("All Files (*)"));
if (fileName.isEmpty())
return;
QMimeDatabase db;
QMimeType mime = db.mimeTypeForFile(fileName, QMimeDatabase::MatchContent);
const auto format = mime.name().split("/")[0];
QFile file{fileName, this};
if (format != "image") {
emit displayError(tr("The selected file is not an image"));
return;
}
if (!file.open(QIODevice::ReadOnly)) {
emit displayError(tr("Error while reading file: %1").arg(file.errorString()));
return;
}
isLoading_ = true;
emit loadingChanged();
// Events emitted from the http callbacks (different threads) will
// be queued back into the UI thread through this proxy object.
auto proxy = std::make_shared<ThreadProxy>();
connect(proxy.get(), &ThreadProxy::error, this, &RoomSettings::displayError);
connect(proxy.get(), &ThreadProxy::stopLoading, this, &RoomSettings::stopLoading);
const auto bin = file.peek(file.size());
const auto payload = std::string(bin.data(), bin.size());
const auto dimensions = QImageReader(&file).size();
// First we need to create a new mxc URI
// (i.e upload media to the Matrix content repository) for the new avatar.
http::client()->upload(
payload,
mime.name().toStdString(),
QFileInfo(fileName).fileName().toStdString(),
[proxy = std::move(proxy),
dimensions,
payload,
mimetype = mime.name().toStdString(),
size = payload.size(),
room_id = roomid_.toStdString(),
content = std::move(bin)](const mtx::responses::ContentURI &res,
mtx::http::RequestErr err) {
if (err) {
emit proxy->stopLoading();
emit proxy->error(
tr("Failed to upload image: %s")
.arg(QString::fromStdString(err->matrix_error.error)));
return;
}
using namespace mtx::events;
state::Avatar avatar_event;
avatar_event.image_info.w = dimensions.width();
avatar_event.image_info.h = dimensions.height();
avatar_event.image_info.mimetype = mimetype;
avatar_event.image_info.size = size;
avatar_event.url = res.content_uri;
http::client()->send_state_event(
room_id,
avatar_event,
[content = std::move(content), proxy = std::move(proxy)](
const mtx::responses::EventId &, mtx::http::RequestErr err) {
if (err) {
emit proxy->error(
tr("Failed to upload image: %s")
.arg(QString::fromStdString(err->matrix_error.error)));
return;
}
emit proxy->stopLoading();
});
});
}

135
src/ui/RoomSettings.h Normal file
View File

@ -0,0 +1,135 @@
#pragma once
#include <QLabel>
#include <QObject>
#include <QPushButton>
#include <QString>
#include <mtx/events/guest_access.hpp>
#include "CacheStructs.h"
class TextField;
/// Convenience class which connects events emmited from threads
/// outside of main with the UI code.
class ThreadProxy : public QObject
{
Q_OBJECT
signals:
void error(const QString &msg);
void nameEventSent(const QString &);
void topicEventSent(const QString &);
void stopLoading();
};
class EditModal : public QWidget
{
Q_OBJECT
public:
EditModal(const QString &roomId, QWidget *parent = nullptr);
void setFields(const QString &roomName, const QString &roomTopic);
signals:
void nameChanged(const QString &roomName);
void topicChanged(const QString &topic);
private slots:
void topicEventSent(const QString &topic);
void nameEventSent(const QString &name);
void error(const QString &msg);
void applyClicked();
private:
QString roomId_;
QString initialName_;
QString initialTopic_;
QLabel *errorField_;
TextField *nameInput_;
TextField *topicInput_;
QPushButton *applyBtn_;
QPushButton *cancelBtn_;
};
class RoomSettings : public QObject
{
Q_OBJECT
Q_PROPERTY(QString roomId READ roomId CONSTANT)
Q_PROPERTY(QString roomVersion READ roomVersion CONSTANT)
Q_PROPERTY(QString roomName READ roomName NOTIFY roomNameChanged)
Q_PROPERTY(QString roomTopic READ roomTopic NOTIFY roomTopicChanged)
Q_PROPERTY(QString roomAvatarUrl READ roomAvatarUrl NOTIFY avatarUrlChanged)
Q_PROPERTY(int memberCount READ memberCount CONSTANT)
Q_PROPERTY(int notifications READ notifications NOTIFY notificationsChanged)
Q_PROPERTY(int accessJoinRules READ accessJoinRules NOTIFY accessJoinRulesChanged)
Q_PROPERTY(bool isLoading READ isLoading NOTIFY loadingChanged)
Q_PROPERTY(bool canChangeAvatar READ canChangeAvatar CONSTANT)
Q_PROPERTY(bool canChangeJoinRules READ canChangeJoinRules CONSTANT)
Q_PROPERTY(bool canChangeNameAndTopic READ canChangeNameAndTopic CONSTANT)
Q_PROPERTY(bool isEncryptionEnabled READ isEncryptionEnabled NOTIFY encryptionChanged)
Q_PROPERTY(bool respondsToKeyRequests READ respondsToKeyRequests NOTIFY keyRequestsChanged)
public:
RoomSettings(QString roomid, QObject *parent = nullptr);
QString roomId() const;
QString roomName() const;
QString roomTopic() const;
QString roomVersion() const;
QString roomAvatarUrl();
int memberCount() const;
int notifications();
int accessJoinRules();
bool respondsToKeyRequests();
bool isLoading() const;
//! Whether the user has enough power level to send m.room.join_rules events.
bool canChangeJoinRules() const;
//! Whether the user has enough power level to send m.room.name & m.room.topic events.
bool canChangeNameAndTopic() const;
//! Whether the user has enough power level to send m.room.avatar event.
bool canChangeAvatar() const;
bool isEncryptionEnabled() const;
Q_INVOKABLE void enableEncryption();
Q_INVOKABLE void updateAvatar();
Q_INVOKABLE void openEditModal();
Q_INVOKABLE void changeAccessRules(int index);
Q_INVOKABLE void changeNotifications(int currentIndex);
Q_INVOKABLE void changeKeyRequestsPreference(bool isOn);
signals:
void loadingChanged();
void roomNameChanged();
void roomTopicChanged();
void avatarUrlChanged();
void encryptionChanged();
void keyRequestsChanged();
void notificationsChanged();
void accessJoinRulesChanged();
void displayError(const QString &errorMessage);
public slots:
void stopLoading();
void avatarChanged();
private:
void retrieveRoomInfo();
void updateAccessRules(const std::string &room_id,
const mtx::events::state::JoinRules &,
const mtx::events::state::GuestAccess &);
private:
QString roomid_;
bool usesEncryption_ = false;
bool isLoading_ = false;
RoomInfo info_;
int notifications_ = 0;
int accessRules_ = 0;
};