577 lines
14 KiB
C++
577 lines
14 KiB
C++
/*
|
|
This file is part of Telegram Desktop,
|
|
the official desktop application for the Telegram messaging service.
|
|
|
|
For license and copyright information please follow this link:
|
|
https://github.com/telegramdesktop/tdesktop/blob/master/LEGAL
|
|
*/
|
|
#include "dialogs/dialogs_row.h"
|
|
|
|
#include "ui/chat/chat_theme.h" // CountAverageColor.
|
|
#include "ui/color_contrast.h"
|
|
#include "ui/effects/ripple_animation.h"
|
|
#include "ui/image/image_prepare.h"
|
|
#include "ui/text/format_values.h"
|
|
#include "ui/text/text_options.h"
|
|
#include "ui/text/text_utilities.h"
|
|
#include "ui/painter.h"
|
|
#include "dialogs/dialogs_entry.h"
|
|
#include "dialogs/ui/dialogs_video_userpic.h"
|
|
#include "dialogs/ui/dialogs_layout.h"
|
|
#include "data/data_folder.h"
|
|
#include "data/data_forum.h"
|
|
#include "data/data_session.h"
|
|
#include "data/data_peer_values.h"
|
|
#include "history/history.h"
|
|
#include "history/history_item.h"
|
|
#include "lang/lang_keys.h"
|
|
#include "base/unixtime.h"
|
|
#include "styles/style_dialogs.h"
|
|
|
|
namespace Dialogs {
|
|
namespace {
|
|
|
|
constexpr auto kTopLayer = 2;
|
|
constexpr auto kBottomLayer = 1;
|
|
constexpr auto kNoneLayer = 0;
|
|
|
|
[[nodiscard]] QImage CornerBadgeTTL(
|
|
not_null<PeerData*> peer,
|
|
Ui::PeerUserpicView &view,
|
|
int photoSize) {
|
|
const auto ttl = peer->messagesTTL();
|
|
if (!ttl) {
|
|
return QImage();
|
|
}
|
|
constexpr auto kBlurRadius = 24;
|
|
|
|
const auto ratio = style::DevicePixelRatio();
|
|
const auto fullSize = photoSize;
|
|
const auto blurredFull = Images::BlurLargeImage(
|
|
peer->generateUserpicImage(view, fullSize * ratio, 0),
|
|
kBlurRadius);
|
|
const auto partRect = CornerBadgeTTLRect(fullSize);
|
|
const auto &partSize = partRect.width();
|
|
auto result = [&] {
|
|
auto blurredPart = blurredFull.copy(
|
|
blurredFull.width() - partSize * ratio,
|
|
blurredFull.height() - partSize * ratio,
|
|
partSize * ratio,
|
|
partSize * ratio);
|
|
blurredPart.setDevicePixelRatio(ratio);
|
|
|
|
constexpr auto kMinAcceptableContrast = 4.5;
|
|
const auto averageColor = Ui::CountAverageColor(blurredPart);
|
|
const auto contrast = Ui::CountContrast(
|
|
averageColor,
|
|
st::premiumButtonFg->c);
|
|
if (contrast < kMinAcceptableContrast) {
|
|
constexpr auto kDarkerBy = 0.2;
|
|
auto painterPart = QPainter(&blurredPart);
|
|
painterPart.setOpacity(kDarkerBy);
|
|
painterPart.fillRect(
|
|
QRect(QPoint(), partRect.size()),
|
|
Qt::black);
|
|
}
|
|
return Images::Circle(std::move(blurredPart));
|
|
}();
|
|
|
|
auto q = QPainter(&result);
|
|
PainterHighQualityEnabler hq(q);
|
|
|
|
const auto innerRect = QRect(QPoint(), partRect.size())
|
|
- st::dialogsTTLBadgeInnerMargins;
|
|
const auto ttlText = Ui::FormatTTLTiny(ttl);
|
|
|
|
q.setFont(st::dialogsScamFont);
|
|
q.setPen(st::premiumButtonFg);
|
|
q.drawText(
|
|
innerRect,
|
|
(ttlText.size() > 2) ? ttlText.mid(0, 2) : ttlText,
|
|
style::al_center);
|
|
|
|
constexpr auto kPenWidth = 1.5;
|
|
|
|
const auto penWidth = style::ConvertScaleExact(kPenWidth);
|
|
auto pen = QPen(st::premiumButtonFg);
|
|
pen.setJoinStyle(Qt::RoundJoin);
|
|
pen.setCapStyle(Qt::RoundCap);
|
|
pen.setWidthF(penWidth);
|
|
|
|
q.setPen(pen);
|
|
q.setBrush(Qt::NoBrush);
|
|
q.drawArc(innerRect, arc::kQuarterLength, arc::kHalfLength);
|
|
|
|
q.setClipRect(innerRect
|
|
- QMargins(innerRect.width() / 2, 0, -penWidth, -penWidth));
|
|
pen.setStyle(Qt::DotLine);
|
|
q.setPen(pen);
|
|
q.drawEllipse(innerRect);
|
|
|
|
return result;
|
|
}
|
|
|
|
} // namespace
|
|
|
|
QRect CornerBadgeTTLRect(int photoSize) {
|
|
const auto &partSize = st::dialogsTTLBadgeSize;
|
|
return QRect(
|
|
photoSize - partSize + st::dialogsTTLBadgeSkip.x(),
|
|
photoSize - partSize + st::dialogsTTLBadgeSkip.y(),
|
|
partSize,
|
|
partSize);
|
|
}
|
|
|
|
Row::CornerLayersManager::CornerLayersManager() = default;
|
|
|
|
bool Row::CornerLayersManager::isSameLayer(Layer layer) const {
|
|
return isFinished() && (_nextLayer == layer);
|
|
}
|
|
|
|
void Row::CornerLayersManager::setLayer(
|
|
Layer layer,
|
|
Fn<void()> updateCallback) {
|
|
if (_nextLayer == layer) {
|
|
return;
|
|
}
|
|
_lastFrameShown = false;
|
|
_prevLayer = _nextLayer;
|
|
_nextLayer = layer;
|
|
if (_animation.animating()) {
|
|
_animation.change(
|
|
1.,
|
|
st::dialogsOnlineBadgeDuration * (1. - _animation.value(1.)));
|
|
} else if (updateCallback) {
|
|
_animation.start(
|
|
std::move(updateCallback),
|
|
0.,
|
|
1.,
|
|
st::dialogsOnlineBadgeDuration);
|
|
}
|
|
}
|
|
|
|
float64 Row::CornerLayersManager::progressForLayer(Layer layer) const {
|
|
return (_nextLayer == layer)
|
|
? progress()
|
|
: (_prevLayer == layer)
|
|
? (1. - progress())
|
|
: 0.;
|
|
}
|
|
|
|
float64 Row::CornerLayersManager::progress() const {
|
|
return _animation.value(1.);
|
|
}
|
|
|
|
bool Row::CornerLayersManager::isFinished() const {
|
|
return (progress() == 1.) && _lastFrameShown;
|
|
}
|
|
|
|
void Row::CornerLayersManager::markFrameShown() {
|
|
if (progress() == 1.) {
|
|
_lastFrameShown = true;
|
|
}
|
|
}
|
|
|
|
bool Row::CornerLayersManager::isDisplayedNone() const {
|
|
return (progress() == 1.) && (_nextLayer == 0);
|
|
}
|
|
|
|
BasicRow::BasicRow() = default;
|
|
BasicRow::~BasicRow() = default;
|
|
|
|
void BasicRow::addRipple(
|
|
QPoint origin,
|
|
QSize size,
|
|
Fn<void()> updateCallback) {
|
|
if (!_ripple) {
|
|
addRippleWithMask(
|
|
origin,
|
|
Ui::RippleAnimation::RectMask(size),
|
|
std::move(updateCallback));
|
|
} else {
|
|
_ripple->add(origin);
|
|
}
|
|
}
|
|
|
|
void BasicRow::addRippleWithMask(
|
|
QPoint origin,
|
|
QImage mask,
|
|
Fn<void()> updateCallback) {
|
|
_ripple = std::make_unique<Ui::RippleAnimation>(
|
|
st::dialogsRipple,
|
|
std::move(mask),
|
|
std::move(updateCallback));
|
|
_ripple->add(origin);
|
|
}
|
|
|
|
void BasicRow::clearRipple() {
|
|
_ripple = nullptr;
|
|
}
|
|
|
|
void BasicRow::stopLastRipple() {
|
|
if (_ripple) {
|
|
_ripple->lastStop();
|
|
}
|
|
}
|
|
|
|
void BasicRow::paintRipple(
|
|
QPainter &p,
|
|
int x,
|
|
int y,
|
|
int outerWidth,
|
|
const QColor *colorOverride) const {
|
|
if (_ripple) {
|
|
_ripple->paint(p, x, y, outerWidth, colorOverride);
|
|
if (_ripple->empty()) {
|
|
_ripple.reset();
|
|
}
|
|
}
|
|
}
|
|
|
|
void BasicRow::paintUserpic(
|
|
Painter &p,
|
|
not_null<PeerData*> peer,
|
|
Ui::VideoUserpic *videoUserpic,
|
|
History *historyForCornerBadge,
|
|
const Ui::PaintContext &context) const {
|
|
PaintUserpic(
|
|
p,
|
|
peer,
|
|
videoUserpic,
|
|
_userpic,
|
|
context.st->padding.left(),
|
|
context.st->padding.top(),
|
|
context.width,
|
|
context.st->photoSize,
|
|
context.paused);
|
|
}
|
|
|
|
Row::Row(Key key, int index, int top) : _id(key), _top(top), _index(index) {
|
|
if (const auto history = key.history()) {
|
|
updateCornerBadgeShown(history->peer);
|
|
}
|
|
}
|
|
|
|
Row::~Row() {
|
|
clearTopicJumpRipple();
|
|
}
|
|
|
|
void Row::recountHeight(float64 narrowRatio) {
|
|
if (const auto history = _id.history()) {
|
|
_height = history->isForum()
|
|
? anim::interpolate(
|
|
st::forumDialogRow.height,
|
|
st::defaultDialogRow.height,
|
|
narrowRatio)
|
|
: st::defaultDialogRow.height;
|
|
} else if (_id.folder()) {
|
|
_height = st::defaultDialogRow.height;
|
|
} else {
|
|
_height = st::forumTopicRow.height;
|
|
}
|
|
}
|
|
|
|
uint64 Row::sortKey(FilterId filterId) const {
|
|
return _id.entry()->sortKeyInChatList(filterId);
|
|
}
|
|
|
|
void Row::setCornerBadgeShown(
|
|
CornerLayersManager::Layer nextLayer,
|
|
Fn<void()> updateCallback) const {
|
|
const auto cornerBadgeShown = (nextLayer ? 1 : 0);
|
|
if (_cornerBadgeShown == cornerBadgeShown) {
|
|
if (!cornerBadgeShown) {
|
|
return;
|
|
} else if (_cornerBadgeUserpic
|
|
&& _cornerBadgeUserpic->layersManager.isSameLayer(nextLayer)) {
|
|
return;
|
|
}
|
|
}
|
|
const_cast<Row*>(this)->_cornerBadgeShown = cornerBadgeShown;
|
|
ensureCornerBadgeUserpic();
|
|
_cornerBadgeUserpic->layersManager.setLayer(
|
|
nextLayer,
|
|
std::move(updateCallback));
|
|
if (!_cornerBadgeShown
|
|
&& _cornerBadgeUserpic
|
|
&& _cornerBadgeUserpic->layersManager.isDisplayedNone()) {
|
|
_cornerBadgeUserpic = nullptr;
|
|
}
|
|
}
|
|
|
|
void Row::updateCornerBadgeShown(
|
|
not_null<PeerData*> peer,
|
|
Fn<void()> updateCallback) const {
|
|
const auto user = peer->asUser();
|
|
const auto now = user ? base::unixtime::now() : TimeId();
|
|
const auto nextLayer = [&] {
|
|
if (user && Data::IsUserOnline(user, now)) {
|
|
return kTopLayer;
|
|
} else if (peer->isChannel()
|
|
&& Data::ChannelHasActiveCall(peer->asChannel())) {
|
|
return kTopLayer;
|
|
} else if (peer->messagesTTL()) {
|
|
return kBottomLayer;
|
|
}
|
|
return kNoneLayer;
|
|
}();
|
|
setCornerBadgeShown(nextLayer, std::move(updateCallback));
|
|
if ((nextLayer == kTopLayer) && user) {
|
|
peer->owner().watchForOffline(user, now);
|
|
}
|
|
}
|
|
|
|
void Row::ensureCornerBadgeUserpic() const {
|
|
if (_cornerBadgeUserpic) {
|
|
return;
|
|
}
|
|
_cornerBadgeUserpic = std::make_unique<CornerBadgeUserpic>();
|
|
}
|
|
|
|
void Row::PaintCornerBadgeFrame(
|
|
not_null<CornerBadgeUserpic*> data,
|
|
not_null<PeerData*> peer,
|
|
Ui::VideoUserpic *videoUserpic,
|
|
Ui::PeerUserpicView &view,
|
|
const Ui::PaintContext &context) {
|
|
data->frame.fill(Qt::transparent);
|
|
|
|
Painter q(&data->frame);
|
|
PaintUserpic(
|
|
q,
|
|
peer,
|
|
videoUserpic,
|
|
view,
|
|
0,
|
|
0,
|
|
data->frame.width() / data->frame.devicePixelRatio(),
|
|
context.st->photoSize,
|
|
context.paused);
|
|
|
|
const auto &manager = data->layersManager;
|
|
if (const auto p = manager.progressForLayer(kBottomLayer); p) {
|
|
const auto size = context.st->photoSize;
|
|
if (data->cacheTTL.isNull() && peer->messagesTTL()) {
|
|
data->cacheTTL = CornerBadgeTTL(peer, view, size);
|
|
}
|
|
q.setOpacity(p);
|
|
const auto point = CornerBadgeTTLRect(size).topLeft();
|
|
q.drawImage(point, data->cacheTTL);
|
|
q.setOpacity(1.);
|
|
}
|
|
const auto topLayerProgress = manager.progressForLayer(kTopLayer);
|
|
if (!topLayerProgress) {
|
|
return;
|
|
}
|
|
|
|
PainterHighQualityEnabler hq(q);
|
|
q.setCompositionMode(QPainter::CompositionMode_Source);
|
|
|
|
const auto size = peer->isUser()
|
|
? st::dialogsOnlineBadgeSize
|
|
: st::dialogsCallBadgeSize;
|
|
const auto stroke = st::dialogsOnlineBadgeStroke;
|
|
const auto skip = peer->isUser()
|
|
? st::dialogsOnlineBadgeSkip
|
|
: st::dialogsCallBadgeSkip;
|
|
const auto shrink = (size / 2) * (1. - topLayerProgress);
|
|
|
|
auto pen = QPen(Qt::transparent);
|
|
pen.setWidthF(stroke * topLayerProgress);
|
|
q.setPen(pen);
|
|
q.setBrush(data->active
|
|
? st::dialogsOnlineBadgeFgActive
|
|
: st::dialogsOnlineBadgeFg);
|
|
q.drawEllipse(QRectF(
|
|
context.st->photoSize - skip.x() - size,
|
|
context.st->photoSize - skip.y() - size,
|
|
size,
|
|
size
|
|
).marginsRemoved({ shrink, shrink, shrink, shrink }));
|
|
}
|
|
|
|
void Row::paintUserpic(
|
|
Painter &p,
|
|
not_null<PeerData*> peer,
|
|
Ui::VideoUserpic *videoUserpic,
|
|
History *historyForCornerBadge,
|
|
const Ui::PaintContext &context) const {
|
|
updateCornerBadgeShown(peer);
|
|
|
|
const auto cornerBadgeShown = !_cornerBadgeUserpic
|
|
? _cornerBadgeShown
|
|
: !_cornerBadgeUserpic->layersManager.isDisplayedNone();
|
|
if (!historyForCornerBadge || !cornerBadgeShown) {
|
|
BasicRow::paintUserpic(
|
|
p,
|
|
peer,
|
|
videoUserpic,
|
|
historyForCornerBadge,
|
|
context);
|
|
if (!historyForCornerBadge || !_cornerBadgeShown) {
|
|
_cornerBadgeUserpic = nullptr;
|
|
}
|
|
return;
|
|
}
|
|
ensureCornerBadgeUserpic();
|
|
const auto ratio = style::DevicePixelRatio();
|
|
const auto added = std::max({
|
|
-st::dialogsCallBadgeSkip.x(),
|
|
-st::dialogsCallBadgeSkip.y(),
|
|
0 });
|
|
const auto frameSide = (context.st->photoSize + added)
|
|
* style::DevicePixelRatio();
|
|
const auto frameSize = QSize(frameSide, frameSide);
|
|
if (_cornerBadgeUserpic->frame.size() != frameSize) {
|
|
_cornerBadgeUserpic->frame = QImage(
|
|
frameSize,
|
|
QImage::Format_ARGB32_Premultiplied);
|
|
_cornerBadgeUserpic->frame.setDevicePixelRatio(ratio);
|
|
}
|
|
auto key = peer->userpicUniqueKey(userpicView());
|
|
key.first += peer->messagesTTL();
|
|
const auto frameIndex = videoUserpic ? videoUserpic->frameIndex() : -1;
|
|
const auto paletteVersion = style::PaletteVersion();
|
|
const auto keyChanged = (_cornerBadgeUserpic->key != key)
|
|
|| (_cornerBadgeUserpic->paletteVersion != paletteVersion);
|
|
if (keyChanged) {
|
|
_cornerBadgeUserpic->cacheTTL = QImage();
|
|
}
|
|
if (keyChanged
|
|
|| !_cornerBadgeUserpic->layersManager.isFinished()
|
|
|| _cornerBadgeUserpic->active != context.active
|
|
|| _cornerBadgeUserpic->frameIndex != frameIndex
|
|
|| videoUserpic) {
|
|
_cornerBadgeUserpic->key = key;
|
|
_cornerBadgeUserpic->paletteVersion = paletteVersion;
|
|
_cornerBadgeUserpic->active = context.active;
|
|
_cornerBadgeUserpic->frameIndex = frameIndex;
|
|
_cornerBadgeUserpic->layersManager.markFrameShown();
|
|
PaintCornerBadgeFrame(
|
|
_cornerBadgeUserpic.get(),
|
|
peer,
|
|
videoUserpic,
|
|
userpicView(),
|
|
context);
|
|
}
|
|
p.drawImage(
|
|
context.st->padding.left(),
|
|
context.st->padding.top(),
|
|
_cornerBadgeUserpic->frame);
|
|
if (historyForCornerBadge->peer->isUser()) {
|
|
return;
|
|
}
|
|
const auto actionPainter = historyForCornerBadge->sendActionPainter();
|
|
const auto bg = context.active
|
|
? st::dialogsBgActive
|
|
: st::dialogsBg;
|
|
const auto size = st::dialogsCallBadgeSize;
|
|
const auto skip = st::dialogsCallBadgeSkip;
|
|
p.setOpacity(
|
|
_cornerBadgeUserpic->layersManager.progressForLayer(kTopLayer));
|
|
p.translate(context.st->padding.left(), context.st->padding.top());
|
|
actionPainter->paintSpeaking(
|
|
p,
|
|
context.st->photoSize - skip.x() - size,
|
|
context.st->photoSize - skip.y() - size,
|
|
context.width,
|
|
bg,
|
|
context.now);
|
|
p.translate(-context.st->padding.left(), -context.st->padding.top());
|
|
p.setOpacity(1.);
|
|
}
|
|
|
|
bool Row::lookupIsInTopicJump(int x, int y) const {
|
|
const auto history = this->history();
|
|
return history && history->lastItemDialogsView().isInTopicJump(x, y);
|
|
}
|
|
|
|
void Row::stopLastRipple() {
|
|
BasicRow::stopLastRipple();
|
|
const auto history = this->history();
|
|
const auto view = history ? &history->lastItemDialogsView() : nullptr;
|
|
if (view) {
|
|
view->stopLastRipple();
|
|
}
|
|
}
|
|
|
|
void Row::clearRipple() {
|
|
BasicRow::clearRipple();
|
|
clearTopicJumpRipple();
|
|
}
|
|
|
|
void Row::addTopicJumpRipple(
|
|
QPoint origin,
|
|
not_null<Ui::TopicJumpCache*> topicJumpCache,
|
|
Fn<void()> updateCallback) {
|
|
const auto history = this->history();
|
|
const auto view = history ? &history->lastItemDialogsView() : nullptr;
|
|
if (view) {
|
|
view->addTopicJumpRipple(
|
|
origin,
|
|
topicJumpCache,
|
|
std::move(updateCallback));
|
|
_topicJumpRipple = 1;
|
|
}
|
|
}
|
|
|
|
void Row::clearTopicJumpRipple() {
|
|
if (!_topicJumpRipple) {
|
|
return;
|
|
}
|
|
const auto history = this->history();
|
|
const auto view = history ? &history->lastItemDialogsView() : nullptr;
|
|
if (view) {
|
|
view->clearRipple();
|
|
}
|
|
_topicJumpRipple = 0;
|
|
}
|
|
|
|
bool Row::topicJumpRipple() const {
|
|
return _topicJumpRipple != 0;
|
|
}
|
|
|
|
FakeRow::FakeRow(
|
|
Key searchInChat,
|
|
not_null<HistoryItem*> item,
|
|
Fn<void()> repaint)
|
|
: _searchInChat(searchInChat)
|
|
, _item(item)
|
|
, _repaint(std::move(repaint)) {
|
|
invalidateTopic();
|
|
}
|
|
|
|
void FakeRow::invalidateTopic() {
|
|
_topic = _item->topic();
|
|
if (_topic) {
|
|
return;
|
|
} else if (const auto rootId = _item->topicRootId()) {
|
|
if (const auto forum = _item->history()->asForum()) {
|
|
if (!forum->topicDeleted(rootId)) {
|
|
forum->requestTopic(rootId, crl::guard(this, [=] {
|
|
_topic = _item->topic();
|
|
if (_topic) {
|
|
_repaint();
|
|
}
|
|
}));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
const Ui::Text::String &FakeRow::name() const {
|
|
if (_name.isEmpty()) {
|
|
const auto from = _searchInChat
|
|
? _item->displayFrom()
|
|
: nullptr;
|
|
const auto peer = from ? from : _item->history()->peer.get();
|
|
_name.setText(
|
|
st::semiboldTextStyle,
|
|
peer->name(),
|
|
Ui::NameTextOptions());
|
|
}
|
|
return _name;
|
|
}
|
|
|
|
} // namespace Dialogs
|