ZaStoGram_desktop/Telegram/SourceFiles/tgw/tgw_emoji_images.cpp
John Preston 7b7593dd57 Draw widget text emoji from the app's own emoji set
Task: 2026/10/26/draw-emoji-in-widget-text-from-the-apps-own-emoji-set
2026-11-05 17:12:55 +04:00

241 lines
5.7 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 "tgw/tgw_emoji_images.h"
#include "chat_helpers/stickers_emoji_image_loader.h"
#include "core/application.h"
#include "ui/emoji_config.h"
#include "styles/style_chat.h"
namespace Tgw {
namespace {
constexpr auto kMaxTileBytes = int64(8 * 1024 * 1024);
constexpr auto kMaxIsolatedBytes = int64(16 * 1024 * 1024);
constexpr auto kPixelBytes = 4;
class EmojiImages final : public base::has_weak_ptr {
public:
EmojiImages();
void paint(
QPainter &p,
EmojiPtr emoji,
const QRectF &box,
float64 deviceSide);
[[nodiscard]] rpl::producer<> refreshes() const;
private:
struct TileKey {
int index = 0;
int side = 0;
friend inline constexpr auto operator<=>(TileKey, TileKey) = default;
};
struct Tile {
QImage image;
uint64 used = 0;
};
struct Isolated {
QImage image;
bool pending = false;
};
[[nodiscard]] QImage tile(EmojiPtr emoji, int side);
[[nodiscard]] QImage isolated(EmojiPtr emoji);
[[nodiscard]] bool request(EmojiPtr emoji);
void insertTile(TileKey key, const QImage &image);
void landed(
EmojiPtr emoji,
uint64 generation,
int64 reserved,
QImage image);
void reset();
void requestRefresh();
base::flat_map<TileKey, Tile> _tiles;
base::flat_map<int, Isolated> _isolated;
rpl::event_stream<> _refreshes;
rpl::lifetime _lifetime;
uint64 _generation = 0;
uint64 _lastUse = 0;
int64 _tileBytes = 0;
int64 _readyBytes = 0;
int64 _reservedBytes = 0;
bool _refreshPosted = false;
};
[[nodiscard]] int64 ImageBytes(QSize size) {
return int64(size.width()) * size.height() * kPixelBytes;
}
[[nodiscard]] QImage DrawTile(EmojiPtr emoji, int side) {
auto result = QImage(
QSize(side, side),
QImage::Format_ARGB32_Premultiplied);
// WHY: Ui::Emoji::Draw scales its sprites by the app's ratio but its
// fallback by the target's; widget layers have ratio 1, so a tile at
// the app's ratio keeps both paths at the tier's exact size.
result.setDevicePixelRatio(style::DevicePixelRatio());
result.fill(Qt::transparent);
auto p = QPainter(&result);
Ui::Emoji::Draw(p, emoji, side, 0, 0);
p.end();
return result;
}
[[nodiscard]] EmojiImages &Images() {
static auto result = EmojiImages();
return result;
}
EmojiImages::EmojiImages() {
Ui::Emoji::Updated() | rpl::on_next([=] {
reset();
}, _lifetime);
}
void EmojiImages::paint(
QPainter &p,
EmojiPtr emoji,
const QRectF &box,
float64 deviceSide) {
const auto normal = Ui::Emoji::GetSizeNormal();
const auto large = Ui::Emoji::GetSizeLarge();
const auto image = (deviceSide <= normal)
? tile(emoji, normal)
: (deviceSide <= large)
? tile(emoji, large)
: isolated(emoji);
p.drawImage(box, image);
}
rpl::producer<> EmojiImages::refreshes() const {
return _refreshes.events();
}
QImage EmojiImages::tile(EmojiPtr emoji, int side) {
const auto key = TileKey{ emoji->index(), side };
const auto i = _tiles.find(key);
if (i != end(_tiles)) {
i->second.used = ++_lastUse;
return i->second.image;
}
const auto generation = _generation;
auto result = DrawTile(emoji, side);
if (generation == _generation) {
insertTile(key, result);
}
return result;
}
QImage EmojiImages::isolated(EmojiPtr emoji) {
const auto index = emoji->index();
const auto i = _isolated.find(index);
if (i == end(_isolated)) {
_isolated.emplace(index, Isolated{ .pending = request(emoji) });
} else if (!i->second.image.isNull()) {
return i->second.image;
}
return tile(emoji, Ui::Emoji::GetSizeLarge());
}
bool EmojiImages::request(EmojiPtr emoji) {
const auto side = st::largeEmojiSize * style::DevicePixelRatio();
const auto reserved = ImageBytes(QSize(side, side));
if (_readyBytes + _reservedBytes + reserved > kMaxIsolatedBytes) {
return false;
}
_reservedBytes += reserved;
const auto weak = base::make_weak(this);
const auto generation = _generation;
Core::App().emojiImageLoader().with([=](
const Stickers::EmojiImageLoader &loader) {
crl::on_main(weak, [
=,
image = loader.prepareWithoutOutline(emoji)
]() mutable {
landed(emoji, generation, reserved, std::move(image));
});
});
return true;
}
void EmojiImages::insertTile(TileKey key, const QImage &image) {
const auto bytes = ImageBytes(image.size());
while (!_tiles.empty() && (_tileBytes + bytes > kMaxTileBytes)) {
const auto oldest = ranges::min_element(
_tiles,
ranges::less(),
[](const auto &entry) { return entry.second.used; });
_tileBytes -= ImageBytes(oldest->second.image.size());
_tiles.erase(oldest);
}
_tiles.emplace(key, Tile{ image, ++_lastUse });
_tileBytes += bytes;
}
void EmojiImages::landed(
EmojiPtr emoji,
uint64 generation,
int64 reserved,
QImage image) {
_reservedBytes -= reserved;
if (generation != _generation) {
return;
}
const auto i = _isolated.find(emoji->index());
if (i == end(_isolated) || !i->second.pending) {
return;
}
i->second.pending = false;
const auto bytes = ImageBytes(image.size());
if (!image.isNull() && bytes <= reserved) {
i->second.image = std::move(image);
_readyBytes += bytes;
}
requestRefresh();
}
void EmojiImages::reset() {
_tiles.clear();
_isolated.clear();
_tileBytes = 0;
_readyBytes = 0;
++_generation;
requestRefresh();
}
void EmojiImages::requestRefresh() {
if (_refreshPosted) {
return;
}
_refreshPosted = true;
crl::on_main(this, [=] {
_refreshPosted = false;
_refreshes.fire({});
});
}
} // namespace
void PaintEmoji(
QPainter &p,
EmojiPtr emoji,
const QRectF &box,
float64 deviceSide) {
Images().paint(p, emoji, box, deviceSide);
}
rpl::producer<> EmojiRefreshes() {
return Images().refreshes();
}
} // namespace Tgw