ZaStoGram_desktop/Telegram/SourceFiles/wallet/wallet_card_stickers.cpp
John Preston 31f7ce9ad7 Show the card fiat and GRAM halo only over gifts
Task: 2026/10/20/keep-the-card-fiat-amount-and-gram-readable-over-gifts
2026-10-20 21:23:41 +04:00

1450 lines
39 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 "wallet/wallet_card_stickers.h"
#include "apiwrap.h"
#include "data/data_document.h"
#include "data/data_document_media.h"
#include "data/data_star_gift.h"
#include "data/data_user.h"
#include "data/data_user_wallet_card.h"
#include "history/view/media/history_view_sticker_player.h"
#include "lottie/lottie_common.h"
#include "lottie/lottie_single_player.h"
#include "main/main_session.h"
#include "ui/effects/star_burst.h"
#include "ui/painter.h"
#include "ui/power_saving.h"
#include "wallet/wallet_address.h"
#include "wallet/wallet_card_space.h"
#include "wallet/wallet_own_card.h"
#include "wallet/wallet_session.h"
#include "styles/style_wallet.h"
namespace Wallet {
namespace {
// WHY: the outline is computed on a grid of at most this many cells per
// outline radius, so the work per frame pixel stays bounded at any size.
constexpr auto kOutlineSamples = 8;
constexpr auto kNoSite = std::numeric_limits<float>::max();
constexpr auto kSolidSpan = -2;
constexpr auto kBlendSpan = -3;
constexpr auto kSettleDuration = crl::time(70);
constexpr auto kRingDelay = crl::time(50);
constexpr auto kRingDuration = crl::time(300);
constexpr auto kLandingDuration = kRingDelay + kRingDuration;
constexpr auto kSparkleDelay = crl::time(150);
constexpr auto kSparkleSpread = crl::time(50);
constexpr auto kSparkleLifeMin = crl::time(100);
constexpr auto kSparkleLifeMax = crl::time(150);
constexpr auto kRingStartScale = 1.2;
constexpr auto kRingGrowth = 0.8;
constexpr auto kRingOpacity = 0.6;
constexpr auto kSinkDuration = crl::time(300);
struct OutlineGrid {
int step = 0;
int columns = 0;
int rows = 0;
std::vector<float> values;
std::vector<float> horizontal;
std::vector<float> vertical;
std::vector<float> tones;
std::vector<uchar> alphas;
};
struct Envelope {
std::vector<float> positions;
std::vector<float> heights;
std::vector<float> carries;
std::vector<float> shades;
std::vector<float> bounds;
};
struct OutlineSpan {
int from = 0;
int till = 0;
int column = 0;
QRgb value = 0;
};
[[nodiscard]] QSize FrameSize(not_null<DocumentData*> document, int side) {
const auto box = QSize(side, side);
const auto &dimensions = document->dimensions;
return dimensions.isEmpty()
? box
: dimensions.scaled(box, Qt::KeepAspectRatio).expandedTo({ 1, 1 });
}
[[nodiscard]] std::unique_ptr<HistoryView::StickerPlayer> MakePlayer(
not_null<DocumentData*> document,
const QByteArray &bytes,
int side,
int ratio) {
const auto sticker = document->sticker();
const auto size = FrameSize(document, side);
if (sticker && sticker->isLottie()) {
return std::make_unique<HistoryView::LottiePlayer>(
std::make_unique<Lottie::SinglePlayer>(
Lottie::ReadContent(bytes, document->filepath()),
Lottie::FrameRequest{ size * ratio },
Lottie::Quality::High));
} else if (sticker && sticker->isWebm()) {
return std::make_unique<HistoryView::WebmPlayer>(
document->location(),
bytes,
size);
}
return std::make_unique<HistoryView::StaticStickerPlayer>(
document->location(),
bytes,
size);
}
void LowerEnvelope(
float *values,
float *along,
float *across,
float *tones,
int count,
int stride,
float cutoff,
Envelope &buffer) {
const auto positions = buffer.positions.data();
const auto heights = buffer.heights.data();
const auto carries = buffer.carries.data();
const auto shades = buffer.shades.data();
const auto bounds = buffer.bounds.data();
auto top = -1;
for (auto q = 0; q != count; ++q) {
const auto height = values[q * stride];
if (height >= cutoff) {
continue;
}
const auto position = q + along[q * stride];
auto bound = -kNoSite;
while (top >= 0) {
const auto site = positions[top];
bound = (height - heights[top] + position * position - site * site)
/ (2.f * (position - site));
if (bound > bounds[top]) {
break;
}
--top;
}
++top;
positions[top] = position;
heights[top] = height;
carries[top] = across[q * stride];
shades[top] = tones[q * stride];
bounds[top] = bound;
}
if (top < 0) {
return;
}
auto index = 0;
for (auto q = 0; q != count; ++q) {
while (index < top && bounds[index + 1] <= q) {
++index;
}
const auto delta = q - positions[index];
values[q * stride] = delta * delta + heights[index];
across[q * stride] = carries[index];
tones[q * stride] = shades[index];
}
}
void SpreadRows(uchar *to, const uchar *from, int columns, int count) {
for (auto row = 0; row != count; row += columns) {
const auto line = from + row;
const auto result = to + row;
result[0] = std::max(line[0], line[1]);
for (auto x = 1; x != columns - 1; ++x) {
result[x] = std::max(line[x], std::max(line[x - 1], line[x + 1]));
}
result[columns - 1] = std::max(line[columns - 2], line[columns - 1]);
}
}
void MaxShifted(uchar *to, const uchar *from, int count, int shift) {
const auto till = count + std::min(shift, 0);
for (auto i = std::max(shift, 0); i < till; ++i) {
to[i] = std::max(to[i], from[i - shift]);
}
}
[[nodiscard]] OutlineGrid OutlineSites(const QImage &frame, int outline) {
const auto step = (outline + kOutlineSamples - 1) / kOutlineSamples;
const auto width = frame.width();
const auto columns = (width + 2 * outline + step - 1) / step;
const auto rows = (frame.height() + 2 * outline + step - 1) / step;
const auto cells = columns * rows;
const auto middle = (step - 1) / 2.f;
auto result = OutlineGrid{
.step = step,
.columns = columns,
.rows = rows,
.values = std::vector<float>(cells, kNoSite),
.horizontal = std::vector<float>(cells),
.vertical = std::vector<float>(cells),
.tones = std::vector<float>(cells),
.alphas = std::vector<uchar>(cells),
};
auto sums = std::vector<float>(cells);
auto buffer = std::vector<uchar>(2 * cells);
auto lineSums = std::vector<float>(width);
auto lineShifts = std::vector<float>(width);
auto linePeaks = std::vector<uchar>(width);
for (auto row = 0; row != rows; ++row) {
const auto top = std::max(row * step - outline, 0);
const auto bottom = std::min(
(row + 1) * step - outline,
frame.height());
if (top >= bottom) {
continue;
}
ranges::fill(lineSums, 0.f);
ranges::fill(lineShifts, 0.f);
ranges::fill(linePeaks, uchar());
for (auto y = top; y != bottom; ++y) {
const auto pixels = reinterpret_cast<const QRgb*>(
frame.constScanLine(y));
const auto shift = y + outline - row * step - middle;
for (auto x = 0; x != width; ++x) {
const auto alpha = uchar(qAlpha(pixels[x]));
lineSums[x] += alpha;
lineShifts[x] += alpha * shift;
linePeaks[x] = std::max(linePeaks[x], alpha);
}
}
auto x = 0;
for (auto column = outline / step; x != width; ++column) {
const auto till = std::min((column + 1) * step - outline, width);
auto sum = 0.f;
auto horizontal = 0.f;
auto vertical = 0.f;
auto peak = uchar();
for (; x != till; ++x) {
const auto shift = x + outline - column * step - middle;
sum += lineSums[x];
horizontal += lineSums[x] * shift;
vertical += lineShifts[x];
peak = std::max(peak, linePeaks[x]);
}
const auto index = row * columns + column;
sums[index] = sum;
result.horizontal[index] = horizontal;
result.vertical[index] = vertical;
result.alphas[index] = peak;
}
}
const auto tones = buffer.data();
const auto spread = tones + cells;
SpreadRows(spread, result.alphas.data(), columns, cells);
std::copy(spread, spread + cells, tones);
MaxShifted(tones, spread, cells, columns);
MaxShifted(tones, spread, cells, -columns);
for (auto index = 0; index != cells; ++index) {
const auto sum = sums[index];
if (!sum) {
continue;
}
// antialiased rims count as partial cover of their brighter neighbour
const auto coverage = sum / (float(tones[index]) * step * step);
const auto reach = (outline
+ coverage * step / 2.f
- (1.f - coverage) / (2.f * step)) / step;
result.values[index] = -reach * reach;
result.horizontal[index] /= sum * step;
result.vertical[index] /= sum * step;
result.tones[index] = tones[index];
}
return result;
}
void OutlineDistances(OutlineGrid &grid, int outline) {
const auto step = grid.step;
const auto columns = grid.columns;
const auto rows = grid.rows;
const auto values = grid.values.data();
const auto horizontal = grid.horizontal.data();
const auto vertical = grid.vertical.data();
const auto tones = grid.tones.data();
const auto relative = outline / float(step);
const auto limit = float(outline + 2 * step);
const auto cutoff = (limit * limit) / (step * step) - relative * relative;
const auto longest = std::max(columns, rows);
auto buffer = Envelope{
.positions = std::vector<float>(longest),
.heights = std::vector<float>(longest),
.carries = std::vector<float>(longest),
.shades = std::vector<float>(longest),
.bounds = std::vector<float>(longest),
};
for (auto column = 0; column != columns; ++column) {
LowerEnvelope(
values + column,
vertical + column,
horizontal + column,
tones + column,
rows,
columns,
cutoff,
buffer);
}
for (auto row = 0; row != rows; ++row) {
const auto shift = row * columns;
LowerEnvelope(
values + shift,
horizontal + shift,
vertical + shift,
tones + shift,
columns,
1,
cutoff,
buffer);
}
for (auto &value : grid.values) {
value = (value == kNoSite)
? limit
: std::min(
limit,
step * std::sqrt(std::max(value + relative * relative, 0.f)));
}
}
void OutlineAlphas(OutlineGrid &grid, int outline) {
const auto columns = grid.columns;
const auto count = int(grid.alphas.size());
const auto radius = outline / float(grid.step);
const auto reaches = int(radius);
const auto result = grid.alphas.data();
auto buffer = std::vector<uchar>(2 * count);
auto rows = buffer.data();
auto spread = rows + count;
std::copy(result, result + count, rows);
for (auto reach = 0; reach <= reaches; ++reach) {
if (reach) {
SpreadRows(spread, rows, columns, count);
std::swap(rows, spread);
}
for (auto dy = -reaches; dy <= reaches; ++dy) {
const auto chord = std::max(radius * radius - dy * dy, 0.f);
if (int(std::sqrt(chord)) == reach) {
MaxShifted(result, rows, count, dy * columns);
}
}
}
// keep the nearest shape's alpha where the cell disc stops short of it
for (auto i = 0; i != count; ++i) {
result[i] = std::max(result[i], uchar(grid.tones[i]));
}
}
void OutlineSpans(
std::vector<OutlineSpan> &spans,
float *above,
float *below,
const OutlineGrid &grid,
const int *starts,
int upper,
int lower,
int outline) {
const auto step = grid.step;
const auto columns = grid.columns;
const auto middle = (step - 1) / 2.f;
const auto outer = outline + 0.5f;
const auto &values = grid.values;
const auto &alphas = grid.alphas;
const auto run = [&](int from, int till, int kind, QRgb value) {
if (!spans.empty()
&& spans.back().column == kind
&& spans.back().value == value) {
spans.back().till = till;
} else {
spans.push_back({ from, till, kind, value });
}
};
spans.clear();
for (auto column = -1; column < columns; ++column) {
const auto from = starts[column + 1];
const auto till = starts[column + 2];
if (from == till) {
continue;
}
const auto first = std::max(column, 0);
const auto second = std::min(column + 1, columns - 1);
const auto [nearest, farthest] = std::minmax({
values[upper + first],
values[upper + second],
values[lower + first],
values[lower + second],
});
const auto alpha = alphas[upper + first];
if (nearest >= outer) {
run(from, till, kSolidSpan, QRgb());
continue;
} else if (farthest > outer - 1.f) {
spans.push_back({ from, till, column });
continue;
} else if (alphas[upper + second] == alpha
&& alphas[lower + first] == alpha
&& alphas[lower + second] == alpha) {
run(from, till, kSolidSpan, QRgb(alpha * 0x01010101U));
continue;
}
const auto start = middle + column * step;
const auto top = float(alpha);
const auto bottom = float(alphas[lower + first]);
const auto rise = (alphas[upper + second] - top) / step;
const auto fall = (alphas[lower + second] - bottom) / step;
for (auto x = from; x != till; ++x) {
above[x] = top + (x - start) * rise;
below[x] = bottom + (x - start) * fall;
}
run(from, till, kBlendSpan, QRgb());
}
}
void FillStrokeRow(
QRgb *to,
const std::vector<OutlineSpan> &spans,
const float *above,
const float *below,
const OutlineGrid &grid,
int upper,
int lower,
float weight,
int outline) {
const auto step = grid.step;
const auto columns = grid.columns;
const auto middle = (step - 1) / 2.f;
const auto outer = outline + 0.5f;
const auto at = [&](const auto &field, int column) {
const auto top = float(field[upper + column]);
return top + (float(field[lower + column]) - top) * weight;
};
for (const auto [from, till, column, value] : spans) {
if (column == kSolidSpan) {
std::fill(to + from, to + till, value);
continue;
} else if (column == kBlendSpan) {
for (auto x = from; x != till; ++x) {
const auto alpha = above[x] + (below[x] - above[x]) * weight;
to[x] = uint(alpha + 0.5f) * 0x01010101U;
}
continue;
}
const auto first = std::max(column, 0);
const auto second = std::min(column + 1, columns - 1);
const auto left = at(grid.values, first);
const auto slope = (at(grid.values, second) - left) / step;
const auto alpha = at(grid.alphas, first);
const auto change = (at(grid.alphas, second) - alpha) / step;
const auto start = middle + column * step;
for (auto x = from; x != till; ++x) {
const auto distance = left + (x - start) * slope;
const auto coverage = std::clamp(outer - distance, 0.f, 1.f);
const auto mask = (alpha + (x - start) * change) * coverage;
to[x] = uint(mask + 0.5f) * 0x01010101U;
}
}
}
void DrawFrameRow(QRgb *to, const QRgb *from, int width) {
for (auto x = 0; x != width; ++x) {
const auto pixel = from[x];
const auto under = qAlpha(to[x]) * (255 - qAlpha(pixel));
to[x] = pixel + ((under + 127) / 255) * 0x01010101U;
}
}
[[nodiscard]] QImage OutlineStroke(
const OutlineGrid &grid,
const QImage &frame,
int outline) {
const auto step = grid.step;
const auto columns = grid.columns;
const auto rows = grid.rows;
const auto middle = (step - 1) / 2.f;
const auto size = frame.size() + QSize(outline, outline) * 2;
auto starts = std::vector<int>(columns + 2);
for (auto column = 0; column != columns; ++column) {
starts[column + 1] = std::min(
int(std::ceil(middle + column * step)),
size.width());
}
starts[columns + 1] = size.width();
auto spans = std::vector<OutlineSpan>();
auto blend = std::vector<float>(2 * size.width());
const auto above = blend.data();
const auto below = above + size.width();
auto band = -1;
auto result = QImage(size, QImage::Format_ARGB32_Premultiplied);
for (auto y = 0; y != size.height(); ++y) {
const auto position = std::clamp(
(y - middle) / step,
0.f,
float(rows - 1));
const auto top = int(position);
const auto upper = top * columns;
const auto lower = std::min(top + 1, rows - 1) * columns;
if (band != top) {
band = top;
OutlineSpans(
spans,
above,
below,
grid,
starts.data(),
upper,
lower,
outline);
}
const auto to = reinterpret_cast<QRgb*>(result.scanLine(y));
FillStrokeRow(
to,
spans,
above,
below,
grid,
upper,
lower,
position - top,
outline);
if (y >= outline && y < outline + frame.height()) {
DrawFrameRow(
to + outline,
reinterpret_cast<const QRgb*>(
frame.constScanLine(y - outline)),
frame.width());
}
}
return result;
}
[[nodiscard]] QSizeF LogicalSize(const QImage &image) {
return QSizeF(image.size()) / image.devicePixelRatio();
}
[[nodiscard]] float64 EaseOut(float64 progress) {
const auto left = 1. - std::clamp(progress, 0., 1.);
return 1. - left * left;
}
[[nodiscard]] Ui::StarBurstDescriptor LandingBurstDescriptor() {
const auto side = [](float64 sign) {
return Ui::StarBurstSide{
.sign = sign,
.count = 5,
.angle = { -90., 90. },
.reach = { 0.55, 0.85 },
};
};
return {
.sides = { side(-1.), side(1.) },
.delay = kSparkleDelay,
.spread = kSparkleSpread,
.lifeMin = kSparkleLifeMin,
.lifeMax = kSparkleLifeMax,
.size = { 0.05, 0.09 },
.alpha = { 0.6, 1. },
.twinkle = { 0.1, 1.9 },
.appearTill = 0.2,
.fadeAfter = 0.5,
.deformation = 0.1,
};
}
void PaintRing(
QPainter &p,
QPointF center,
float64 side,
crl::time elapsed) {
if (elapsed < kRingDelay || elapsed >= kLandingDuration) {
return;
}
const auto progress = (elapsed - kRingDelay) / float64(kRingDuration);
const auto radius = side * (kRingStartScale + kRingGrowth * progress) / 2.;
const auto opacity = p.opacity();
p.setOpacity(opacity * kRingOpacity * (1. - progress));
p.setPen(QPen(QColor(255, 255, 255), st::walletCardStickerRingWidth));
p.setBrush(Qt::NoBrush);
p.drawEllipse(center, radius, radius);
p.setOpacity(opacity);
}
void PaintSticker(
QPainter &p,
const Data::StoryArea &area,
const QImage &image,
QSize card,
QSizeF size) {
p.save();
p.translate(CardStickerCenter(area, card));
p.rotate(CardStickerRotation(area));
p.drawImage(
QRectF(QPointF(-size.width() / 2., -size.height() / 2.), size),
image);
p.restore();
}
void ClipToCard(QPainter &p, QSize card) {
auto clip = QPainterPath();
clip.addRoundedRect(
QRectF(QPointF(), QSizeF(card)),
st::walletCardRadius,
st::walletCardRadius);
p.setClipPath(clip);
}
void PrepareLayer(QImage &layer, QSize size, int ratio) {
const auto pixels = size * ratio;
if (layer.size() != pixels || layer.devicePixelRatio() != ratio) {
layer = QImage(pixels, QImage::Format_ARGB32_Premultiplied);
layer.setDevicePixelRatio(ratio);
}
layer.fill(Qt::transparent);
}
void PaintLayer(QPainter &p, const CardFold &fold, const QImage &layer) {
if (layer.isNull()) {
return;
}
p.save();
p.setOpacity(fold.opacity);
p.setTransform(fold.transform, true);
p.drawImage(QRectF(fold.rest), layer);
p.restore();
}
} // namespace
struct CardStickers::Entry {
not_null<DocumentData*> document;
Data::WalletCardSticker data;
QString canonical;
std::shared_ptr<Data::DocumentMedia> media;
std::unique_ptr<HistoryView::StickerPlayer> player;
std::optional<StickerPlayback> playback;
QImage image;
int imageSide = 0;
int side = 0;
int ratio = 0;
bool handed = false;
rpl::lifetime loading;
};
struct CardStickers::Landing {
QString address;
QImage frame;
std::unique_ptr<Ui::StarBurst> burst;
crl::time started = 0;
float64 fromScale = 1.;
};
struct CardStickers::Sinking {
QString address;
crl::time started = 0;
};
struct CardStickers::Preview {
QString address;
Data::StoryArea area;
};
void RefreshOwnCard(not_null<Main::Session*> session) {
session->api().requestFullPeer(session->user());
}
auto OwnCardStickersValue(not_null<Main::Session*> session)
-> rpl::producer<std::vector<Data::WalletCardSticker>> {
return session->wallet().ownCard().shownValue(
) | rpl::map([](const OwnCardState &state) {
return state.stickers;
}) | rpl::distinct_until_changed();
}
QImage CardStickerOutlined(QImage frame, int ratio) {
frame = std::move(frame).convertToFormat(
QImage::Format_ARGB32_Premultiplied);
const auto outline = CardStickerOutline(
std::max(frame.width(), frame.height()));
auto grid = OutlineSites(frame, outline);
OutlineDistances(grid, outline);
OutlineAlphas(grid, outline);
auto result = OutlineStroke(grid, frame, outline);
result.setDevicePixelRatio(ratio);
return result;
}
bool TravelArtworkPaused() {
return anim::Disabled() || PowerSaving::On(PowerSaving::kStickersChat);
}
void BindStickerPlayback(StickerPlayback &playback, Fn<void()> repaint) {
const auto raw = &playback;
playback.player->setRepaintCallback([=] {
raw->awaitingFrame = false;
repaint();
});
}
StickerPlaybackStep AdvanceStickerPlayback(
StickerPlayback &playback,
crl::time now) {
const auto player = playback.player.get();
if (!player || playback.awaitingFrame || !player->ready()) {
return {};
}
auto info = player->frame(
playback.frameSize,
QColor(0, 0, 0, 0),
false,
now,
false);
if (info.image.isNull()) {
return {};
} else if (playback.advanced
&& (info.index == 0 || info.index < playback.index)) {
return { .finished = true };
}
auto result = StickerPlaybackStep{ .show = true };
if (playback.frame.isNull() || info.index != playback.index) {
result.fresh = std::move(info.image);
playback.index = info.index;
}
return result;
}
bool PresentStickerPlayback(StickerPlayback &playback) {
const auto player = playback.player.get();
if (player->framesCount() == 1) {
return false;
} else if (player->markFrameShown()) {
playback.advanced = true;
playback.awaitingFrame = true;
}
return true;
}
void StackCardStickers(
std::vector<Data::WalletCardSticker> &stickers,
const std::vector<QString> &stack) {
const auto position = [&](const Data::WalletCardSticker &sticker) {
return ranges::find(stack, CanonicalAddress(sticker.address))
- begin(stack);
};
ranges::stable_sort(stickers, ranges::less(), position);
}
CardStickers::CardStickers(
not_null<Main::Session*> session,
rpl::producer<std::vector<Data::WalletCardSticker>> stickers,
Fn<void()> repaint)
: _session(session)
, _repaint(std::move(repaint))
, _landingAnimation([=](crl::time now) { return landingStep(now); })
, _sinkAnimation([=](crl::time now) { return sinkStep(now); }) {
std::move(
stickers
) | rpl::on_next([=](std::vector<Data::WalletCardSticker> &&list) {
apply(std::move(list));
}, _lifetime);
session->wallet().ownCard().failures(
) | rpl::on_next([=] {
lowerRejected();
}, _lifetime);
}
CardStickers::~CardStickers() = default;
void CardStickers::paint(QPainter &p, const CardFold &fold) {
const auto ratio = style::DevicePixelRatio();
const auto size = fold.rest.size();
if (_layerSize != size || _layerRatio != ratio) {
_layerSize = size;
_layerRatio = ratio;
_layerValid = _aboveValid = false;
}
for (const auto &entry : _entries) {
if (validate(entry.get())) {
_layerValid = _aboveValid = false;
}
}
const auto now = crl::now();
if (!_landings.empty()) {
pruneLandings(now);
}
if (!_landings.empty() || !_sinkings.empty()) {
_aboveValid = false;
}
if (!_layerValid || !_aboveValid) {
compose(now);
}
PaintLayer(p, fold, _layer);
}
void CardStickers::paintAbove(QPainter &p, const CardFold &fold) const {
PaintLayer(p, fold, _above);
}
void CardStickers::hold(const QString &address) {
const auto canonical = CanonicalAddress(address);
if (canonical.isEmpty()) {
return;
}
_holds.emplace(canonical);
dropArrival(canonical);
if (const auto entry = lookup(canonical)) {
entry->playback.reset();
}
invalidate();
refreshArriving();
}
void CardStickers::release(const QString &address) {
const auto canonical = CanonicalAddress(address);
if (_holds.remove(canonical)) {
sink(canonical, crl::now());
invalidate();
refreshArriving();
_releases.fire_copy(canonical);
}
}
void CardStickers::grip(const QString &address) {
const auto canonical = CanonicalAddress(address);
if (canonical.isEmpty() || !_grips.emplace(canonical).second) {
return;
}
raise(canonical);
}
void CardStickers::ungrip(const QString &address) {
const auto canonical = CanonicalAddress(address);
if (_grips.remove(canonical) && _rejectedGrips.remove(canonical)) {
_raised.erase(ranges::remove(_raised, canonical), end(_raised));
invalidate();
}
}
void CardStickers::raise(const QString &address) {
const auto canonical = CanonicalAddress(address);
if (canonical.isEmpty()
|| (!_raised.empty() && _raised.back() == canonical)) {
return;
}
_raised.erase(ranges::remove(_raised, canonical), end(_raised));
_raised.push_back(canonical);
invalidate();
}
void CardStickers::land(
const QString &address,
float64 fromScale,
QImage frame,
TravelArtwork artwork) {
const auto canonical = CanonicalAddress(address);
if (canonical.isEmpty()) {
return;
}
const auto ended = _holds.remove(canonical);
dropArrival(canonical);
const auto entry = lookup(canonical);
if (!anim::Disabled() && entry) {
_landings.push_back({
.address = canonical,
.frame = (frame.isNull()
? artwork.playback.frame
: std::move(frame)),
.burst = Ui::StarBurst::Make(LandingBurstDescriptor()),
.started = crl::now(),
.fromScale = (std::isfinite(fromScale) && fromScale > 0.)
? fromScale
: 1.,
});
if (!_landingAnimation.animating()) {
_landingAnimation.start();
}
}
if (entry) {
adoptArtwork(entry, std::move(artwork));
}
invalidate();
refreshArriving();
if (ended) {
_releases.fire_copy(canonical);
}
}
void CardStickers::preview(
const QString &address,
const Data::StoryArea &area) {
const auto entry = find(address);
const auto &geometry = area.geometry;
const auto finite = std::isfinite(geometry.x()
+ geometry.y()
+ geometry.width()
+ geometry.height()
+ area.rotation);
if (!entry
|| !finite
|| geometry.width() <= 0.
|| geometry.height() <= 0.) {
clearPreview();
return;
}
dropArrival(entry->canonical);
const auto entering = !_preview
|| (_preview->address != entry->canonical);
if (!_preview) {
_preview = std::make_unique<Preview>();
}
_preview->address = entry->canonical;
_preview->area = area;
if (entering) {
invalidate();
} else {
invalidateAbove();
}
refreshArriving();
}
void CardStickers::clearPreview() {
if (const auto preview = base::take(_preview)) {
if (!ranges::contains(_landings, preview->address, &Landing::address)) {
sink(preview->address, crl::now());
}
invalidate();
refreshArriving();
}
}
void CardStickers::play(const QString &address) {
const auto entry = find(address);
if (!entry
|| entry->playback
|| entry->image.isNull()
|| entry->side <= 0
|| !entry->media
|| !entry->media->loaded()
|| _holds.contains(entry->canonical)
|| anim::Disabled()) {
return;
}
const auto sticker = entry->document->sticker();
if (!sticker || !sticker->isAnimated()) {
return;
}
entry->playback = StickerPlayback{
.player = MakePlayer(
entry->document,
entry->media->bytes(),
entry->side,
entry->ratio),
.frameSize = FrameSize(entry->document, entry->side),
.side = entry->side,
};
entry->handed = false;
BindStickerPlayback(*entry->playback, [=] { invalidate(); });
}
void CardStickers::stopPlayback() {
auto stopped = false;
for (const auto &entry : _entries) {
if (entry->playback) {
entry->playback.reset();
stopped = true;
}
}
if (stopped) {
invalidate();
}
}
bool CardStickers::shown(const QString &address) const {
const auto entry = find(address);
return entry
&& (entry->side > 0)
&& !entry->image.isNull()
&& !_holds.contains(entry->canonical);
}
bool CardStickers::held(const QString &address) const {
return _holds.contains(CanonicalAddress(address));
}
QImage CardStickers::image(const QString &address) const {
const auto entry = find(address);
if (!entry) {
return QImage();
} else if (entry->playback && !entry->playback->frame.isNull()) {
return entry->playback->frame;
}
return entry->image;
}
std::vector<QString> CardStickers::stack() const {
auto result = std::vector<QString>();
for (const auto &entry : ordered()) {
result.push_back(entry->canonical);
}
return result;
}
const QImage &CardStickers::settledLayer() const {
return _layer;
}
rpl::producer<bool> CardStickers::arrivingValue() const {
return _arriving.value();
}
rpl::producer<QString> CardStickers::releases() const {
return _releases.events();
}
void CardStickers::apply(std::vector<Data::WalletCardSticker> &&stickers) {
auto was = base::take(_entries);
for (auto &sticker : stickers) {
if (!sticker.gift) {
continue;
}
const auto document = sticker.gift->document;
const auto canonical = CanonicalAddress(sticker.address);
const auto i = ranges::find_if(was, [&](const auto &entry) {
return entry
&& (entry->document == document)
&& (entry->canonical == canonical);
});
auto entry = (i != end(was))
? std::move(*i)
: std::make_unique<Entry>(Entry{ .document = document });
entry->data = std::move(sticker);
entry->canonical = canonical;
_entries.push_back(std::move(entry));
}
_landings.erase(ranges::remove_if(_landings, [&](const Landing &landing) {
return !lookup(landing.address);
}), end(_landings));
_sinkings.erase(ranges::remove_if(_sinkings, [&](const Sinking &sinking) {
return !lookup(sinking.address);
}), end(_sinkings));
_raised.erase(ranges::remove_if(_raised, [&](const QString &canonical) {
return !lookup(canonical) && !_holds.contains(canonical);
}), end(_raised));
if (_preview && !lookup(_preview->address)) {
_preview = nullptr;
refreshArriving();
}
invalidate();
}
std::vector<not_null<CardStickers::Entry*>> CardStickers::ordered() const {
auto result = std::vector<not_null<Entry*>>();
result.reserve(_entries.size());
for (const auto &entry : _entries) {
if (!ranges::contains(_raised, entry->canonical)) {
result.push_back(entry.get());
}
}
for (const auto &canonical : _raised) {
if (const auto entry = lookup(canonical)) {
result.push_back(entry);
}
}
return result;
}
void CardStickers::lowerRejected() {
_raised.erase(ranges::remove_if(_raised, [&](const QString &canonical) {
return !_grips.contains(canonical);
}), end(_raised));
_rejectedGrips = _grips;
invalidate();
}
bool CardStickers::validate(not_null<Entry*> entry) {
auto changed = false;
const auto side = CardStickerSide(entry->data.area, _layerSize);
if (entry->side != side || entry->ratio != _layerRatio) {
changed = !entry->image.isNull();
prepare(entry, side);
}
if (entry->player && entry->player->ready()) {
capture(entry);
changed = changed || !entry->image.isNull();
}
return changed;
}
void CardStickers::prepare(not_null<Entry*> entry, int side) {
entry->loading.destroy();
entry->player = nullptr;
if (!entry->handed) {
entry->playback.reset();
}
entry->side = side;
entry->ratio = _layerRatio;
if (!side) {
return;
} else if (!entry->media) {
entry->media = entry->document->createMediaView();
}
entry->media->checkStickerLarge();
if (entry->media->loaded()) {
createPlayer(entry);
return;
}
_session->downloaderTaskFinished(
) | rpl::filter([=] {
return entry->media->loaded();
}) | rpl::take(1) | rpl::on_next([=] {
createPlayer(entry);
}, entry->loading);
}
void CardStickers::createPlayer(not_null<Entry*> entry) {
entry->player = MakePlayer(
entry->document,
entry->media->bytes(),
entry->side,
entry->ratio);
entry->player->setRepaintCallback(_repaint);
}
void CardStickers::capture(not_null<Entry*> entry) {
auto frame = entry->player->frame(
FrameSize(entry->document, entry->side),
QColor(0, 0, 0, 0),
false,
crl::now(),
true).image;
entry->player = nullptr;
if (!frame.isNull()) {
entry->image = CardStickerOutlined(std::move(frame), entry->ratio);
entry->imageSide = entry->side;
}
}
void CardStickers::adoptArtwork(
not_null<Entry*> entry,
TravelArtwork &&artwork) {
auto &playback = artwork.playback;
if (artwork.document != entry->document || playback.side <= 0) {
return;
} else if (validate(entry)) {
_layerValid = _aboveValid = false;
}
if (entry->image.isNull() && !artwork.rest.isNull()) {
entry->image = std::move(artwork.rest);
entry->imageSide = playback.side;
}
if (!playback.player
|| playback.frameSize.isEmpty()
|| TravelArtworkPaused()) {
return;
}
entry->playback = std::move(playback);
entry->handed = true;
BindStickerPlayback(*entry->playback, [=] { invalidate(); });
}
void CardStickers::compose(crl::time now) {
const auto below = !_layerValid;
const auto above = !_aboveValid;
_layerValid = _aboveValid = true;
struct Lifted {
not_null<Entry*> entry;
const Landing *landing = nullptr;
float64 cover = 0.;
};
auto lower = std::vector<not_null<Entry*>>();
auto upper = std::vector<Lifted>();
auto shown = false;
if (!_layerSize.isEmpty()) {
for (const auto &entry : ordered()) {
if (_holds.contains(entry->canonical)) {
continue;
}
const auto landing = ranges::find(
_landings,
entry->canonical,
&Landing::address);
const auto previewed = _preview
&& (_preview->address == entry->canonical);
if (previewed || landing != end(_landings)) {
upper.push_back({
.entry = entry,
.landing = previewed ? nullptr : &*landing,
});
continue;
}
lower.push_back(entry);
shown = shown || !entry->image.isNull();
const auto cover = sinkCover(entry->canonical, now);
if (cover > 0.) {
upper.push_back({ .entry = entry, .cover = cover });
}
}
}
if (below && !shown) {
_layer = QImage();
} else if (below) {
PrepareLayer(_layer, _layerSize, _layerRatio);
auto p = QPainter(&_layer);
auto hq = PainterHighQualityEnabler(p);
ClipToCard(p, _layerSize);
for (const auto &entry : lower) {
const auto playing = advance(entry, now);
paintArt(p, entry, entry->data.area, 1.);
if (playing) {
presented(entry);
}
}
}
if (above && upper.empty()) {
_above = QImage();
} else if (above) {
PrepareLayer(_above, _layerSize, _layerRatio);
auto p = QPainter(&_above);
auto hq = PainterHighQualityEnabler(p);
ClipToCard(p, _layerSize);
for (const auto &lifted : upper) {
const auto entry = lifted.entry;
if (lifted.cover > 0.) {
// WHY: a sinking gift is also in the lower layer, so this
// copy fades out to fade the card data in over it, with the
// frame that layer drew.
p.setOpacity(lifted.cover);
paintArt(p, entry, entry->data.area, 1.);
p.setOpacity(1.);
continue;
}
const auto playing = advance(entry, now);
if (lifted.landing) {
paintLanding(p, entry, *lifted.landing, now);
} else {
paintArt(p, entry, _preview->area, 1.);
}
if (playing) {
presented(entry);
}
}
}
}
bool CardStickers::advance(not_null<Entry*> entry, crl::time now) {
if (!entry->playback) {
return false;
} else if (entry->handed ? TravelArtworkPaused() : anim::Disabled()) {
entry->playback.reset();
return false;
}
auto &playback = *entry->playback;
auto step = AdvanceStickerPlayback(playback, now);
if (step.finished) {
entry->playback.reset();
return false;
} else if (!step.fresh.isNull()) {
playback.frame = CardStickerOutlined(
std::move(step.fresh),
entry->ratio);
}
return step.show;
}
void CardStickers::presented(not_null<Entry*> entry) {
if (!PresentStickerPlayback(*entry->playback)) {
entry->playback.reset();
}
}
bool CardStickers::paintArt(
QPainter &p,
not_null<const Entry*> entry,
const Data::StoryArea &area,
float64 scale) const {
const auto playing = entry->playback
&& !entry->playback->frame.isNull();
const auto &image = playing ? entry->playback->frame : entry->image;
const auto from = playing ? entry->playback->side : entry->imageSide;
const auto side = CardStickerSide(area, _layerSize);
if (image.isNull() || from <= 0 || side <= 0) {
return false;
}
const auto size = LogicalSize(image) * (scale * side / float64(from));
PaintSticker(p, area, image, _layerSize, size);
return true;
}
void CardStickers::paintLanding(
QPainter &p,
not_null<const Entry*> entry,
const Landing &landing,
crl::time now) const {
const auto side = float64(entry->side);
if (side <= 0.) {
return;
}
const auto &area = entry->data.area;
const auto center = CardStickerCenter(area, _layerSize);
const auto elapsed = now - landing.started;
PaintRing(p, center, side, elapsed);
if (landing.burst) {
landing.burst->paint(p, {
.origin = center,
.extent = side,
.elapsed = elapsed,
});
}
const auto settle = EaseOut(elapsed / float64(kSettleDuration));
const auto scale = 1. + (landing.fromScale - 1.) * (1. - settle);
if (!paintArt(p, entry, area, scale) && !landing.frame.isNull()) {
const auto size = QSizeF(landing.frame.size()).scaled(
QSizeF(side, side),
Qt::KeepAspectRatio) * scale;
PaintSticker(p, area, landing.frame, _layerSize, size);
}
}
CardStickers::Entry *CardStickers::find(const QString &address) const {
const auto canonical = CanonicalAddress(address);
return canonical.isEmpty() ? nullptr : lookup(canonical);
}
CardStickers::Entry *CardStickers::lookup(const QString &canonical) const {
const auto i = ranges::find(
_entries,
canonical,
&Entry::canonical);
return (i != end(_entries)) ? i->get() : nullptr;
}
void CardStickers::dropArrival(const QString &canonical) {
_landings.erase(
ranges::remove(_landings, canonical, &Landing::address),
end(_landings));
_sinkings.erase(
ranges::remove(_sinkings, canonical, &Sinking::address),
end(_sinkings));
}
void CardStickers::pruneLandings(crl::time now) {
const auto disabled = anim::Disabled();
const auto was = _landings.size();
auto finished = std::vector<QString>();
_landings.erase(ranges::remove_if(_landings, [&](const Landing &landing) {
if (disabled) {
return true;
} else if (now - landing.started < kLandingDuration) {
return false;
}
const auto entry = lookup(landing.address);
const auto ended = !entry
|| !entry->image.isNull()
|| landing.frame.isNull();
if (ended) {
finished.push_back(landing.address);
}
return ended;
}), end(_landings));
if (_landings.size() != was) {
_layerValid = _aboveValid = false;
}
for (const auto &address : finished) {
sink(address, now);
}
}
bool CardStickers::landingStep(crl::time now) {
pruneLandings(now);
invalidateAbove();
const auto active = ranges::any_of(_landings, [&](const Landing &landing) {
return now - landing.started < kLandingDuration;
});
if (!active) {
_landingAnimation.stop();
}
refreshArriving();
return active;
}
void CardStickers::sink(const QString &canonical, crl::time now) {
const auto entry = lookup(canonical);
if (!entry || entry->image.isNull() || anim::Disabled()) {
return;
}
_sinkings.erase(
ranges::remove(_sinkings, canonical, &Sinking::address),
end(_sinkings));
_sinkings.push_back({ .address = canonical, .started = now });
_aboveValid = false;
if (!_sinkAnimation.animating()) {
_sinkAnimation.start();
}
}
float64 CardStickers::sinkCover(
const QString &canonical,
crl::time now) const {
const auto i = ranges::find(_sinkings, canonical, &Sinking::address);
if (i == end(_sinkings)) {
return 0.;
}
const auto progress = (now - i->started) / float64(kSinkDuration);
return 1. - anim::sineInOut(1., std::clamp(progress, 0., 1.));
}
void CardStickers::pruneSinkings(crl::time now) {
const auto disabled = anim::Disabled();
const auto was = _sinkings.size();
const auto finished = [&](const Sinking &sinking) {
return disabled
|| (now - sinking.started >= kSinkDuration)
|| !lookup(sinking.address);
};
_sinkings.erase(
ranges::remove_if(_sinkings, finished),
end(_sinkings));
if (_sinkings.size() != was) {
_aboveValid = false;
}
}
bool CardStickers::sinkStep(crl::time now) {
pruneSinkings(now);
invalidateAbove();
if (_sinkings.empty()) {
_sinkAnimation.stop();
return false;
}
return true;
}
void CardStickers::refreshArriving() {
_arriving = _landingAnimation.animating()
|| !_holds.empty()
|| (_preview != nullptr);
}
void CardStickers::invalidate() {
_layerValid = _aboveValid = false;
_repaint();
}
void CardStickers::invalidateAbove() {
_aboveValid = false;
_repaint();
}
} // namespace Wallet