not_null<Window::SessionController*> window) {

using Mode = ContactsBoxController::SortMode;

class Controller final : public ContactsBoxController {

public:

using ContactsBoxController::ContactsBoxController;

[[nodiscard]] rpl::producer<not_null<PeerData*>> wheelClicks() const {

return _wheelClicks.events();

}

protected:

std::unique_ptr<PeerListRow> createRow(

not_null<UserData*> user) override {

return !user->isSelf()

? ContactsBoxController::createRow(user)

: nullptr;

}

void rowMiddleClicked(

not_null<PeerListRow*> row) override {

_wheelClicks.fire(row->peer());

}

private:

rpl::event_stream<not_null<PeerData*>> _wheelClicks;

};

auto controller = std::make_unique<Controller>(

&window->session());

controller->setStyleOverrides(&st::contactsWithStories);

controller->setStoriesShown(true);

const auto raw = controller.get();

auto init = [=](not_null<PeerListBox*> box) {

struct State {

QPointer<::Ui::IconButton> toggleSort;

rpl::variable<Mode> mode = Mode::Online;

::Ui::Animations::Simple scrollAnimation;

};

const auto state = box->lifetime().make_state<State>();

box->addButton(tr::lng_close(), [=] { box->closeBox(); });

box->addLeftButton(

tr::lng_profile_add_contact(),

[=] { window->showAddContact(); });

state->toggleSort = box->addTopButton(st::contactsSortButton, [=] {

const auto online = (state->mode.current() == Mode::Online);

const auto mode = online ? Mode::Alphabet : Mode::Online;

state->mode = mode;

raw->setSortMode(mode);

state->toggleSort->setIconOverride(

online ? &st::contactsSortOnlineIcon : nullptr,

online ? &st::contactsSortOnlineIconOver : nullptr);

});

raw->setSortMode(Mode::Online);

raw->wheelClicks() | rpl::on_next([=](not_null<PeerData*> p) {

window->showInNewWindow(p);

}, box->lifetime());

raw->setShowFinishedCallback([=] {

window->checkHighlightControl(

u"contacts/sort"_q,

state->toggleSort,

{ .rippleShape = true });

});

};

return Box<PeerListBox>(std::move(controller), std::move(init));

const auto left = st.item.photoPosition.x();

const auto top = st.item.photoPosition.y();

const auto size = st.item.photoSize;

return Ui::UnreadStoryOutlineGradient(QRectF(left, top, size, size));

PeerListStoriesCounts counts,

const QBrush &unreadBrush) {

Expects(counts.unread <= counts.count);

Expects(counts.count > 0);

auto result = std::vector<Ui::OutlineSegment>();

const auto add = [&](bool unread) {

result.push_back({

.brush = (counts.videoStream

? st::attentionButtonFg->b

: unread

? unreadBrush

: st::dialogsUnreadBgMuted->b),

.width = (unread

? st::dialogsStoriesFull.lineTwice / 2.

: st::dialogsStoriesFull.lineReadTwice / 2.),

});

};

if (counts.videoStream) {

add(true);

} else {

const auto count = counts.count;

const auto unread = counts.unread;

result.reserve(count);

for (auto i = 0, till = count - unread; i != till; ++i) {

add(false);

}

for (auto i = 0; i != unread; ++i) {

add(true);

}

}

return result;

return QMargins(

st::contactsCheckPosition.x(),

(st::contactsPadding.top() + st::contactsPhotoSize + st::contactsPadding.bottom() - st::normalFont->height) / 2,

st::defaultPeerListItem.photoPosition.x() + st::contactsCheckPosition.x(),

0);

Painter &p,

int x,

int y,

int outerWidth,

bool selected,

bool actionSelected) {

p.setFont(actionSelected ? st::linkFontOver : st::linkFont);

p.setPen(actionSelected ? st::defaultLinkButton.overColor : st::defaultLinkButton.color);

p.drawTextLeft(x, y, outerWidth, _action, _actionWidth);

not_null<Main::Session*> session)

: _session(session)

, _api(&session->mtp()) {

_timer.setCallback([this] { searchOnServer(); });

if (_query != query) {

_query = query;

_requestId = 0;

if (!_query.isEmpty() && !searchInCache()) {

_timer.callOnce(AutoSearchTimeout);

} else {

_timer.cancel();

}

}

auto it = _cache.find(_query);

if (it != _cache.cend()) {

_requestId = 0;

searchDone(it->second, _requestId);

return true;

}

return false;

_requestId = _api.request(MTPcontacts_Search(

MTP_string(_query),

MTP_int(SearchPeopleLimit)

)).done([=](const MTPcontacts_Found &result, mtpRequestId requestId) {

searchDone(result, requestId);

}).fail([=](const MTP::Error &error, mtpRequestId requestId) {

if (_requestId == requestId) {

_requestId = 0;

delegate()->peerListSearchRefreshRows();

}

}).send();

_queries.emplace(_requestId, _query);

const MTPcontacts_Found &result,

mtpRequestId requestId) {

Expects(result.type() == mtpc_contacts_found);

auto &contacts = result.c_contacts_found();

auto query = _query;

if (requestId) {

_session->data().processUsers(contacts.vusers());

_session->data().processChats(contacts.vchats());

auto it = _queries.find(requestId);

if (it != _queries.cend()) {

query = it->second;

_cache[query] = result;

_queries.erase(it);

}

}

const auto feedList = [&](const MTPVector<MTPPeer> &list) {

for (const auto &mtpPeer : list.v) {

const auto peer = _session->data().peerLoaded(

peerFromMTP(mtpPeer));

if (peer) {

delegate()->peerListSearchAddRow(peer);

}

}

};

if (_requestId == requestId) {

_requestId = 0;

feedList(contacts.vmy_results());

feedList(contacts.vresults());

delegate()->peerListSearchRefreshRows();

}

not_null<PeerData*> peer,

const style::PeerListItem *maybeLockedSt,

History *maybeHistory)

: PeerListRow(peer)

, _maybeHistory(maybeHistory)

, _maybeLockedSt(maybeLockedSt) {

if (_maybeLockedSt) {

setRestriction(Api::ResolveMessageMoneyRestrictions(

peer,

maybeHistory));

}

return _restriction

? _restriction->value

: Api::MessageMoneyRestriction();

if (!restriction) {

_restriction = nullptr;

return;

} else if (!_restriction) {

_restriction = std::make_unique<Restriction>();

}

_restriction->value = restriction;

Painter &p,

const style::PeerListItem &st,

int x,

int y,

int outerWidth) {

if (const auto &r = _restriction) {

PaintRestrictionBadge(

p,

_maybeLockedSt,

r->value.starsPerMessage,

r->cache,

x,

y,

outerWidth,

st.photoSize);

}

not_null<const style::PeerListItem*> maybeLockedSt) {

if (const auto user = peer()->asUser()) {

using Restriction = Api::MessageMoneyRestriction;

const auto r = _maybeLockedSt

? Api::ResolveMessageMoneyRestrictions(

user,

_maybeHistory)

: Restriction();

if ((_restriction ? _restriction->value : Restriction()) != r) {

setRestriction(r);

return true;

}

}

return false;

PeerListRow::preloadUserpic();

if (!_maybeLockedSt) {

return;

}

const auto peer = this->peer();

const auto known = Api::ResolveMessageMoneyRestrictions(

peer,

_maybeHistory).known;

if (known) {

return;

} else if (const auto user = peer->asUser()) {

const auto api = &user->session().api();

api->premium().resolveMessageMoneyRestrictions(user);

} else if (const auto group = peer->asChannel()) {

group->updateFull();

}

not_null<PeerListController*> controller,

rpl::lifetime &lifetime) {

const auto session = &controller->session();

rpl::merge(

Data::AmPremiumValue(session) | rpl::to_empty,

session->api().premium().someMessageMoneyRestrictionsResolved()

) | rpl::on_next([=] {

const auto st = &controller->computeListSt().item;

const auto delegate = controller->delegate();

const auto process = [&](not_null<PeerListRow*> raw) {

if (static_cast<RecipientRow*>(raw.get())->refreshLock(st)) {

delegate->peerListUpdateRow(raw);

}

};

auto count = delegate->peerListFullRowsCount();

for (auto i = 0; i != count; ++i) {

process(delegate->peerListRowAt(i));

}

count = delegate->peerListSearchRowsCount();

for (auto i = 0; i != count; ++i) {

process(delegate->peerListSearchRowAt(i));

}

}, lifetime);

not_null<Main::Session*> session)

: ChatsListBoxController(

std::make_unique<PeerListGlobalSearchController>(session)) {

setSearchNoResultsText(tr::lng_blocked_list_not_found(tr::now));

delegate()->peerListSetSearchMode(PeerListSearchMode::Enabled);

prepareViewHook();

if (!session().data().chatsListLoaded()) {

session().data().chatsListLoadedEvents(

) | rpl::filter([=](Data::Folder *folder) {

return !folder;

}) | rpl::on_next([=] {

checkForEmptyRows();

}, lifetime());

}

session().data().chatsListChanges(

) | rpl::on_next([=] {

rebuildRows();

}, lifetime());

session().data().contactsLoaded().value(

) | rpl::on_next([=] {

rebuildRows();

}, lifetime());

auto wasEmpty = !delegate()->peerListFullRowsCount();

auto appendList = [this](auto chats) {

auto count = 0;

for (const auto &row : chats->all()) {

if (const auto history = row->history()) {

if (appendRow(history)) {

++count;

}

}

}

return count;

};

auto added = 0;

if (!savedMessagesChatStatus().isEmpty()) {

if (appendRow(session().data().history(session().user()))) {

++added;

}

}

added += appendList(session().data().chatsList()->indexed());

const auto id = Data::Folder::kId;

if (const auto folder = session().data().folderLoaded(id)) {

added += appendList(folder->chatsList()->indexed());

}

added += appendList(session().data().contactsNoChatsList());

if (!wasEmpty && added > 0) {

// Place dialogs list before contactsNoDialogs list.

delegate()->peerListPartitionRows([](const PeerListRow &a) {

const auto history = static_cast<const Row&>(a).history();

return history->inChatList();

});

if (!savedMessagesChatStatus().isEmpty()) {

delegate()->peerListPartitionRows([](const PeerListRow &a) {

return a.peer()->isSelf();

});

}

}

checkForEmptyRows();

delegate()->peerListRefreshRows();

if (delegate()->peerListFullRowsCount()) {

setDescriptionText(QString());

} else {

const auto loaded = session().data().contactsLoaded().current()

&& session().data().chatsListLoaded();

setDescriptionText(loaded ? emptyBoxText() : tr::lng_contacts_loading(tr::now));

}

if (auto row = delegate()->peerListFindRow(history->peer->id.value)) {

updateRowHook(static_cast<Row*>(row));

return false;

}

if (auto row = createRow(history)) {

delegate()->peerListAppendRow(std::move(row));

return true;

}

return false;

not_null<PeerListController*> controller,

not_null<Main::Session*> session)

: _controller(controller)

, _session(session) {

for (auto i = begin(_counts); i != end(_counts); ++i) {

if (const auto row = _delegate->peerListFindRow(i->first)) {

if (i->second.count >= 0 && i->second.unread >= 0) {

applyForRow(row, i->second, true);

}

}

}

if (const auto row = _delegate->peerListFindRow(id)) {

applyForRow(row, counts);

_delegate->peerListUpdateRow(row);

}

const auto user = row->peer()->asUser();

if (!user) {

return;

}

const auto stories = &_session->data().stories();

const auto source = stories->source(user->id);

const auto count = source

? int(source->ids.size())

: user->hasActiveStories()

? 1

: 0;

const auto unread = source

? int(source->info().unreadCount)

: user->hasUnreadStories()

? 1

: 0;

const auto videoStream = source

? bool(source->info().hasVideoStream)

: user->hasActiveVideoStream();

applyForRow(row, { count, unread, videoStream }, true);

const auto point = _delegate->peerListLastRowMousePosition();

const auto &st = _controller->computeListSt().item;

if (point && point->x() < st.photoPosition.x() + st.photoSize) {

if (const auto window = peer->session().tryResolveWindow()) {

if (const auto user = peer->asUser()) {

if (user->hasActiveStories()) {

window->openPeerStories(peer->id);

return true;

}

}

}

}

return false;

_delegate = delegate;

_unreadBrush = PeerListStoriesGradient(_controller->computeListSt());

style::PaletteChanged() | rpl::on_next([=] {

_unreadBrush = PeerListStoriesGradient(_controller->computeListSt());

updateColors();

}, _lifetime);

_session->changes().peerUpdates(

Data::PeerUpdate::Flag::StoriesState

) | rpl::on_next([=](const Data::PeerUpdate &update) {

const auto id = update.peer->id.value;

if (const auto row = _delegate->peerListFindRow(id)) {

process(row);

}

}, _lifetime);

const auto stories = &_session->data().stories();

stories->sourceChanged() | rpl::on_next([=](PeerId id) {

const auto source = stories->source(id);

const auto info = source

? source->info()

: Data::StoriesSourceInfo();

updateFor(id.value, {

int(info.count),

int(info.unreadCount),

bool(info.hasVideoStream),

});

}, _lifetime);

not_null<PeerListRow*> row,

Counts counts,

bool force) {

auto &existing = _counts[row->id()];

if (!force && existing == counts) {

return;

}

existing = counts;

_delegate->peerListSetRowChecked(row, counts.count > 0);

if (counts.count > 0) {

row->setCustomizedCheckSegments(

PeerListStoriesSegments(counts, _unreadBrush),

counts.videoStream);

}

not_null<Main::Session*> session)

: ContactsBoxController(

session,

std::make_unique<PeerListGlobalSearchController>(session)) {

not_null<Main::Session*> session,

std::unique_ptr<PeerListSearchController> searchController)

: PeerListController(std::move(searchController))

, _session(session)

, _sortByOnlineTimer([=] { sort(); }) {

setSearchNoResultsText(tr::lng_blocked_list_not_found(tr::now));

delegate()->peerListSetSearchMode(PeerListSearchMode::Enabled);

delegate()->peerListSetTitle(tr::lng_contacts_header());

prepareViewHook();

if (_stories) {

_stories->prepare(delegate());

}

session().data().contactsLoaded().value(

) | rpl::on_next([=] {

rebuildRows();

}, lifetime());

const auto appendList = [&](auto chats) {

auto count = 0;

for (const auto &row : chats->all()) {

if (const auto history = row->history()) {

if (const auto user = history->peer->asUser()) {

if (appendRow(user)) {

++count;

}

}

}

}

return count;

};

appendList(session().data().contactsList());

checkForEmptyRows();

sort();

delegate()->peerListRefreshRows();

setDescriptionText(delegate()->peerListFullRowsCount()

? QString()

: session().data().contactsLoaded().current()

? tr::lng_contacts_not_found(tr::now)

: tr::lng_contacts_loading(tr::now));

not_null<PeerData*> peer) {

if (const auto user = peer->asUser()) {

return createRow(user);

}

return nullptr;

const auto peer = row->peer();

if (_stories && _stories->handleClick(peer)) {

return;

} else if (const auto window = peer->session().tryResolveWindow()) {

window->showPeerHistory(peer);

}

if (_sortMode == mode) {

return;

}

_sortMode = mode;

sort();

if (_sortMode == SortMode::Online) {

session().changes().peerUpdates(

Data::PeerUpdate::Flag::OnlineStatus

) | rpl::filter([=](const Data::PeerUpdate &update) {

return !_sortByOnlineTimer.isActive()

&& delegate()->peerListFindRow(update.peer->id.value);

}) | rpl::on_next([=] {

_sortByOnlineTimer.callOnce(kSortByOnlineThrottle);

}, _sortByOnlineLifetime);

} else {

_sortByOnlineTimer.cancel();

_sortByOnlineLifetime.destroy();

}

switch (_sortMode) {

case SortMode::Alphabet: sortByName(); break;

case SortMode::Online: sortByOnline(); break;

default: Unexpected("SortMode in ContactsBoxController.");

}

const auto now = base::unixtime::now();

const auto key = [&](const PeerListRow &row) {

const auto user = row.peer()->asUser();

return user

? (std::min(user->lastseen().onlineTill(), now + 1) + 1)

: TimeId();

};

const auto predicate = [&](const PeerListRow &a, const PeerListRow &b) {

return key(a) > key(b);

};

delegate()->peerListSortRows(predicate);

if (auto row = delegate()->peerListFindRow(user->id.value)) {

updateRowHook(row);

return false;

}

if (auto row = createRow(user)) {

const auto raw = row.get();

delegate()->peerListAppendRow(std::move(row));

if (_stories) {

_stories->process(raw);

}

return true;

}

return false;

not_null<UserData*> user) {

return {

.text = tr::lng_send_non_premium_message_toast(

tr::now,

lt_user,

TextWithEntities{ user->shortName() },

lt_link,

tr::link(

tr::bold(

tr::lng_send_non_premium_message_toast_link(

tr::now))),

tr::rich),

};

not_null<Main::Session*> session,

FnMut<void(not_null<Data::Thread*>)> callback,

Fn<bool(not_null<Data::Thread*>)> filter)

: ChooseRecipientBoxController({

.session = session,

.callback = std::move(callback),

.filter = std::move(filter),

}) {

ChooseRecipientArgs &&args)

: ChatsListBoxController(args.session)

, _session(args.session)

, _callback(std::move(args.callback))

, _filter(std::move(args.filter))

, _moneyRestrictionError(std::move(args.moneyRestrictionError)) {

delegate()->peerListSetTitle(tr::lng_forward_choose());

if (_moneyRestrictionError) {

TrackMessageMoneyRestrictionsChanges(this, lifetime());

}

not_null<PeerListRow*> row) {

return RecipientRow::ShowLockedError(

this,

row,

_moneyRestrictionError);

if (showLockedError(row)) {

return;

}

auto guard = base::make_weak(this);

const auto peer = row->peer();

if (const auto forum = peer->forum()) {

const auto weak = std::make_shared<base::weak_qptr<Ui::BoxContent>>();

auto callback = [=](not_null<Data::Thread*> thread) {

const auto exists = guard.get();

if (!exists) {

if (*weak) {

(*weak)->closeBox();

}

return;

}

auto onstack = std::move(_callback);

onstack(thread);

if (guard) {

_callback = std::move(onstack);

} else if (*weak) {

(*weak)->closeBox();

}

};

const auto filter = [=](not_null<Data::Thread*> thread) {

return guard && (!_filter || _filter(thread));

};

auto owned = Box<PeerListBox>(

std::make_unique<ChooseTopicBoxController>(

forum,

std::move(callback),

filter),

[=](not_null<PeerListBox*> box) {

box->addButton(tr::lng_cancel(), [=] {

box->closeBox();

});

forum->destroyed(

) | rpl::on_next([=] {

box->closeBox();

}, box->lifetime());

});

*weak = owned.data();

delegate()->peerListUiShow()->showBox(std::move(owned));

return;

} else if (const auto monoforum = peer->monoforum()) {

const auto weak = std::make_shared<base::weak_qptr<Ui::BoxContent>>();

auto callback = [=](not_null<Data::SavedSublist*> sublist) {

const auto exists = guard.get();

if (!exists) {

if (*weak) {

(*weak)->closeBox();

}

return;

}

auto onstack = std::move(_callback);

onstack(sublist);

if (guard) {

_callback = std::move(onstack);

} else if (*weak) {

(*weak)->closeBox();

}

};

const auto filter = [=](not_null<Data::SavedSublist*> sublist) {

return guard && (!_filter || _filter(sublist));

};

auto owned = Box<PeerListBox>(

std::make_unique<ChooseSublistBoxController>(

monoforum,

std::move(callback),

filter),

[=](not_null<PeerListBox*> box) {

box->addButton(tr::lng_cancel(), [=] {

box->closeBox();

});

monoforum->destroyed(

) | rpl::on_next([=] {

box->closeBox();

}, box->lifetime());

});

*weak = owned.data();

delegate()->peerListUiShow()->showBox(std::move(owned));

return;

}

const auto history = peer->owner().history(peer);

auto callback = std::move(_callback);

callback(history);

if (guard) {

_callback = std::move(callback);

}

not_null<PeerListController*> controller,

not_null<PeerListRow*> row,

Fn<RecipientMoneyRestrictionError(not_null<UserData*>)> error) {

const auto recipient = static_cast<RecipientRow*>(row.get());

if (!recipient->restriction().premiumRequired) {

return false;

}

::Settings::ShowPremiumPromoToast(

controller->delegate()->peerListUiShow(),

ChatHelpers::ResolveWindowDefault(),

error(row->peer()->asUser()).text,

u"require_premium"_q);

return true;

not_null<History*> history) -> std::unique_ptr<Row> {

const auto peer = history->peer;

const auto skip = _filter

? !_filter(history)

: ((peer->isBroadcast() && !Data::CanSendAnything(peer))

|| peer->isRepliesChat()

|| peer->isVerifyCodes()

|| (peer->isUser() && (_moneyRestrictionError

? !peer->asUser()->canSendIgnoreMoneyRestrictions()

: !Data::CanSendAnything(peer))));

if (skip) {

return nullptr;

}

auto result = std::make_unique<Row>(

history,

_moneyRestrictionError ? &computeListSt().item : nullptr);

return result;

not_null<Data::Forum*> forum)

: _forum(forum)

, _api(&forum->session().mtp())

, _timer([=] { searchOnServer(); }) {

if (_query != query) {

_query = query;

_api.request(base::take(_requestId)).cancel();

_offsetDate = 0;

_offsetId = 0;

_offsetTopicId = 0;

_allLoaded = false;

if (!_query.isEmpty()) {

_timer.callOnce(AutoSearchTimeout);

} else {

_timer.cancel();

}