tdesktop/Telegram/SourceFiles/settings/settings_premium.cpp

1745 lines
47 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 "settings/settings_premium.h"
#include "boxes/premium_preview_box.h"
#include "boxes/sticker_set_box.h"
#include "chat_helpers/stickers_lottie.h" // LottiePlayerFromDocument.
#include "core/application.h"
#include "core/click_handler_types.h"
#include "core/local_url_handlers.h" // Core::TryConvertUrlToLocal.
#include "core/ui_integration.h" // MarkedTextContext.
#include "data/data_document.h"
#include "data/data_document_media.h"
#include "data/data_peer_values.h"
#include "data/data_session.h"
#include "data/stickers/data_custom_emoji.h" // SerializeCustomEmojiId.
#include "data/stickers/data_stickers.h"
#include "history/view/media/history_view_sticker.h" // EmojiSize.
#include "history/view/media/history_view_sticker_player.h"
#include "info/info_wrap_widget.h" // Info::Wrap.
#include "info/profile/info_profile_values.h"
#include "info/settings/info_settings_widget.h" // SectionCustomTopBarData.
#include "lang/lang_keys.h"
#include "main/main_account.h"
#include "main/main_app_config.h"
#include "main/main_session.h"
#include "settings/settings_common_session.h"
#include "ui/abstract_button.h"
#include "ui/basic_click_handlers.h"
#include "ui/effects/gradient.h"
#include "ui/effects/premium_graphics.h"
#include "ui/effects/premium_stars_colored.h"
#include "ui/effects/premium_top_bar.h"
#include "ui/layers/generic_box.h"
#include "ui/text/format_values.h"
#include "ui/text/text_utilities.h"
#include "ui/toast/toast.h"
#include "ui/widgets/checkbox.h" // Ui::RadiobuttonGroup.
#include "ui/widgets/gradient_round_button.h"
#include "ui/widgets/labels.h"
#include "ui/wrap/fade_wrap.h"
#include "ui/wrap/padding_wrap.h"
#include "ui/wrap/slide_wrap.h"
#include "ui/wrap/vertical_layout.h"
#include "ui/new_badges.h"
#include "ui/painter.h"
#include "ui/power_saving.h"
#include "ui/vertical_list.h"
#include "window/window_controller.h"
#include "window/window_session_controller.h"
#include "window/window_session_controller_link_info.h"
#include "base/unixtime.h"
#include "apiwrap.h"
#include "api/api_premium.h"
#include "styles/style_chat_helpers.h"
#include "styles/style_premium.h"
#include "styles/style_info.h"
#include "styles/style_layers.h"
#include "styles/style_settings.h"
namespace Settings {
namespace {
using SectionCustomTopBarData = Info::Settings::SectionCustomTopBarData;
[[nodiscard]] Data::SubscriptionOptions SubscriptionOptionsForRows(
Data::SubscriptionOptions result) {
for (auto &option : result) {
const auto total = option.costTotal;
const auto perMonth = option.costPerMonth;
option.costTotal = tr::lng_premium_gift_per(
tr::now,
lt_cost,
perMonth);
option.costPerMonth = tr::lng_premium_subscribe_total(
tr::now,
lt_cost,
total);
if (option.duration == tr::lng_months(tr::now, lt_count, 1)) {
option.costPerMonth = QString();
option.duration = tr::lng_premium_subscribe_months_1(tr::now);
} else if (option.duration == tr::lng_months(tr::now, lt_count, 6)) {
option.duration = tr::lng_premium_subscribe_months_6(tr::now);
} else if (option.duration == tr::lng_years(tr::now, lt_count, 1)) {
option.duration = tr::lng_premium_subscribe_months_12(tr::now);
}
}
return result;
}
[[nodiscard]] int TopTransitionSkip() {
return (st::settingsButton.padding.top()
+ st::settingsPremiumRowTitlePadding.top()) / 2;
}
namespace Ref {
namespace Gift {
struct Data {
PeerId peerId;
int months = 0;
bool me = false;
explicit operator bool() const {
return peerId != 0;
}
};
[[nodiscard]] QString Serialize(const Data &gift) {
return QString::number(gift.peerId.value)
+ ':'
+ QString::number(gift.months)
+ ':'
+ QString::number(gift.me ? 1 : 0);
}
[[nodiscard]] Data Parse(QStringView data) {
const auto components = data.split(':');
if (components.size() != 3) {
return {};
}
return {
.peerId = PeerId(components[0].toULongLong()),
.months = components[1].toInt(),
.me = (components[2].toInt() == 1),
};
}
} // namespace Gift
namespace EmojiStatus {
struct Data {
PeerId peerId;
explicit operator bool() const {
return peerId != 0;
}
};
[[nodiscard]] QString Serialize(const Data &gift) {
return QString("profile_:%1").arg(QString::number(gift.peerId.value));
}
[[nodiscard]] Data Parse(QStringView data) {
if (data.startsWith(u"profile_:"_q)) {
const auto components = data.split(':');
if (components.size() != 2) {
return {};
}
return {
.peerId = PeerId(components[1].toULongLong()),
};
}
return {};
}
} // namespace EmojiStatus
} // namespace Ref
struct Entry {
const style::icon *icon;
rpl::producer<QString> title;
rpl::producer<QString> description;
PremiumFeature section = PremiumFeature::DoubleLimits;
bool newBadge = false;
};
using Order = std::vector<QString>;
[[nodiscard]] Order FallbackOrder() {
return Order{
u"stories"_q,
u"more_upload"_q,
u"double_limits"_q,
u"last_seen"_q,
u"voice_to_text"_q,
u"faster_download"_q,
u"translations"_q,
u"animated_emoji"_q,
u"emoji_status"_q,
u"saved_tags"_q,
//u"peer_colors"_q,
u"wallpapers"_q,
u"profile_badge"_q,
u"message_privacy"_q,
u"advanced_chat_management"_q,
u"no_ads"_q,
//u"app_icons"_q,
u"infinite_reactions"_q,
u"animated_userpics"_q,
u"premium_stickers"_q,
u"business"_q,
};
}
[[nodiscard]] base::flat_map<QString, Entry> EntryMap() {
return base::flat_map<QString, Entry>{
{
u"saved_tags"_q,
Entry{
&st::settingsPremiumIconTags,
tr::lng_premium_summary_subtitle_tags_for_messages(),
tr::lng_premium_summary_about_tags_for_messages(),
PremiumFeature::TagsForMessages,
true,
},
},
{
u"last_seen"_q,
Entry{
&st::settingsPremiumIconLastSeen,
tr::lng_premium_summary_subtitle_last_seen(),
tr::lng_premium_summary_about_last_seen(),
PremiumFeature::LastSeen,
true,
},
},
{
u"message_privacy"_q,
Entry{
&st::settingsPremiumIconPrivacy,
tr::lng_premium_summary_subtitle_message_privacy(),
tr::lng_premium_summary_about_message_privacy(),
PremiumFeature::MessagePrivacy,
true,
},
},
{
u"wallpapers"_q,
Entry{
&st::settingsPremiumIconWallpapers,
tr::lng_premium_summary_subtitle_wallpapers(),
tr::lng_premium_summary_about_wallpapers(),
PremiumFeature::Wallpapers,
},
},
{
u"stories"_q,
Entry{
&st::settingsPremiumIconStories,
tr::lng_premium_summary_subtitle_stories(),
tr::lng_premium_summary_about_stories(),
PremiumFeature::Stories,
},
},
{
u"double_limits"_q,
Entry{
&st::settingsPremiumIconDouble,
tr::lng_premium_summary_subtitle_double_limits(),
tr::lng_premium_summary_about_double_limits(),
PremiumFeature::DoubleLimits,
},
},
{
u"more_upload"_q,
Entry{
&st::settingsPremiumIconFiles,
tr::lng_premium_summary_subtitle_more_upload(),
tr::lng_premium_summary_about_more_upload(),
PremiumFeature::MoreUpload,
},
},
{
u"faster_download"_q,
Entry{
&st::settingsPremiumIconSpeed,
tr::lng_premium_summary_subtitle_faster_download(),
tr::lng_premium_summary_about_faster_download(),
PremiumFeature::FasterDownload,
},
},
{
u"voice_to_text"_q,
Entry{
&st::settingsPremiumIconVoice,
tr::lng_premium_summary_subtitle_voice_to_text(),
tr::lng_premium_summary_about_voice_to_text(),
PremiumFeature::VoiceToText,
},
},
{
u"no_ads"_q,
Entry{
&st::settingsPremiumIconChannelsOff,
tr::lng_premium_summary_subtitle_no_ads(),
tr::lng_premium_summary_about_no_ads(),
PremiumFeature::NoAds,
},
},
{
u"emoji_status"_q,
Entry{
&st::settingsPremiumIconStatus,
tr::lng_premium_summary_subtitle_emoji_status(),
tr::lng_premium_summary_about_emoji_status(),
PremiumFeature::EmojiStatus,
},
},
{
u"infinite_reactions"_q,
Entry{
&st::settingsPremiumIconLike,
tr::lng_premium_summary_subtitle_infinite_reactions(),
tr::lng_premium_summary_about_infinite_reactions(),
PremiumFeature::InfiniteReactions,
},
},
{
u"premium_stickers"_q,
Entry{
&st::settingsIconStickers,
tr::lng_premium_summary_subtitle_premium_stickers(),
tr::lng_premium_summary_about_premium_stickers(),
PremiumFeature::Stickers,
},
},
{
u"animated_emoji"_q,
Entry{
&st::settingsIconEmoji,
tr::lng_premium_summary_subtitle_animated_emoji(),
tr::lng_premium_summary_about_animated_emoji(),
PremiumFeature::AnimatedEmoji,
},
},
{
u"advanced_chat_management"_q,
Entry{
&st::settingsIconChat,
tr::lng_premium_summary_subtitle_advanced_chat_management(),
tr::lng_premium_summary_about_advanced_chat_management(),
PremiumFeature::AdvancedChatManagement,
},
},
{
u"profile_badge"_q,
Entry{
&st::settingsPremiumIconStar,
tr::lng_premium_summary_subtitle_profile_badge(),
tr::lng_premium_summary_about_profile_badge(),
PremiumFeature::ProfileBadge,
},
},
{
u"animated_userpics"_q,
Entry{
&st::settingsPremiumIconPlay,
tr::lng_premium_summary_subtitle_animated_userpics(),
tr::lng_premium_summary_about_animated_userpics(),
PremiumFeature::AnimatedUserpics,
},
},
{
u"translations"_q,
Entry{
&st::settingsPremiumIconTranslations,
tr::lng_premium_summary_subtitle_translation(),
tr::lng_premium_summary_about_translation(),
PremiumFeature::RealTimeTranslation,
},
},
{
u"business"_q,
Entry{
&st::settingsPremiumIconBusiness,
tr::lng_premium_summary_subtitle_business(),
tr::lng_premium_summary_about_business(),
PremiumFeature::Business,
true,
},
},
};
}
void SendAppLog(
not_null<Main::Session*> session,
const QString &type,
const MTPJSONValue &data) {
const auto now = double(base::unixtime::now())
+ (QTime::currentTime().msec() / 1000.);
session->api().request(MTPhelp_SaveAppLog(
MTP_vector<MTPInputAppEvent>(1, MTP_inputAppEvent(
MTP_double(now),
MTP_string(type),
MTP_long(0),
data
))
)).send();
}
[[nodiscard]] QString ResolveRef(const QString &ref) {
return ref.isEmpty() ? "settings" : ref;
}
void SendScreenShow(
not_null<Window::SessionController*> controller,
const std::vector<QString> &order,
const QString &ref) {
auto list = QVector<MTPJSONValue>();
list.reserve(order.size());
for (const auto &element : order) {
list.push_back(MTP_jsonString(MTP_string(element)));
}
auto values = QVector<MTPJSONObjectValue>{
MTP_jsonObjectValue(
MTP_string("premium_promo_order"),
MTP_jsonArray(MTP_vector<MTPJSONValue>(std::move(list)))),
MTP_jsonObjectValue(
MTP_string("source"),
MTP_jsonString(MTP_string(ResolveRef(ref)))),
};
const auto data = MTP_jsonObject(
MTP_vector<MTPJSONObjectValue>(std::move(values)));
SendAppLog(
&controller->session(),
"premium.promo_screen_show",
data);
}
void SendScreenAccept(not_null<Window::SessionController*> controller) {
SendAppLog(
&controller->session(),
"premium.promo_screen_accept",
MTP_jsonNull());
}
class EmojiStatusTopBar final {
public:
EmojiStatusTopBar(
not_null<DocumentData*> document,
Fn<void(QRect)> callback,
QSizeF size);
void setCenter(QPointF position);
void setPaused(bool paused);
void paint(QPainter &p);
private:
QRectF _rect;
std::shared_ptr<Data::DocumentMedia> _media;
std::unique_ptr<HistoryView::StickerPlayer> _player;
bool _paused = false;
rpl::lifetime _lifetime;
};
EmojiStatusTopBar::EmojiStatusTopBar(
not_null<DocumentData*> document,
Fn<void(QRect)> callback,
QSizeF size)
: _rect(QPointF(), size) {
const auto sticker = document->sticker();
Assert(sticker != nullptr);
_media = document->createMediaView();
_media->checkStickerLarge();
_media->goodThumbnailWanted();
rpl::single() | rpl::then(
document->owner().session().downloaderTaskFinished()
) | rpl::start_with_next([=] {
if (!_media->loaded()) {
return;
}
_lifetime.destroy();
if (sticker->isLottie()) {
_player = std::make_unique<HistoryView::LottiePlayer>(
ChatHelpers::LottiePlayerFromDocument(
_media.get(),
ChatHelpers::StickerLottieSize::EmojiInteractionReserved7, //
size.toSize(),
Lottie::Quality::High));
} else if (sticker->isWebm()) {
_player = std::make_unique<HistoryView::WebmPlayer>(
_media->owner()->location(),
_media->bytes(),
size.toSize());
} else if (sticker) {
_player = std::make_unique<HistoryView::StaticStickerPlayer>(
_media->owner()->location(),
_media->bytes(),
size.toSize());
}
if (_player) {
_player->setRepaintCallback([=] { callback(_rect.toRect()); });
} else {
callback(_rect.toRect());
}
}, _lifetime);
}
void EmojiStatusTopBar::setCenter(QPointF position) {
const auto size = _rect.size();
const auto shift = QPointF(size.width() / 2., size.height() / 2.);
_rect = QRectF(QPointF(position - shift), QPointF(position + shift));
}
void EmojiStatusTopBar::setPaused(bool paused) {
_paused = paused;
}
void EmojiStatusTopBar::paint(QPainter &p) {
if (_player && _player->ready()) {
const auto frame = _player->frame(
_rect.size().toSize(),
(_media->owner()->emojiUsesTextColor()
? st::profileVerifiedCheckBg->c
: QColor(0, 0, 0, 0)),
false,
crl::now(),
_paused || On(PowerSaving::kEmojiStatus));
p.drawImage(_rect.toRect(), frame.image);
if (!_paused) {
_player->markFrameShown();
}
}
}
class TopBarUser final : public Ui::Premium::TopBarAbstract {
public:
TopBarUser(
not_null<QWidget*> parent,
not_null<Window::SessionController*> controller,
not_null<PeerData*> peer,
rpl::producer<> showFinished);
void setPaused(bool paused) override;
void setTextPosition(int x, int y) override;
rpl::producer<int> additionalHeight() const override;
protected:
void paintEvent(QPaintEvent *e) override;
void resizeEvent(QResizeEvent *e) override;
private:
void updateTitle(
DocumentData *document,
TextWithEntities name,
not_null<Window::SessionController*> controller);
void updateAbout(DocumentData *document) const;
object_ptr<Ui::RpWidget> _content;
object_ptr<Ui::FlatLabel> _title;
object_ptr<Ui::FlatLabel> _about;
Ui::Premium::ColoredMiniStars _ministars;
struct {
object_ptr<Ui::RpWidget> widget;
Ui::Text::String text;
Ui::Animations::Simple animation;
bool shown = false;
QPoint position;
} _smallTop;
std::unique_ptr<EmojiStatusTopBar> _emojiStatus;
QImage _imageStar;
QRectF _starRect;
};
TopBarUser::TopBarUser(
not_null<QWidget*> parent,
not_null<Window::SessionController*> controller,
not_null<PeerData*> peer,
rpl::producer<> showFinished)
: TopBarAbstract(parent, st::userPremiumCover)
, _content(this)
, _title(_content, st::settingsPremiumUserTitle)
, _about(_content, st::userPremiumCover.about)
, _ministars(_content, true)
, _smallTop({
.widget = object_ptr<Ui::RpWidget>(this),
.text = Ui::Text::String(
st::boxTitle.style,
tr::lng_premium_summary_title(tr::now)),
}) {
_starRect = TopBarAbstract::starRect(1., 1.);
rpl::single() | rpl::then(
style::PaletteChanged()
) | rpl::start_with_next([=] {
TopBarAbstract::computeIsDark();
update();
}, lifetime());
auto documentValue = Info::Profile::EmojiStatusIdValue(
peer
) | rpl::map([=](DocumentId id) -> DocumentData* {
const auto document = id
? controller->session().data().document(id).get()
: nullptr;
return (document && document->sticker()) ? document : nullptr;
});
rpl::combine(
std::move(documentValue),
Info::Profile::NameValue(peer)
) | rpl::start_with_next([=](
DocumentData *document,
const QString &name) {
if (document) {
_emojiStatus = std::make_unique<EmojiStatusTopBar>(
document,
[=](QRect r) { _content->update(std::move(r)); },
HistoryView::Sticker::EmojiSize());
_imageStar = QImage();
} else {
_emojiStatus = nullptr;
_imageStar = Ui::Premium::GenerateStarForLightTopBar(_starRect);
}
updateTitle(document, { name }, controller);
updateAbout(document);
auto event = QResizeEvent(size(), size());
resizeEvent(&event);
update();
}, lifetime());
rpl::combine(
_title->sizeValue(),
_about->sizeValue(),
_content->sizeValue()
) | rpl::start_with_next([=](
const QSize &titleSize,
const QSize &aboutSize,
const QSize &size) {
const auto rect = TopBarAbstract::starRect(1., 1.);
const auto &padding = st::settingsPremiumUserTitlePadding;
_title->moveToLeft(
(size.width() - titleSize.width()) / 2,
rect.top() + rect.height() + padding.top());
_about->moveToLeft(
(size.width() - aboutSize.width()) / 2,
_title->y() + titleSize.height() + padding.bottom());
const auto aboutBottom = _about->y() + _about->height();
const auto height = (aboutBottom > st::settingsPremiumUserHeight)
? aboutBottom + padding.bottom()
: st::settingsPremiumUserHeight;
{
const auto was = maximumHeight();
const auto now = height;
if (was != now) {
setMaximumHeight(now);
if (was == size.height()) {
resize(size.width(), now);
}
}
}
_content->resize(size.width(), maximumHeight());
}, lifetime());
const auto smallTopShadow = Ui::CreateChild<Ui::FadeShadow>(
_smallTop.widget.data());
smallTopShadow->setDuration(st::infoTopBarDuration);
rpl::combine(
rpl::single(
false
) | rpl::then(std::move(showFinished) | rpl::map_to(true)),
sizeValue()
) | rpl::start_with_next([=](bool showFinished, const QSize &size) {
_content->resize(size.width(), maximumHeight());
const auto skip = TopTransitionSkip();
_content->moveToLeft(0, size.height() - _content->height() - skip);
_smallTop.widget->resize(size.width(), minimumHeight());
smallTopShadow->resizeToWidth(size.width());
smallTopShadow->moveToLeft(
0,
_smallTop.widget->height() - smallTopShadow->height());
const auto shown = (minimumHeight() * 2 > size.height());
if (_smallTop.shown != shown) {
_smallTop.shown = shown;
if (!showFinished) {
_smallTop.widget->update();
smallTopShadow->toggle(_smallTop.shown, anim::type::instant);
} else {
_smallTop.animation.start(
[=] { _smallTop.widget->update(); },
_smallTop.shown ? 0. : 1.,
_smallTop.shown ? 1. : 0.,
st::infoTopBarDuration);
smallTopShadow->toggle(_smallTop.shown, anim::type::normal);
}
}
}, lifetime());
_smallTop.widget->paintRequest(
) | rpl::start_with_next([=] {
Painter p(_smallTop.widget);
p.setOpacity(_smallTop.animation.value(_smallTop.shown ? 1. : 0.));
TopBarAbstract::paintEdges(p);
p.setPen(st::boxTitleFg);
_smallTop.text.drawLeft(
p,
_smallTop.position.x(),
_smallTop.position.y(),
width(),
width());
}, lifetime());
_content->paintRequest(
) | rpl::start_with_next([=] {
auto p = QPainter(_content);
_ministars.paint(p);
if (_emojiStatus) {
_emojiStatus->paint(p);
} else if (!_imageStar.isNull()) {
p.drawImage(_starRect.topLeft(), _imageStar);
}
}, lifetime());
}
void TopBarUser::updateTitle(
DocumentData *document,
TextWithEntities name,
not_null<Window::SessionController*> controller) {
if (!document) {
return _title->setMarkedText(
tr::lng_premium_summary_user_title(
tr::now,
lt_user,
std::move(name),
Ui::Text::WithEntities));
}
const auto stickerInfo = document->sticker();
if (!stickerInfo) {
return;
}
const auto owner = &document->owner();
const auto &sets = owner->stickers().sets();
const auto setId = stickerInfo->set.id;
const auto it = sets.find(setId);
if (it == sets.cend()) {
return;
}
const auto set = it->second.get();
const auto coloredId = owner->customEmojiManager().coloredSetId();
const auto text = (set->thumbnailDocumentId ? QChar('0') : QChar())
+ set->title;
const auto linkIndex = 1;
const auto entityEmojiData = Data::SerializeCustomEmojiId(
set->thumbnailDocumentId);
const auto entities = EntitiesInText{
{ EntityType::CustomEmoji, 0, 1, entityEmojiData },
Ui::Text::Link(text, linkIndex).entities.front(),
};
auto title = (setId == coloredId)
? tr::lng_premium_emoji_status_title_colored(
tr::now,
lt_user,
std::move(name),
Ui::Text::WithEntities)
: tr::lng_premium_emoji_status_title(
tr::now,
lt_user,
std::move(name),
lt_link,
{ .text = text, .entities = entities, },
Ui::Text::WithEntities);
const auto context = Core::MarkedTextContext{
.session = &controller->session(),
.customEmojiRepaint = [=] { _title->update(); },
};
_title->setMarkedText(std::move(title), context);
auto link = std::make_shared<LambdaClickHandler>([=,
stickerSetIdentifier = stickerInfo->set] {
setPaused(true);
const auto box = controller->show(Box<StickerSetBox>(
controller->uiShow(),
stickerSetIdentifier,
Data::StickersType::Emoji));
box->boxClosing(
) | rpl::start_with_next(crl::guard(this, [=] {
setPaused(false);
}), box->lifetime());
});
_title->setLink(linkIndex, std::move(link));
}
void TopBarUser::updateAbout(DocumentData *document) const {
_about->setMarkedText((document
? tr::lng_premium_emoji_status_about
: tr::lng_premium_summary_user_about)(
tr::now,
Ui::Text::RichLangValue));
}
void TopBarUser::setPaused(bool paused) {
_ministars.setPaused(paused);
if (_emojiStatus) {
_emojiStatus->setPaused(paused);
}
}
void TopBarUser::setTextPosition(int x, int y) {
_smallTop.position = { x, y };
}
rpl::producer<int> TopBarUser::additionalHeight() const {
return rpl::never<int>();
}
void TopBarUser::paintEvent(QPaintEvent *e) {
auto p = QPainter(this);
TopBarAbstract::paintEdges(p);
}
void TopBarUser::resizeEvent(QResizeEvent *e) {
_starRect = TopBarAbstract::starRect(1., 1.);
_ministars.setCenter(_starRect.toRect());
if (_emojiStatus) {
_emojiStatus->setCenter(_starRect.center());
}
}
class Premium : public Section<Premium> {
public:
Premium(
QWidget *parent,
not_null<Window::SessionController*> controller);
[[nodiscard]] rpl::producer<QString> title() override;
[[nodiscard]] QPointer<Ui::RpWidget> createPinnedToTop(
not_null<QWidget*> parent) override;
[[nodiscard]] QPointer<Ui::RpWidget> createPinnedToBottom(
not_null<Ui::RpWidget*> parent) override;
void showFinished() override;
[[nodiscard]] bool hasFlexibleTopBar() const override;
void setStepDataReference(std::any &data) override;
[[nodiscard]] rpl::producer<> sectionShowBack() override final;
private:
void setupContent();
void setupSubscriptionOptions(not_null<Ui::VerticalLayout*> container);
const not_null<Window::SessionController*> _controller;
const QString _ref;
QPointer<Ui::GradientButton> _subscribe;
base::unique_qptr<Ui::FadeWrap<Ui::IconButton>> _back;
base::unique_qptr<Ui::IconButton> _close;
rpl::variable<bool> _backToggles;
rpl::variable<Info::Wrap> _wrap;
Fn<void(bool)> _setPaused;
std::shared_ptr<Ui::RadiobuttonGroup> _radioGroup;
rpl::event_stream<> _showBack;
rpl::event_stream<> _showFinished;
rpl::variable<QString> _buttonText;
};
Premium::Premium(
QWidget *parent,
not_null<Window::SessionController*> controller)
: Section(parent)
, _controller(controller)
, _ref(ResolveRef(controller->premiumRef()))
, _radioGroup(std::make_shared<Ui::RadiobuttonGroup>()) {
setupContent();
_controller->session().api().premium().reload();
}
rpl::producer<QString> Premium::title() {
return tr::lng_premium_summary_title();
}
bool Premium::hasFlexibleTopBar() const {
return true;
}
rpl::producer<> Premium::sectionShowBack() {
return _showBack.events();
}
void Premium::setStepDataReference(std::any &data) {
const auto my = std::any_cast<SectionCustomTopBarData>(&data);
if (my) {
_backToggles = std::move(
my->backButtonEnables
) | rpl::map_to(true);
_wrap = std::move(my->wrapValue);
}
}
void Premium::setupSubscriptionOptions(
not_null<Ui::VerticalLayout*> container) {
const auto isEmojiStatus = (!!Ref::EmojiStatus::Parse(_ref));
const auto isGift = (!!Ref::Gift::Parse(_ref));
const auto options = container->add(
object_ptr<Ui::SlideWrap<Ui::VerticalLayout>>(
container,
object_ptr<Ui::VerticalLayout>(container)));
const auto skip = container->add(
object_ptr<Ui::SlideWrap<Ui::VerticalLayout>>(
container,
object_ptr<Ui::VerticalLayout>(container)));
const auto content = options->entity();
Ui::AddSkip(content, st::settingsPremiumOptionsPadding.top());
const auto apiPremium = &_controller->session().api().premium();
Ui::Premium::AddGiftOptions(
content,
_radioGroup,
SubscriptionOptionsForRows(apiPremium->subscriptionOptions()),
st::premiumSubscriptionOption,
true);
Ui::AddSkip(content, st::settingsPremiumOptionsPadding.bottom());
Ui::AddDivider(content);
const auto lastSkip = TopTransitionSkip() * (isEmojiStatus ? 1 : 2);
Ui::AddSkip(content, lastSkip - st::defaultVerticalListSkip);
Ui::AddSkip(skip->entity(), lastSkip);
if (isEmojiStatus || isGift) {
options->toggle(false, anim::type::instant);
skip->toggle(true, anim::type::instant);
return;
}
auto toggleOn = rpl::combine(
Data::AmPremiumValue(&_controller->session()),
apiPremium->statusTextValue(
) | rpl::map([=] {
return apiPremium->subscriptionOptions().size() < 2;
})
) | rpl::map([=](bool premium, bool noOptions) {
return !premium && !noOptions;
});
options->toggleOn(rpl::duplicate(toggleOn), anim::type::instant);
skip->toggleOn(std::move(
toggleOn
) | rpl::map([](bool value) { return !value; }), anim::type::instant);
}
void Premium::setupContent() {
const auto content = Ui::CreateChild<Ui::VerticalLayout>(this);
setupSubscriptionOptions(content);
auto buttonCallback = [=](PremiumFeature section) {
_setPaused(true);
const auto hidden = crl::guard(this, [=] { _setPaused(false); });
ShowPremiumPreviewToBuy(_controller, section, hidden);
};
AddSummaryPremium(content, _controller, _ref, std::move(buttonCallback));
#if 0
Ui::AddSkip(content);
Ui::AddDivider(content);
Ui::AddSkip(content);
content->add(
object_ptr<Ui::FlatLabel>(
content,
tr::lng_premium_summary_bottom_subtitle(
) | rpl::map(Ui::Text::Bold),
stLabel),
st::defaultSubsectionTitlePadding);
content->add(
object_ptr<Ui::FlatLabel>(
content,
tr::lng_premium_summary_bottom_about(Ui::Text::RichLangValue),
st::aboutLabel),
st::boxRowPadding);
Ui::AddSkip(
content,
stDefault.padding.top() + stDefault.padding.bottom());
#endif
Ui::ResizeFitChild(this, content);
}
QPointer<Ui::RpWidget> Premium::createPinnedToTop(
not_null<QWidget*> parent) {
auto title = _controller->session().premium()
? tr::lng_premium_summary_title()
: rpl::conditional(
Data::AmPremiumValue(&_controller->session()),
tr::lng_premium_summary_title_subscribed(),
tr::lng_premium_summary_title());
auto about = [&]() -> rpl::producer<TextWithEntities> {
const auto gift = Ref::Gift::Parse(_ref);
if (gift) {
auto &data = _controller->session().data();
if (const auto peer = data.peer(gift.peerId)) {
return (gift.me
? tr::lng_premium_summary_subtitle_gift_me
: tr::lng_premium_summary_subtitle_gift)(
lt_count,
rpl::single(float64(gift.months)),
lt_user,
rpl::single(Ui::Text::Bold(peer->name())),
Ui::Text::RichLangValue);
}
}
return rpl::conditional(
Data::AmPremiumValue(&_controller->session()),
_controller->session().api().premium().statusTextValue(),
tr::lng_premium_summary_top_about(Ui::Text::RichLangValue));
}();
const auto emojiStatusData = Ref::EmojiStatus::Parse(_ref);
const auto isEmojiStatus = (!!emojiStatusData);
auto peerWithPremium = [&]() -> PeerData* {
if (isEmojiStatus) {
auto &data = _controller->session().data();
if (const auto peer = data.peer(emojiStatusData.peerId)) {
return peer;
}
}
return nullptr;
}();
const auto content = [&]() -> Ui::Premium::TopBarAbstract* {
if (peerWithPremium) {
return Ui::CreateChild<TopBarUser>(
parent.get(),
_controller,
peerWithPremium,
_showFinished.events());
}
const auto weak = base::make_weak(_controller);
const auto clickContextOther = [=] {
return QVariant::fromValue(ClickHandlerContext{
.sessionWindow = weak,
.botStartAutoSubmit = true,
});
};
return Ui::CreateChild<Ui::Premium::TopBar>(
parent.get(),
st::defaultPremiumCover,
clickContextOther,
std::move(title),
std::move(about));
}();
_setPaused = [=](bool paused) {
content->setPaused(paused);
if (_subscribe) {
_subscribe->setGlarePaused(paused);
}
};
_wrap.value(
) | rpl::start_with_next([=](Info::Wrap wrap) {
content->setRoundEdges(wrap == Info::Wrap::Layer);
}, content->lifetime());
const auto calculateMaximumHeight = [=] {
return isEmojiStatus
? st::settingsPremiumUserHeight + TopTransitionSkip()
: st::settingsPremiumTopHeight;
};
content->setMaximumHeight(calculateMaximumHeight());
content->setMinimumHeight(st::infoLayerTopBarHeight);
content->resize(content->width(), content->maximumHeight());
content->additionalHeight(
) | rpl::start_with_next([=](int additionalHeight) {
const auto wasMax = (content->height() == content->maximumHeight());
content->setMaximumHeight(calculateMaximumHeight()
+ additionalHeight);
if (wasMax) {
content->resize(content->width(), content->maximumHeight());
}
}, content->lifetime());
_wrap.value(
) | rpl::start_with_next([=](Info::Wrap wrap) {
const auto isLayer = (wrap == Info::Wrap::Layer);
_back = base::make_unique_q<Ui::FadeWrap<Ui::IconButton>>(
content,
object_ptr<Ui::IconButton>(
content,
isEmojiStatus
? (isLayer ? st::infoTopBarBack : st::infoLayerTopBarBack)
: (isLayer
? st::settingsPremiumLayerTopBarBack
: st::settingsPremiumTopBarBack)),
st::infoTopBarScale);
_back->setDuration(0);
_back->toggleOn(isLayer
? _backToggles.value() | rpl::type_erased()
: rpl::single(true));
_back->entity()->addClickHandler([=] {
_showBack.fire({});
});
_back->toggledValue(
) | rpl::start_with_next([=](bool toggled) {
const auto &st = isLayer ? st::infoLayerTopBar : st::infoTopBar;
content->setTextPosition(
toggled ? st.back.width : st.titlePosition.x(),
st.titlePosition.y());
}, _back->lifetime());
if (!isLayer) {
_close = nullptr;
} else {
_close = base::make_unique_q<Ui::IconButton>(
content,
isEmojiStatus
? st::infoTopBarClose
: st::settingsPremiumTopBarClose);
_close->addClickHandler([=] {
_controller->parentController()->hideLayer();
_controller->parentController()->hideSpecialLayer();
});
content->widthValue(
) | rpl::start_with_next([=] {
_close->moveToRight(0, 0);
}, _close->lifetime());
}
}, content->lifetime());
return Ui::MakeWeak(not_null<Ui::RpWidget*>{ content });
}
void Premium::showFinished() {
_showFinished.fire({});
}
QPointer<Ui::RpWidget> Premium::createPinnedToBottom(
not_null<Ui::RpWidget*> parent) {
const auto content = Ui::CreateChild<Ui::RpWidget>(parent.get());
if (Ref::Gift::Parse(_ref)) {
return nullptr;
}
const auto emojiStatusData = Ref::EmojiStatus::Parse(_ref);
const auto session = &_controller->session();
auto buttonText = [&]() -> std::optional<rpl::producer<QString>> {
if (emojiStatusData) {
auto &data = session->data();
if (const auto peer = data.peer(emojiStatusData.peerId)) {
return Info::Profile::EmojiStatusIdValue(
peer
) | rpl::map([=](DocumentId id) {
return id
? tr::lng_premium_emoji_status_button()
: _buttonText.value();
// : tr::lng_premium_summary_user_button();
}) | rpl::flatten_latest();
}
}
return _buttonText.value();
}();
_subscribe = CreateSubscribeButton({
_controller,
content,
[ref = _ref] { return ref; },
std::move(buttonText),
std::nullopt,
[=, options = session->api().premium().subscriptionOptions()] {
const auto value = _radioGroup->current();
return (value < options.size() && value >= 0)
? options[value].botUrl
: QString();
},
});
#if 0
if (emojiStatusData) {
// "Learn More" should open the general Premium Settings
// so we override the button callback.
// To have ability to jump back to the User Premium Settings
// we should replace the ref explicitly.
_subscribe->setClickedCallback([=] {
const auto ref = _ref;
const auto controller = _controller;
ShowPremium(controller, QString());
controller->setPremiumRef(ref);
});
} else {
#endif
{
const auto callback = [=](int value) {
const auto options =
_controller->session().api().premium().subscriptionOptions();
if (options.empty()) {
return;
}
Assert(value < options.size() && value >= 0);
auto text = tr::lng_premium_subscribe_button(
tr::now,
lt_cost,
options[value].costPerMonth);
_buttonText = std::move(text);
};
_radioGroup->setChangedCallback(callback);
callback(0);
}
_showFinished.events(
) | rpl::take(1) | rpl::start_with_next([=] {
_subscribe->startGlareAnimation();
}, _subscribe->lifetime());
content->widthValue(
) | rpl::start_with_next([=](int width) {
const auto padding = st::settingsPremiumButtonPadding;
_subscribe->resizeToWidth(width - padding.left() - padding.right());
}, _subscribe->lifetime());
rpl::combine(
_subscribe->heightValue(),
Data::AmPremiumValue(session),
session->premiumPossibleValue()
) | rpl::start_with_next([=](
int buttonHeight,
bool premium,
bool premiumPossible) {
const auto padding = st::settingsPremiumButtonPadding;
const auto finalHeight = !premiumPossible
? 0
: !premium
? (padding.top() + buttonHeight + padding.bottom())
: 0;
content->resize(content->width(), finalHeight);
_subscribe->moveToLeft(padding.left(), padding.top());
_subscribe->setVisible(!premium && premiumPossible);
}, _subscribe->lifetime());
return Ui::MakeWeak(not_null<Ui::RpWidget*>{ content });
}
} // namespace
template <>
struct SectionFactory<Premium> : AbstractSectionFactory {
object_ptr<AbstractSection> create(
not_null<QWidget*> parent,
not_null<Window::SessionController*> controller,
not_null<Ui::ScrollArea*> scroll,
rpl::producer<Container> containerValue
) const final override {
return object_ptr<Premium>(parent, controller);
}
bool hasCustomTopBar() const final override {
return true;
}
[[nodiscard]] static const std::shared_ptr<SectionFactory> &Instance() {
static const auto result = std::make_shared<SectionFactory>();
return result;
}
};
Type PremiumId() {
return Premium::Id();
}
void ShowPremium(not_null<Main::Session*> session, const QString &ref) {
const auto active = Core::App().activeWindow();
const auto controller = (active && active->isPrimary())
? active->sessionController()
: nullptr;
if (controller && session == &controller->session()) {
ShowPremium(controller, ref);
} else {
for (const auto &controller : session->windows()) {
if (controller->window().isPrimary()) {
ShowPremium(controller, ref);
}
}
}
}
void ShowPremium(
not_null<Window::SessionController*> controller,
const QString &ref) {
if (!controller->session().premiumPossible()) {
controller->show(Box(PremiumUnavailableBox));
return;
}
controller->setPremiumRef(ref);
controller->showSettings(Settings::PremiumId());
}
void ShowGiftPremium(
not_null<Window::SessionController*> controller,
not_null<PeerData*> peer,
int months,
bool me) {
ShowPremium(controller, Ref::Gift::Serialize({ peer->id, months, me }));
}
void ShowEmojiStatusPremium(
not_null<Window::SessionController*> controller,
not_null<PeerData*> peer) {
ShowPremium(controller, Ref::EmojiStatus::Serialize({ peer->id }));
}
void StartPremiumPayment(
not_null<Window::SessionController*> controller,
const QString &ref) {
const auto account = &controller->session().account();
const auto username = account->appConfig().get<QString>(
"premium_bot_username",
QString());
const auto slug = account->appConfig().get<QString>(
"premium_invoice_slug",
QString());
if (!username.isEmpty()) {
controller->showPeerByLink(Window::PeerByLinkInfo{
.usernameOrId = username,
.resolveType = Window::ResolveType::BotStart,
.startToken = ref,
.startAutoSubmit = true,
});
} else if (!slug.isEmpty()) {
UrlClickHandler::Open("https://t.me/$" + slug);
}
}
QString LookupPremiumRef(PremiumFeature section) {
for (const auto &[ref, entry] : EntryMap()) {
if (entry.section == section) {
return ref;
}
}
return QString();
}
void ShowPremiumPromoToast(
std::shared_ptr<ChatHelpers::Show> show,
TextWithEntities textWithLink,
const QString &ref) {
ShowPremiumPromoToast(show, [=](
not_null<Main::Session*> session,
ChatHelpers::WindowUsage usage) {
Expects(&show->session() == session);
return show->resolveWindow(usage);
}, std::move(textWithLink), ref);
}
void ShowPremiumPromoToast(
std::shared_ptr<Main::SessionShow> show,
Fn<Window::SessionController*(
not_null<Main::Session*>,
ChatHelpers::WindowUsage)> resolveWindow,
TextWithEntities textWithLink,
const QString &ref) {
using WeakToast = base::weak_ptr<Ui::Toast::Instance>;
const auto toast = std::make_shared<WeakToast>();
(*toast) = show->showToast({
.text = std::move(textWithLink),
.st = &st::defaultMultilineToast,
.duration = Ui::Toast::kDefaultDuration * 2,
.adaptive = true,
.multiline = true,
.filter = crl::guard(&show->session(), [=](
const ClickHandlerPtr &,
Qt::MouseButton button) {
if (button == Qt::LeftButton) {
if (const auto strong = toast->get()) {
strong->hideAnimated();
(*toast) = nullptr;
if (const auto controller = resolveWindow(
&show->session(),
ChatHelpers::WindowUsage::PremiumPromo)) {
Settings::ShowPremium(controller, ref);
}
return true;
}
}
return false;
}),
});
}
not_null<Ui::RoundButton*> CreateLockedButton(
not_null<QWidget*> parent,
rpl::producer<QString> text,
const style::RoundButton &st,
rpl::producer<bool> locked) {
const auto result = Ui::CreateChild<Ui::RoundButton>(
parent.get(),
rpl::single(QString()),
st);
const auto labelSt = result->lifetime().make_state<style::FlatLabel>(
st::defaultFlatLabel);
labelSt->style.font = st.font;
labelSt->textFg = st.textFg;
const auto label = Ui::CreateChild<Ui::FlatLabel>(
result,
std::move(text),
*labelSt);
label->setAttribute(Qt::WA_TransparentForMouseEvents);
const auto icon = Ui::CreateChild<Ui::RpWidget>(result);
icon->setAttribute(Qt::WA_TransparentForMouseEvents);
icon->resize(st::stickersPremiumLock.size());
icon->paintRequest() | rpl::start_with_next([=] {
auto p = QPainter(icon);
st::stickersPremiumLock.paint(p, 0, 0, icon->width());
}, icon->lifetime());
rpl::combine(
result->widthValue(),
label->widthValue(),
std::move(locked)
) | rpl::start_with_next([=](int outer, int inner, bool locked) {
if (locked) {
icon->show();
inner += icon->width();
label->move(
(outer - inner) / 2 + icon->width(),
st::similarChannelsLock.textTop);
icon->move(
(outer - inner) / 2,
st::similarChannelsLock.textTop);
} else {
icon->hide();
label->move(
(outer - inner) / 2,
st::similarChannelsLock.textTop);
}
}, result->lifetime());
return result;
}
not_null<Ui::GradientButton*> CreateSubscribeButton(
SubscribeButtonArgs &&args) {
Expects(args.show || args.controller);
if (!args.show && args.controller) {
args.show = args.controller->uiShow();
}
const auto result = Ui::CreateChild<Ui::GradientButton>(
args.parent.get(),
args.gradientStops
? base::take(*args.gradientStops)
: Ui::Premium::ButtonGradientStops());
result->setClickedCallback([
show = args.show,
computeRef = args.computeRef,
computeBotUrl = args.computeBotUrl] {
const auto window = show->resolveWindow(
ChatHelpers::WindowUsage::PremiumPromo);
if (!window) {
return;
}
const auto url = computeBotUrl ? computeBotUrl() : QString();
if (!url.isEmpty()) {
const auto local = Core::TryConvertUrlToLocal(url);
if (local.isEmpty()) {
return;
}
UrlClickHandler::Open(
local,
QVariant::fromValue(ClickHandlerContext{
.sessionWindow = base::make_weak(window),
.botStartAutoSubmit = true,
}));
} else {
SendScreenAccept(window);
StartPremiumPayment(window, computeRef());
}
});
const auto &st = st::premiumPreviewBox.button;
result->resize(args.parent->width(), st.height);
const auto premium = &args.show->session().api().premium();
premium->reload();
const auto computeCost = [=] {
const auto amount = premium->monthlyAmount();
const auto currency = premium->monthlyCurrency();
const auto valid = (amount > 0) && !currency.isEmpty();
return Ui::FillAmountAndCurrency(
valid ? amount : 500,
valid ? currency : "USD");
};
const auto label = Ui::CreateChild<Ui::FlatLabel>(
result,
args.text
? base::take(*args.text)
: tr::lng_premium_summary_button(
lt_cost,
premium->statusTextValue() | rpl::map(computeCost)),
st::premiumPreviewButtonLabel);
label->setAttribute(Qt::WA_TransparentForMouseEvents);
rpl::combine(
result->widthValue(),
label->widthValue()
) | rpl::start_with_next([=](int outer, int width) {
label->moveToLeft(
(outer - width) / 2,
st::premiumPreviewBox.button.textTop,
outer);
}, label->lifetime());
return result;
}
std::vector<PremiumFeature> PremiumFeaturesOrder(
not_null<Main::Session*> session) {
const auto mtpOrder = session->account().appConfig().get<Order>(
"premium_promo_order",
FallbackOrder());
return ranges::views::all(
mtpOrder
) | ranges::views::transform([](const QString &s) {
if (s == u"more_upload"_q) {
return PremiumFeature::MoreUpload;
} else if (s == u"faster_download"_q) {
return PremiumFeature::FasterDownload;
} else if (s == u"voice_to_text"_q) {
return PremiumFeature::VoiceToText;
} else if (s == u"no_ads"_q) {
return PremiumFeature::NoAds;
} else if (s == u"emoji_status"_q) {
return PremiumFeature::EmojiStatus;
} else if (s == u"infinite_reactions"_q) {
return PremiumFeature::InfiniteReactions;
} else if (s == u"saved_tags"_q) {
return PremiumFeature::TagsForMessages;
} else if (s == u"last_seen"_q) {
return PremiumFeature::LastSeen;
} else if (s == u"message_privacy"_q) {
return PremiumFeature::MessagePrivacy;
} else if (s == u"premium_stickers"_q) {
return PremiumFeature::Stickers;
} else if (s == u"animated_emoji"_q) {
return PremiumFeature::AnimatedEmoji;
} else if (s == u"advanced_chat_management"_q) {
return PremiumFeature::AdvancedChatManagement;
} else if (s == u"profile_badge"_q) {
return PremiumFeature::ProfileBadge;
} else if (s == u"animated_userpics"_q) {
return PremiumFeature::AnimatedUserpics;
} else if (s == u"translations"_q) {
return PremiumFeature::RealTimeTranslation;
} else if (s == u"wallpapers"_q) {
return PremiumFeature::Wallpapers;
}
return PremiumFeature::kCount;
}) | ranges::views::filter([](PremiumFeature type) {
return (type != PremiumFeature::kCount);
}) | ranges::to_vector;
}
void AddSummaryPremium(
not_null<Ui::VerticalLayout*> content,
not_null<Window::SessionController*> controller,
const QString &ref,
Fn<void(PremiumFeature)> buttonCallback) {
const auto &stDefault = st::settingsButton;
const auto &stLabel = st::defaultFlatLabel;
const auto iconSize = st::settingsPremiumIconDouble.size();
const auto &titlePadding = st::settingsPremiumRowTitlePadding;
const auto &descriptionPadding = st::settingsPremiumRowAboutPadding;
auto entryMap = EntryMap();
auto iconContainers = std::vector<Ui::AbstractButton*>();
iconContainers.reserve(int(entryMap.size()));
const auto addRow = [&](Entry &entry) {
const auto labelAscent = stLabel.style.font->ascent;
const auto button = Ui::CreateChild<Ui::SettingsButton>(
content.get(),
rpl::single(QString()));
const auto label = content->add(
object_ptr<Ui::FlatLabel>(
content,
std::move(entry.title) | rpl::map(Ui::Text::Bold),
stLabel),
titlePadding);
label->setAttribute(Qt::WA_TransparentForMouseEvents);
const auto description = content->add(
object_ptr<Ui::FlatLabel>(
content,
std::move(entry.description),
st::boxDividerLabel),
descriptionPadding);
description->setAttribute(Qt::WA_TransparentForMouseEvents);
if (entry.newBadge) {
Ui::NewBadge::AddAfterLabel(content, label);
}
const auto dummy = Ui::CreateChild<Ui::AbstractButton>(content.get());
dummy->setAttribute(Qt::WA_TransparentForMouseEvents);
content->sizeValue(
) | rpl::start_with_next([=](const QSize &s) {
dummy->resize(s.width(), iconSize.height());
}, dummy->lifetime());
label->geometryValue(
) | rpl::start_with_next([=](const QRect &r) {
dummy->moveToLeft(0, r.y() + (r.height() - labelAscent));
}, dummy->lifetime());
rpl::combine(
content->widthValue(),
label->heightValue(),
description->heightValue()
) | rpl::start_with_next([=,
topPadding = titlePadding,
bottomPadding = descriptionPadding](
int width,
int topHeight,
int bottomHeight) {
button->resize(
width,
topPadding.top()
+ topHeight
+ topPadding.bottom()
+ bottomPadding.top()
+ bottomHeight
+ bottomPadding.bottom());
}, button->lifetime());
label->topValue(
) | rpl::start_with_next([=, padding = titlePadding.top()](int top) {
button->moveToLeft(0, top - padding);
}, button->lifetime());
const auto arrow = Ui::CreateChild<Ui::IconButton>(
button,
st::backButton);
arrow->setIconOverride(
&st::settingsPremiumArrow,
&st::settingsPremiumArrowOver);
arrow->setAttribute(Qt::WA_TransparentForMouseEvents);
button->sizeValue(
) | rpl::start_with_next([=](const QSize &s) {
const auto &point = st::settingsPremiumArrowShift;
arrow->moveToRight(
-point.x(),
point.y() + (s.height() - arrow->height()) / 2);
}, arrow->lifetime());
const auto section = entry.section;
button->setClickedCallback([=] { buttonCallback(section); });
iconContainers.push_back(dummy);
};
auto icons = std::vector<const style::icon *>();
icons.reserve(int(entryMap.size()));
{
const auto &account = controller->session().account();
const auto mtpOrder = account.appConfig().get<Order>(
"premium_promo_order",
FallbackOrder());
const auto processEntry = [&](Entry &entry) {
icons.push_back(entry.icon);
addRow(entry);
};
for (const auto &key : mtpOrder) {
auto it = entryMap.find(key);
if (it == end(entryMap)) {
continue;
}
processEntry(it->second);
}
SendScreenShow(controller, mtpOrder, ref);
}
content->resizeToWidth(content->height());
// Icons.
Assert(iconContainers.size() > 2);
const auto from = iconContainers.front()->y();
const auto to = iconContainers.back()->y() + iconSize.height();
auto gradient = QLinearGradient(0, 0, 0, to - from);
gradient.setStops(Ui::Premium::FullHeightGradientStops());
for (auto i = 0; i < int(icons.size()); i++) {
const auto &iconContainer = iconContainers[i];
const auto pointTop = iconContainer->y() - from;
const auto pointBottom = pointTop + iconContainer->height();
const auto ratioTop = pointTop / float64(to - from);
const auto ratioBottom = pointBottom / float64(to - from);
auto resultGradient = QLinearGradient(
QPointF(),
QPointF(0, pointBottom - pointTop));
resultGradient.setColorAt(
.0,
anim::gradient_color_at(gradient, ratioTop));
resultGradient.setColorAt(
.1,
anim::gradient_color_at(gradient, ratioBottom));
const auto brush = QBrush(resultGradient);
AddButtonIcon(
iconContainer,
stDefault,
{ .icon = icons[i], .backgroundBrush = brush });
}
Ui::AddSkip(content, descriptionPadding.bottom());
}
} // namespace Settings