diff --git a/Telegram/Resources/langs/lang.strings b/Telegram/Resources/langs/lang.strings index 13c63fd49..138f26554 100644 --- a/Telegram/Resources/langs/lang.strings +++ b/Telegram/Resources/langs/lang.strings @@ -403,6 +403,8 @@ Copyright (c) 2014-2017 John Preston, https://desktop.telegram.org "lng_connection_user_ph" = "Username"; "lng_connection_password_ph" = "Password"; "lng_connection_save" = "Save"; + +"lng_settings_blocked_users" = "Blocked users"; "lng_settings_show_sessions" = "Show all sessions"; "lng_settings_reset" = "Terminate all other sessions"; "lng_settings_reset_sure" = "Are you sure you want to terminate\nall other sessions?"; @@ -428,6 +430,12 @@ Copyright (c) 2014-2017 John Preston, https://desktop.telegram.org "lng_sessions_other_desc" = "You can log in to Telegram from other mobile, tablet and desktop devices, using the same phone number. All your data will be instantly synchronized."; "lng_sessions_terminate_all" = "Terminate all other sessions"; +"lng_blocked_list_title" = "Blocked users"; +"lng_blocked_list_unknown_phone" = "unknown phone"; +"lng_blocked_list_unblock" = "Unblock"; +"lng_blocked_list_add" = "Block user"; +"lng_blocked_list_about" = "Blocked users can't send you messages or add you to groups. They will not see your profile pictures, online and last seen status."; + "lng_preview_loading" = "Getting Link Info..."; "lng_profile_chat_unaccessible" = "Group is inaccessible"; diff --git a/Telegram/SourceFiles/boxes/abstractbox.h b/Telegram/SourceFiles/boxes/abstractbox.h index 19aa65218..0ef58121d 100644 --- a/Telegram/SourceFiles/boxes/abstractbox.h +++ b/Telegram/SourceFiles/boxes/abstractbox.h @@ -62,17 +62,6 @@ public: setAttribute(Qt::WA_OpaquePaintEvent); } - void setDelegate(BoxContentDelegate *newDelegate) { - _delegate = newDelegate; - prepare(); - setInnerFocus(); - } - virtual void setInnerFocus() { - setFocus(); - } - virtual void closeHook() { - } - bool isBoxShown() const { return getDelegate()->isBoxShown(); } @@ -80,17 +69,6 @@ public: getDelegate()->closeBox(); } -public slots: - void onScrollToY(int top, int bottom = -1); - - void onDraggingScrollDelta(int delta); - -protected: - virtual void prepare() = 0; - - void setLayerType(bool layerType) { - getDelegate()->setLayerType(layerType); - } void setTitle(const QString &title, const QString &additional = QString()) { getDelegate()->setTitle(title, additional); } @@ -107,6 +85,30 @@ protected: getDelegate()->updateButtonsPositions(); } + virtual void setInnerFocus() { + setFocus(); + } + virtual void closeHook() { + } + + void setDelegate(BoxContentDelegate *newDelegate) { + _delegate = newDelegate; + prepare(); + setInnerFocus(); + } + +public slots: + void onScrollToY(int top, int bottom = -1); + + void onDraggingScrollDelta(int delta); + +protected: + virtual void prepare() = 0; + + void setLayerType(bool layerType) { + getDelegate()->setLayerType(layerType); + } + void setNoContentMargin(bool noContentMargin) { if (_noContentMargin != noContentMargin) { _noContentMargin = noContentMargin; diff --git a/Telegram/SourceFiles/boxes/members_box.cpp b/Telegram/SourceFiles/boxes/members_box.cpp index 444299864..f1bf3612f 100644 --- a/Telegram/SourceFiles/boxes/members_box.cpp +++ b/Telegram/SourceFiles/boxes/members_box.cpp @@ -34,31 +34,33 @@ Copyright (c) 2014-2017 John Preston, https://desktop.telegram.org #include "auth_session.h" #include "storage/file_download.h" -MembersAddButton::MembersAddButton(QWidget *parent, const style::TwoIconButton &st) : RippleButton(parent, st.ripple) -, _st(st) { - resize(_st.width, _st.height); - setCursor(style::cur_pointer); -} - -void MembersAddButton::paintEvent(QPaintEvent *e) { - Painter p(this); - - auto ms = getms(); - auto over = isOver(); - auto down = isDown(); - - ((over || down) ? _st.iconBelowOver : _st.iconBelow).paint(p, _st.iconPosition, width()); - paintRipple(p, _st.rippleAreaPosition.x(), _st.rippleAreaPosition.y(), ms); - ((over || down) ? _st.iconAboveOver : _st.iconAbove).paint(p, _st.iconPosition, width()); -} - -QImage MembersAddButton::prepareRippleMask() const { - return Ui::RippleAnimation::ellipseMask(QSize(_st.rippleAreaSize, _st.rippleAreaSize)); -} - -QPoint MembersAddButton::prepareRippleStartPosition() const { - return mapFromGlobal(QCursor::pos()) - _st.rippleAreaPosition; -} +// Not used for now. +// +//MembersAddButton::MembersAddButton(QWidget *parent, const style::TwoIconButton &st) : RippleButton(parent, st.ripple) +//, _st(st) { +// resize(_st.width, _st.height); +// setCursor(style::cur_pointer); +//} +// +//void MembersAddButton::paintEvent(QPaintEvent *e) { +// Painter p(this); +// +// auto ms = getms(); +// auto over = isOver(); +// auto down = isDown(); +// +// ((over || down) ? _st.iconBelowOver : _st.iconBelow).paint(p, _st.iconPosition, width()); +// paintRipple(p, _st.rippleAreaPosition.x(), _st.rippleAreaPosition.y(), ms); +// ((over || down) ? _st.iconAboveOver : _st.iconAbove).paint(p, _st.iconPosition, width()); +//} +// +//QImage MembersAddButton::prepareRippleMask() const { +// return Ui::RippleAnimation::ellipseMask(QSize(_st.rippleAreaSize, _st.rippleAreaSize)); +//} +// +//QPoint MembersAddButton::prepareRippleStartPosition() const { +// return mapFromGlobal(QCursor::pos()) - _st.rippleAreaPosition; +//} MembersBox::MembersBox(QWidget*, ChannelData *channel, MembersFilter filter) : _channel(channel) diff --git a/Telegram/SourceFiles/boxes/members_box.h b/Telegram/SourceFiles/boxes/members_box.h index 0033a61bf..01204757c 100644 --- a/Telegram/SourceFiles/boxes/members_box.h +++ b/Telegram/SourceFiles/boxes/members_box.h @@ -34,20 +34,22 @@ enum class MembersFilter { }; using MembersAlreadyIn = OrderedSet; -class MembersAddButton : public Ui::RippleButton { -public: - MembersAddButton(QWidget *parent, const style::TwoIconButton &st); - -protected: - void paintEvent(QPaintEvent *e) override; - - QImage prepareRippleMask() const override; - QPoint prepareRippleStartPosition() const override; - -private: - const style::TwoIconButton &_st; - -}; +// Not used for now. +// +//class MembersAddButton : public Ui::RippleButton { +//public: +// MembersAddButton(QWidget *parent, const style::TwoIconButton &st); +// +//protected: +// void paintEvent(QPaintEvent *e) override; +// +// QImage prepareRippleMask() const override; +// QPoint prepareRippleStartPosition() const override; +// +//private: +// const style::TwoIconButton &_st; +// +//}; class MembersBox : public BoxContent { Q_OBJECT diff --git a/Telegram/SourceFiles/boxes/peer_list_box.cpp b/Telegram/SourceFiles/boxes/peer_list_box.cpp new file mode 100644 index 000000000..6301e30b6 --- /dev/null +++ b/Telegram/SourceFiles/boxes/peer_list_box.cpp @@ -0,0 +1,518 @@ +/* +This file is part of Telegram Desktop, +the official desktop version of Telegram messaging app, see https://telegram.org + +Telegram Desktop 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. + +It 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. + +In addition, as a special exception, the copyright holders give permission +to link the code of portions of this program with the OpenSSL library. + +Full license: https://github.com/telegramdesktop/tdesktop/blob/master/LICENSE +Copyright (c) 2014-2017 John Preston, https://desktop.telegram.org +*/ +#include "boxes/peer_list_box.h" + +#include "styles/style_boxes.h" +#include "styles/style_dialogs.h" +#include "ui/widgets/scroll_area.h" +#include "ui/effects/ripple_animation.h" +#include "observer_peer.h" +#include "auth_session.h" +#include "mainwidget.h" +#include "storage/file_download.h" + +PeerListBox::PeerListBox(QWidget*, std::unique_ptr controller) +: _controller(std::move(controller)) { +} + +void PeerListBox::prepare() { + _inner = setInnerWidget(object_ptr(this, _controller.get()), st::boxLayerScroll); + + _controller->setView(this); + + setDimensions(st::boxWideWidth, st::boxMaxListHeight); + + connect(_inner, SIGNAL(mustScrollTo(int, int)), this, SLOT(onScrollToY(int, int))); +} + +void PeerListBox::keyPressEvent(QKeyEvent *e) { + if (e->key() == Qt::Key_Down) { + _inner->selectSkip(1); + } else if (e->key() == Qt::Key_Up) { + _inner->selectSkip(-1); + } else if (e->key() == Qt::Key_PageDown) { + _inner->selectSkipPage(height(), 1); + } else if (e->key() == Qt::Key_PageUp) { + _inner->selectSkipPage(height(), -1); + } else { + BoxContent::keyPressEvent(e); + } +} + +void PeerListBox::resizeEvent(QResizeEvent *e) { + BoxContent::resizeEvent(e); + + _inner->resize(width(), _inner->height()); +} + +void PeerListBox::appendRow(std::unique_ptr row) { + _inner->appendRow(std::move(row)); +} + +void PeerListBox::prependRow(std::unique_ptr row) { + _inner->prependRow(std::move(row)); +} + +PeerListBox::Row *PeerListBox::findRow(PeerData *peer) { + return _inner->findRow(peer); +} + +void PeerListBox::updateRow(Row *row) { + _inner->updateRow(row); +} + +void PeerListBox::removeRow(Row *row) { + _inner->removeRow(row); +} + +void PeerListBox::setAboutText(const QString &aboutText) { + _inner->setAboutText(aboutText); +} + +void PeerListBox::refreshRows() { + _inner->refreshRows(); +} + +PeerListBox::Row::Row(PeerData *peer) : _peer(peer) { +} + +void PeerListBox::Row::setDisabled(bool disabled) { + _disabled = disabled; +} + +void PeerListBox::Row::setActionLink(const QString &action) { + _action = action; + refreshActionLink(); +} + +void PeerListBox::Row::refreshActionLink() { + if (!_initialized) return; + _actionWidth = _action.isEmpty() ? 0 : st::normalFont->width(_action); +} + +void PeerListBox::Row::setCustomStatus(const QString &status) { + _status = status; + _statusType = StatusType::Custom; +} + +void PeerListBox::Row::clearCustomStatus() { + _statusType = StatusType::Online; + refreshStatus(); +} + +void PeerListBox::Row::refreshStatus() { + if (!_initialized || _statusType == StatusType::Custom) { + return; + } + if (auto user = peer()->asUser()) { + auto time = unixtime(); + _status = App::onlineText(user, time); + _statusType = App::onlineColorUse(user, time) ? StatusType::Online : StatusType::LastSeen; + } +} + +PeerListBox::Row::StatusType PeerListBox::Row::statusType() const { + return _statusType; +} + +void PeerListBox::Row::refreshName() { + if (!_initialized) { + return; + } + _name.setText(st::contactsNameStyle, peer()->name, _textNameOptions); +} + +QString PeerListBox::Row::status() const { + return _status; +} + +QString PeerListBox::Row::action() const { + return _action; +} + +int PeerListBox::Row::actionWidth() const { + return _actionWidth; +} + +PeerListBox::Row::~Row() = default; + +template +void PeerListBox::Row::addRipple(QSize size, QPoint point, UpdateCallback updateCallback) { + if (!_ripple) { + auto mask = Ui::RippleAnimation::rectMask(size); + _ripple = std::make_unique(st::contactsRipple, std::move(mask), std::move(updateCallback)); + } + _ripple->add(point); +} + +void PeerListBox::Row::stopLastRipple() { + if (_ripple) { + _ripple->lastStop(); + } +} + +void PeerListBox::Row::paintRipple(Painter &p, int x, int y, int outerWidth, TimeMs ms) { + if (_ripple) { + _ripple->paint(p, x, y, outerWidth, ms); + if (_ripple->empty()) { + _ripple.reset(); + } + } +} + +void PeerListBox::Row::lazyInitialize() { + if (_initialized) { + return; + } + _initialized = true; + refreshActionLink(); + refreshName(); + refreshStatus(); +} + +PeerListBox::Inner::Inner(QWidget *parent, Controller *controller) : TWidget(parent) +, _controller(controller) +, _rowHeight(st::contactsPadding.top() + st::contactsPhotoSize + st::contactsPadding.bottom()) +, _aboutWidth(st::boxWideWidth - st::contactsPadding.left() - st::contactsPadding.right()) +, _about(_aboutWidth) { + subscribe(AuthSession::CurrentDownloaderTaskFinished(), [this] { update(); }); + + connect(App::main(), SIGNAL(peerNameChanged(PeerData*, const PeerData::Names&, const PeerData::NameFirstChars&)), this, SLOT(onPeerNameChanged(PeerData*, const PeerData::Names&, const PeerData::NameFirstChars&))); + connect(App::main(), SIGNAL(peerPhotoChanged(PeerData*)), this, SLOT(peerUpdated(PeerData*))); +} + +void PeerListBox::Inner::appendRow(std::unique_ptr row) { + if (!_rowsByPeer.contains(row->peer())) { + row->setIndex(_rows.size()); + _rowsByPeer.insert(row->peer(), row.get()); + _rows.push_back(std::move(row)); + } +} + +void PeerListBox::Inner::prependRow(std::unique_ptr row) { + if (!_rowsByPeer.contains(row->peer())) { + _rowsByPeer.insert(row->peer(), row.get()); + _rows.insert(_rows.begin(), std::move(row)); + auto index = 0; + for (auto &row : _rows) { + row->setIndex(index++); + } + } +} + +PeerListBox::Row *PeerListBox::Inner::findRow(PeerData *peer) { + return _rowsByPeer.value(peer, nullptr); +} + +void PeerListBox::Inner::updateRow(Row *row) { + updateRowWithIndex(row->index()); +} + +void PeerListBox::Inner::removeRow(Row *row) { + auto index = row->index(); + t_assert(index >= 0 && index < _rows.size()); + t_assert(_rows[index].get() == row); + + clearSelection(); + + _rowsByPeer.remove(row->peer()); + _rows.erase(_rows.begin() + index); + for (auto i = index, count = int(_rows.size()); i != count; ++i) { + _rows[i]->setIndex(i); + } +} + +void PeerListBox::Inner::setAboutText(const QString &aboutText) { + _about.setText(st::boxLabelStyle, aboutText); +} + +void PeerListBox::Inner::refreshRows() { + if (!_about.isEmpty()) { + _aboutHeight = st::membersAboutLimitPadding.top() + _about.countHeight(_aboutWidth) + st::membersAboutLimitPadding.bottom(); + } else { + _aboutHeight = 0; + } + if (_rows.empty()) { + resize(width(), st::membersMarginTop + _rowHeight + _aboutHeight + st::membersMarginBottom); + } else { + resize(width(), st::membersMarginTop + _rows.size() * _rowHeight + _aboutHeight + st::membersMarginBottom); + } + if (_visibleBottom > 0) { + checkScrollForPreload(); + } + update(); +} + +void PeerListBox::Inner::paintEvent(QPaintEvent *e) { + QRect r(e->rect()); + Painter p(this); + + p.fillRect(r, st::contactsBg); + + auto ms = getms(); + auto yFrom = r.y() - st::membersMarginTop; + auto yTo = r.y() + r.height() - st::membersMarginTop; + p.translate(0, st::membersMarginTop); + if (_rows.empty()) { + if (!_about.isEmpty()) { + p.setPen(st::membersAboutLimitFg); + _about.draw(p, st::contactsPadding.left(), _rowHeight + st::membersAboutLimitPadding.top(), _aboutWidth, style::al_center); + } + } else { + auto from = floorclamp(yFrom, _rowHeight, 0, _rows.size()); + auto to = ceilclamp(yTo, _rowHeight, 0, _rows.size()); + p.translate(0, from * _rowHeight); + for (auto index = from; index != to; ++index) { + paintRow(p, ms, index); + p.translate(0, _rowHeight); + } + if (!_about.isEmpty() && to == _rows.size()) { + p.setPen(st::membersAboutLimitFg); + _about.draw(p, st::contactsPadding.left(), st::membersAboutLimitPadding.top(), _aboutWidth, style::al_center); + } + } +} + +void PeerListBox::Inner::enterEventHook(QEvent *e) { + setMouseTracking(true); +} + +void PeerListBox::Inner::leaveEventHook(QEvent *e) { + _mouseSelection = false; + setMouseTracking(false); + if (_selected.index >= 0) { + clearSelection(); + } +} + +void PeerListBox::Inner::mouseMoveEvent(QMouseEvent *e) { + _mouseSelection = true; + _lastMousePosition = e->globalPos(); + updateSelection(); +} + +void PeerListBox::Inner::mousePressEvent(QMouseEvent *e) { + _mouseSelection = true; + _lastMousePosition = e->globalPos(); + updateSelection(); + setPressed(_selected); + if (_selected.index >= 0 && _selected.index < _rows.size() && !_selected.action) { + auto size = QSize(width(), _rowHeight); + auto point = mapFromGlobal(QCursor::pos()) - QPoint(0, getRowTop(_selected.index)); + auto row = _rows[_selected.index].get(); + row->addRipple(size, point, [this, row] { + updateRow(row); + }); + } +} + +void PeerListBox::Inner::mouseReleaseEvent(QMouseEvent *e) { + updateRowWithIndex(_pressed.index); + updateRowWithIndex(_selected.index); + auto pressed = _pressed; + setPressed(SelectedRow()); + if (e->button() == Qt::LeftButton) { + if (pressed == _selected && pressed.index >= 0) { + if (pressed.action) { + _controller->rowActionClicked(_rows[pressed.index]->peer()); + } else { + _controller->rowClicked(_rows[pressed.index]->peer()); + } + } + } +} + +void PeerListBox::Inner::setPressed(SelectedRow pressed) { + if (_pressed.index >= 0 && _pressed.index < _rows.size()) { + _rows[_pressed.index]->stopLastRipple(); + } + _pressed = pressed; +} + +void PeerListBox::Inner::paintRow(Painter &p, TimeMs ms, int index) { + t_assert(index >= 0 && index < _rows.size()); + auto row = _rows[index].get(); + row->lazyInitialize(); + + auto peer = row->peer(); + auto user = peer->asUser(); + auto active = (_pressed.index >= 0) ? _pressed : _selected; + auto selected = (active.index == index); + auto actionSelected = (selected && active.action); + + p.fillRect(0, 0, width(), _rowHeight, selected ? st::contactsBgOver : st::contactsBg); + row->paintRipple(p, 0, 0, width(), ms); + peer->paintUserpicLeft(p, st::contactsPadding.left(), st::contactsPadding.top(), width(), st::contactsPhotoSize); + + p.setPen(st::contactsNameFg); + + auto actionWidth = row->actionWidth(); + auto &name = row->name(); + auto namex = st::contactsPadding.left() + st::contactsPhotoSize + st::contactsPadding.left(); + auto namew = width() - namex - st::contactsPadding.right() - (actionWidth ? (actionWidth + st::contactsCheckPosition.x() * 2) : 0); + if (peer->isVerified()) { + auto icon = &st::dialogsVerifiedIcon; + namew -= icon->width(); + icon->paint(p, namex + qMin(name.maxWidth(), namew), st::contactsPadding.top() + st::contactsNameTop, width()); + } + name.drawLeftElided(p, namex, st::contactsPadding.top() + st::contactsNameTop, namew, width()); + + if (actionWidth) { + p.setFont(actionSelected ? st::linkOverFont : st::linkFont); + p.setPen(actionSelected ? st::defaultLinkButton.overColor : st::defaultLinkButton.color); + auto actionRight = st::contactsPadding.right() + st::contactsCheckPosition.x(); + auto actionTop = (_rowHeight - st::normalFont->height) / 2; + p.drawTextRight(actionRight, actionTop, width(), row->action(), actionWidth); + } + + auto statusHasOnlineColor = (row->statusType() == Row::StatusType::Online); + p.setFont(st::contactsStatusFont); + p.setPen(statusHasOnlineColor ? st::contactsStatusFgOnline : (selected ? st::contactsStatusFgOver : st::contactsStatusFg)); + p.drawTextLeft(namex, st::contactsPadding.top() + st::contactsStatusTop, width(), row->status()); +} + +void PeerListBox::Inner::selectSkip(int32 dir) { + _mouseSelection = false; + + auto newSelectedIndex = _selected.index + dir; + if (newSelectedIndex <= 0) { + newSelectedIndex = _rows.empty() ? -1 : 0; + } else if (newSelectedIndex >= _rows.size()) { + newSelectedIndex = -1; + } + if (dir > 0) { + if (newSelectedIndex < 0 || newSelectedIndex >= _rows.size()) { + newSelectedIndex = -1; + } + } else if (!_rows.empty()) { + if (newSelectedIndex < 0) { + newSelectedIndex = _rows.size() - 1; + } + } + _selected.index = newSelectedIndex; + _selected.action = false; + if (newSelectedIndex >= 0) { + emit mustScrollTo(st::membersMarginTop + newSelectedIndex * _rowHeight, st::membersMarginTop + (newSelectedIndex + 1) * _rowHeight); + } + + update(); +} + +void PeerListBox::Inner::selectSkipPage(int32 h, int32 dir) { + auto rowsToSkip = h / _rowHeight; + if (!rowsToSkip) return; + selectSkip(rowsToSkip * dir); +} + +void PeerListBox::Inner::loadProfilePhotos() { + if (_visibleTop >= _visibleBottom) return; + + auto yFrom = _visibleTop; + auto yTo = _visibleBottom + (_visibleBottom - _visibleTop) * PreloadHeightsCount; + AuthSession::Current().downloader()->clearPriorities(); + + if (yTo < 0) return; + if (yFrom < 0) yFrom = 0; + + if (!_rows.empty()) { + auto from = yFrom / _rowHeight; + if (from < 0) from = 0; + if (from < _rows.size()) { + auto to = (yTo / _rowHeight) + 1; + if (to > _rows.size()) to = _rows.size(); + + for (auto index = from; index != to; ++index) { + _rows[index]->peer()->loadUserpic(); + } + } + } +} + +void PeerListBox::Inner::checkScrollForPreload() { + if (_visibleBottom + PreloadHeightsCount * (_visibleBottom - _visibleTop) > height()) { + _controller->preloadRows(); + } +} + +void PeerListBox::Inner::setVisibleTopBottom(int visibleTop, int visibleBottom) { + _visibleTop = visibleTop; + _visibleBottom = visibleBottom; + loadProfilePhotos(); + checkScrollForPreload(); +} + +void PeerListBox::Inner::clearSelection() { + updateRowWithIndex(_selected.index); + _selected = SelectedRow(); + _lastMousePosition = QCursor::pos(); + updateSelection(); +} + +void PeerListBox::Inner::updateSelection() { + if (!_mouseSelection) return; + + auto point = mapFromGlobal(_lastMousePosition); + point.setY(point.y() - st::membersMarginTop); + auto in = parentWidget()->rect().contains(parentWidget()->mapFromGlobal(_lastMousePosition)); + auto selected = SelectedRow(); + selected.index = (in && point.y() >= 0 && point.y() < _rows.size() * _rowHeight) ? (point.y() / _rowHeight) : -1; + if (selected.index >= 0) { + auto actionRight = st::contactsPadding.right() + st::contactsCheckPosition.x(); + auto actionTop = (_rowHeight - st::normalFont->height) / 2; + auto actionWidth = _rows[selected.index]->actionWidth(); + auto actionLeft = width() - actionWidth - actionRight; + auto rowTop = selected.index * _rowHeight; + auto actionRect = myrtlrect(actionLeft, rowTop + actionTop, actionWidth, st::normalFont->height); + if (actionRect.contains(point)) { + selected.action = true; + } + } + if (_selected != selected) { + updateRowWithIndex(_selected.index); + _selected = selected; + updateRowWithIndex(_selected.index); + setCursor(_selected.action ? style::cur_pointer : style::cur_default); + } +} + +void PeerListBox::Inner::peerUpdated(PeerData *peer) { + update(); +} + +int PeerListBox::Inner::getRowTop(int index) const { + if (index >= 0) { + return st::membersMarginTop + index * _rowHeight; + } + return -1; +} + +void PeerListBox::Inner::updateRowWithIndex(int index) { + if (index >= 0) { + update(0, getRowTop(index), width(), _rowHeight); + } +} + +void PeerListBox::Inner::onPeerNameChanged(PeerData *peer, const PeerData::Names &oldNames, const PeerData::NameFirstChars &oldChars) { + if (auto row = findRow(peer)) { + row->refreshName(); + update(0, st::membersMarginTop + row->index() * _rowHeight, width(), _rowHeight); + } +} diff --git a/Telegram/SourceFiles/boxes/peer_list_box.h b/Telegram/SourceFiles/boxes/peer_list_box.h new file mode 100644 index 000000000..d3420ef96 --- /dev/null +++ b/Telegram/SourceFiles/boxes/peer_list_box.h @@ -0,0 +1,232 @@ +/* +This file is part of Telegram Desktop, +the official desktop version of Telegram messaging app, see https://telegram.org + +Telegram Desktop 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. + +It 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. + +In addition, as a special exception, the copyright holders give permission +to link the code of portions of this program with the OpenSSL library. + +Full license: https://github.com/telegramdesktop/tdesktop/blob/master/LICENSE +Copyright (c) 2014-2017 John Preston, https://desktop.telegram.org +*/ +#pragma once + +#include "boxes/abstractbox.h" + +namespace Ui { +class RippleAnimation; +} // namespace Ui + +class PeerListBox : public BoxContent { + Q_OBJECT + + class Inner; + +public: + class Row { + public: + Row(PeerData *peer); + + void setDisabled(bool disabled); + + void setActionLink(const QString &action); + PeerData *peer() const { + return _peer; + } + + void setCustomStatus(const QString &status); + void clearCustomStatus(); + + virtual ~Row(); + + private: + // Inner interface. + friend class Inner; + + void refreshName(); + const Text &name() const { + return _name; + } + + enum class StatusType { + Online, + LastSeen, + Custom, + }; + void refreshStatus(); + StatusType statusType() const; + QString status() const; + + void refreshActionLink(); + QString action() const; + int actionWidth() const; + + void setIndex(int index) { + _index = index; + } + int index() const { + return _index; + } + + template + void addRipple(QSize size, QPoint point, UpdateCallback updateCallback); + void stopLastRipple(); + void paintRipple(Painter &p, int x, int y, int outerWidth, TimeMs ms); + + void lazyInitialize(); + + private: + PeerData *_peer = nullptr; + bool _initialized = false; + std::unique_ptr _ripple; + Text _name; + QString _status; + StatusType _statusType = StatusType::Online; + QString _action; + int _actionWidth = 0; + bool _disabled = false; + int _index = -1; + + }; + + class Controller { + public: + virtual void prepare() = 0; + virtual void rowClicked(PeerData *peer) = 0; + virtual void rowActionClicked(PeerData *peer) { + } + virtual void preloadRows() { + } + + virtual ~Controller() = default; + + protected: + PeerListBox *view() const { + return _view; + } + + private: + void setView(PeerListBox *box) { + _view = box; + prepare(); + } + + PeerListBox *_view = nullptr; + + friend class PeerListBox; + + }; + PeerListBox(QWidget*, std::unique_ptr controller); + + // Interface for the controller. + void appendRow(std::unique_ptr row); + void prependRow(std::unique_ptr row); + Row *findRow(PeerData *peer); + void updateRow(Row *row); + void removeRow(Row *row); + void setAboutText(const QString &aboutText); + void refreshRows(); + +protected: + void prepare() override; + + void keyPressEvent(QKeyEvent *e) override; + void resizeEvent(QResizeEvent *e) override; + +private: + class Inner; + QPointer _inner; + + std::unique_ptr _controller; + +}; + +// This class is hold in header because it requires Qt preprocessing. +class PeerListBox::Inner : public TWidget, public RPCSender, private base::Subscriber { + Q_OBJECT + +public: + Inner(QWidget *parent, Controller *controller); + + void selectSkip(int32 dir); + void selectSkipPage(int32 h, int32 dir); + + void clearSelection(); + + void setVisibleTopBottom(int visibleTop, int visibleBottom) override; + + // Interface for the controller. + void appendRow(std::unique_ptr row); + void prependRow(std::unique_ptr row); + Row *findRow(PeerData *peer); + void updateRow(Row *row); + void removeRow(Row *row); + void setAboutText(const QString &aboutText); + void refreshRows(); + +signals: + void mustScrollTo(int ymin, int ymax); + +public slots: + void peerUpdated(PeerData *peer); + void onPeerNameChanged(PeerData *peer, const PeerData::Names &oldNames, const PeerData::NameFirstChars &oldChars); + +protected: + void paintEvent(QPaintEvent *e) override; + void enterEventHook(QEvent *e) override; + void leaveEventHook(QEvent *e) override; + void mouseMoveEvent(QMouseEvent *e) override; + void mousePressEvent(QMouseEvent *e) override; + void mouseReleaseEvent(QMouseEvent *e) override; + +private: + struct SelectedRow { + int index = -1; + bool action = false; + }; + friend inline bool operator==(SelectedRow a, SelectedRow b) { + return (a.index == b.index) && (a.action == b.action); + } + friend inline bool operator!=(SelectedRow a, SelectedRow b) { + return !(a == b); + } + + void setPressed(SelectedRow pressed); + + void updateSelection(); + void loadProfilePhotos(); + void checkScrollForPreload(); + + void updateRowWithIndex(int index); + int getRowTop(int index) const; + + void paintRow(Painter &p, TimeMs ms, int index); + + Controller *_controller = nullptr; + int _rowHeight = 0; + int _visibleTop = 0; + int _visibleBottom = 0; + + SelectedRow _selected; + SelectedRow _pressed; + bool _mouseSelection = false; + + std::vector> _rows; + QMap _rowsByPeer; + + int _aboutWidth = 0; + int _aboutHeight = 0; + Text _about; + + QPoint _lastMousePosition; + +}; diff --git a/Telegram/SourceFiles/mtproto/core_types.h b/Telegram/SourceFiles/mtproto/core_types.h index 7ccb25c91..26bfc89e2 100644 --- a/Telegram/SourceFiles/mtproto/core_types.h +++ b/Telegram/SourceFiles/mtproto/core_types.h @@ -185,18 +185,18 @@ public: TypeData &operator=(const TypeData &other) = delete; TypeData &operator=(TypeData &&other) = delete; - void incrementCounter() const { - _counter.ref(); - } - - bool decrementCounter() const { - return _counter.deref(); - } - virtual ~TypeData() { } private: + void incrementCounter() const { + _counter.ref(); + } + bool decrementCounter() const { + return _counter.deref(); + } + friend class TypeDataOwner; + mutable QAtomicInt _counter = { 1 }; }; diff --git a/Telegram/SourceFiles/settings/settings_blocked_box_controller.cpp b/Telegram/SourceFiles/settings/settings_blocked_box_controller.cpp new file mode 100644 index 000000000..60fbbe3d9 --- /dev/null +++ b/Telegram/SourceFiles/settings/settings_blocked_box_controller.cpp @@ -0,0 +1,158 @@ +/* +This file is part of Telegram Desktop, +the official desktop version of Telegram messaging app, see https://telegram.org + +Telegram Desktop 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. + +It 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. + +In addition, as a special exception, the copyright holders give permission +to link the code of portions of this program with the OpenSSL library. + +Full license: https://github.com/telegramdesktop/tdesktop/blob/master/LICENSE +Copyright (c) 2014-2017 John Preston, https://desktop.telegram.org +*/ +#include "settings/settings_blocked_box_controller.h" + +#include "lang.h" +#include "apiwrap.h" +#include "observer_peer.h" + +namespace Settings { +namespace { + +constexpr auto kPerPage = 40; + +} // namespace + +void BlockedBoxController::prepare() { + view()->setTitle(lang(lng_blocked_list_title)); + view()->addButton(lang(lng_close), [this] { view()->closeBox(); }); + view()->setAboutText(lang(lng_contacts_loading)); + view()->refreshRows(); + + subscribe(Notify::PeerUpdated(), Notify::PeerUpdatedHandler(Notify::PeerUpdate::Flag::UserIsBlocked, [this](const Notify::PeerUpdate &update) { + if (!update.peer->isUser()) { + return; + } + handleBlockedEvent(update.peer->asUser()); + })); + + preloadRows(); +} + +void BlockedBoxController::preloadRows() { + if (_loadRequestId || _allLoaded) { + return; + } + + _loadRequestId = MTP::send(MTPcontacts_GetBlocked(MTP_int(_offset), MTP_int(kPerPage)), rpcDone(base::lambda_guarded(this, [this](const MTPcontacts_Blocked &result) { + _loadRequestId = 0; + + if (!_offset) { + view()->setAboutText(lang(lng_blocked_list_about)); + } + + auto handleContactsBlocked = [](auto &list) { + App::feedUsers(list.vusers); + return list.vblocked.v; + }; + switch (result.type()) { + case mtpc_contacts_blockedSlice: { + receivedUsers(handleContactsBlocked(result.c_contacts_blockedSlice())); + } break; + case mtpc_contacts_blocked: { + _allLoaded = true; + receivedUsers(handleContactsBlocked(result.c_contacts_blocked())); + } break; + default: t_assert(!"Bad type() in MTPcontacts_GetBlocked() result."); + } + })), rpcFail(base::lambda_guarded(this, [this](const RPCError &error) { + if (MTP::isDefaultHandledError(error)) { + return false; + } + _loadRequestId = 0; + return true; + }))); +} + +void BlockedBoxController::rowClicked(PeerData *peer) { + Ui::showPeerHistoryAsync(peer->id, ShowAtUnreadMsgId); +} + +void BlockedBoxController::rowActionClicked(PeerData *peer) { + auto user = peer->asUser(); + t_assert(user != nullptr); + + App::api()->unblockUser(user); +} + +void BlockedBoxController::receivedUsers(const QVector &result) { + if (result.empty()) { + _allLoaded = true; + } + + for_const (auto &item, result) { + ++_offset; + if (item.type() != mtpc_contactBlocked) { + continue; + } + auto &contactBlocked = item.c_contactBlocked(); + auto userId = contactBlocked.vuser_id.v; + if (auto user = App::userLoaded(userId)) { + appendRow(user); + user->setBlockStatus(UserData::BlockStatus::Blocked); + } + } + view()->refreshRows(); +} + +void BlockedBoxController::handleBlockedEvent(UserData *user) { + if (user->isBlocked()) { + if (prependRow(user)) { + view()->refreshRows(); + } + } else if (auto row = view()->findRow(user)) { + view()->removeRow(row); + view()->refreshRows(); + } +} + +bool BlockedBoxController::appendRow(UserData *user) { + if (view()->findRow(user)) { + return false; + } + view()->appendRow(createRow(user)); + return true; +} + +bool BlockedBoxController::prependRow(UserData *user) { + if (view()->findRow(user)) { + return false; + } + view()->prependRow(createRow(user)); + return true; +} + +std::unique_ptr BlockedBoxController::createRow(UserData *user) const { + auto row = std::make_unique(user); + row->setActionLink(lang(lng_blocked_list_unblock)); + auto status = [user]() -> QString { + if (user->botInfo) { + return lang(lng_status_bot); + } else if (user->phone().isEmpty()) { + return lang(lng_blocked_list_unknown_phone); + } + return App::formatPhone(user->phone()); + }; + row->setCustomStatus(status()); + return row; +} + +} // namespace Settings diff --git a/Telegram/SourceFiles/settings/settings_blocked_box_controller.h b/Telegram/SourceFiles/settings/settings_blocked_box_controller.h new file mode 100644 index 000000000..9dc625571 --- /dev/null +++ b/Telegram/SourceFiles/settings/settings_blocked_box_controller.h @@ -0,0 +1,47 @@ +/* +This file is part of Telegram Desktop, +the official desktop version of Telegram messaging app, see https://telegram.org + +Telegram Desktop 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. + +It 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. + +In addition, as a special exception, the copyright holders give permission +to link the code of portions of this program with the OpenSSL library. + +Full license: https://github.com/telegramdesktop/tdesktop/blob/master/LICENSE +Copyright (c) 2014-2017 John Preston, https://desktop.telegram.org +*/ +#pragma once + +#include "boxes/peer_list_box.h" + +namespace Settings { + +class BlockedBoxController : public QObject, public PeerListBox::Controller, private base::Subscriber { +public: + void prepare() override; + void rowClicked(PeerData *peer) override; + void rowActionClicked(PeerData *peer) override; + void preloadRows() override; + +private: + void receivedUsers(const QVector &result); + void handleBlockedEvent(UserData *user); + bool appendRow(UserData *user); + bool prependRow(UserData *user); + std::unique_ptr createRow(UserData *user) const; + + int _offset = 0; + mtpRequestId _loadRequestId = 0; + bool _allLoaded = false; + +}; + +} // namespace Settings diff --git a/Telegram/SourceFiles/settings/settings_privacy_widget.cpp b/Telegram/SourceFiles/settings/settings_privacy_widget.cpp index 80f3a803a..fa4e79ac8 100644 --- a/Telegram/SourceFiles/settings/settings_privacy_widget.cpp +++ b/Telegram/SourceFiles/settings/settings_privacy_widget.cpp @@ -28,7 +28,9 @@ Copyright (c) 2014-2017 John Preston, https://desktop.telegram.org #include "boxes/sessionsbox.h" #include "boxes/passcodebox.h" #include "boxes/autolockbox.h" +#include "boxes/peer_list_box.h" #include "platform/platform_specific.h" +#include "settings/settings_blocked_box_controller.h" namespace Settings { @@ -170,6 +172,7 @@ void PrivacyWidget::createControls() { style::margins marginSkip(0, 0, 0, st::settingsSkip); style::margins slidedPadding(0, marginSmall.bottom() / 2, 0, marginSmall.bottom() - (marginSmall.bottom() / 2)); + addChildRow(_blockedUsers, marginSmall, lang(lng_settings_blocked_users), SLOT(onBlockedUsers())); addChildRow(_localPasscodeState, marginSmall); auto label = lang(psIdleSupported() ? lng_passcode_autolock_away : lng_passcode_autolock_inactive); auto value = (Global::AutoLock() % 3600) ? lng_passcode_autolock_minutes(lt_count, Global::AutoLock() / 60) : lng_passcode_autolock_hours(lt_count, Global::AutoLock() / 3600); @@ -192,6 +195,10 @@ void PrivacyWidget::autoLockUpdated() { } } +void PrivacyWidget::onBlockedUsers() { + Ui::show(Box(std::make_unique())); +} + void PrivacyWidget::onAutoLock() { Ui::show(Box()); } diff --git a/Telegram/SourceFiles/settings/settings_privacy_widget.h b/Telegram/SourceFiles/settings/settings_privacy_widget.h index bb90d9753..599150265 100644 --- a/Telegram/SourceFiles/settings/settings_privacy_widget.h +++ b/Telegram/SourceFiles/settings/settings_privacy_widget.h @@ -85,6 +85,7 @@ public: PrivacyWidget(QWidget *parent, UserData *self); private slots: + void onBlockedUsers(); void onAutoLock(); void onShowSessions(); @@ -92,6 +93,7 @@ private: void createControls(); void autoLockUpdated(); + object_ptr _blockedUsers = { nullptr }; object_ptr _localPasscodeState = { nullptr }; object_ptr> _autoLock = { nullptr }; object_ptr _cloudPasswordState = { nullptr }; diff --git a/Telegram/gyp/telegram_sources.txt b/Telegram/gyp/telegram_sources.txt index c5e415539..271c50061 100644 --- a/Telegram/gyp/telegram_sources.txt +++ b/Telegram/gyp/telegram_sources.txt @@ -32,6 +32,8 @@ <(src_loc)/boxes/members_box.h <(src_loc)/boxes/notifications_box.cpp <(src_loc)/boxes/notifications_box.h +<(src_loc)/boxes/peer_list_box.cpp +<(src_loc)/boxes/peer_list_box.h <(src_loc)/boxes/passcodebox.cpp <(src_loc)/boxes/passcodebox.h <(src_loc)/boxes/photocropbox.cpp @@ -295,6 +297,8 @@ <(src_loc)/settings/settings_advanced_widget.h <(src_loc)/settings/settings_background_widget.cpp <(src_loc)/settings/settings_background_widget.h +<(src_loc)/settings/settings_blocked_box_controller.cpp +<(src_loc)/settings/settings_blocked_box_controller.h <(src_loc)/settings/settings_block_widget.cpp <(src_loc)/settings/settings_block_widget.h <(src_loc)/settings/settings_chat_settings_widget.cpp