init

Telegram/SourceFiles/boxes/peers/edit_contact_box.cpp

@@ -0,0 +1,899 @@
+/*
+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 "boxes/peers/edit_contact_box.h"
+
+#include "api/api_peer_photo.h"
+#include "api/api_text_entities.h"
+#include "apiwrap.h"
+#include "base/call_delayed.h"
+#include "boxes/peers/edit_peer_common.h"
+#include "boxes/premium_preview_box.h"
+#include "chat_helpers/tabbed_panel.h"
+#include "chat_helpers/tabbed_selector.h"
+#include "core/application.h"
+#include "core/click_handler_types.h"
+#include "core/ui_integration.h"
+#include "data/data_changes.h"
+#include "data/data_document.h"
+#include "data/data_premium_limits.h"
+#include "data/data_session.h"
+#include "data/data_user.h"
+#include "data/stickers/data_custom_emoji.h"
+#include "data/stickers/data_stickers.h"
+#include "editor/photo_editor_common.h"
+#include "editor/photo_editor_layer_widget.h"
+#include "history/view/controls/history_view_characters_limit.h"
+#include "info/profile/info_profile_cover.h"
+#include "info/userpic/info_userpic_emoji_builder_common.h"
+#include "info/userpic/info_userpic_emoji_builder_menu_item.h"
+#include "lang/lang_keys.h"
+#include "lottie/lottie_common.h"
+#include "lottie/lottie_frame_generator.h"
+#include "main/main_session.h"
+#include "settings/settings_common.h"
+#include "ui/animated_icon.h"
+#include "ui/controls/emoji_button_factory.h"
+#include "ui/controls/emoji_button.h"
+#include "ui/controls/userpic_button.h"
+#include "ui/boxes/confirm_box.h"
+#include "ui/text/format_values.h" // Ui::FormatPhone
+#include "ui/text/text_entity.h"
+#include "ui/text/text_utilities.h"
+#include "ui/toast/toast.h"
+#include "ui/vertical_list.h"
+#include "ui/widgets/checkbox.h"
+#include "ui/widgets/fields/input_field.h"
+#include "ui/widgets/labels.h"
+#include "ui/widgets/popup_menu.h"
+#include "ui/wrap/vertical_layout.h"
+#include "ui/wrap/slide_wrap.h"
+#include "ui/painter.h"
+#include "window/window_controller.h"
+#include "window/window_session_controller.h"
+#include "styles/style_boxes.h"
+#include "styles/style_chat_helpers.h"
+#include "styles/style_info.h"
+#include "styles/style_layers.h"
+#include "styles/style_menu_icons.h"
+#include "styles/style_settings.h"
+#include "styles/style_widgets.h"
+
+#include <QtGui/QClipboard>
+#include <QtGui/QGuiApplication>
+
+namespace {
+
+constexpr auto kAnimationStartFrame = 0;
+constexpr auto kAnimationEndFrame = 21;
+
+QString UserPhone(not_null<UserData*> user) {
+	const auto phone = user->phone();
+	return phone.isEmpty()
+		? user->owner().findContactPhone(peerToUser(user->id))
+		: phone;
+}
+
+void SendRequest(
+		base::weak_qptr<Ui::GenericBox> box,
+		not_null<UserData*> user,
+		bool sharePhone,
+		const QString &first,
+		const QString &last,
+		const QString &phone,
+		const TextWithEntities &note,
+		Fn<void()> done) {
+	const auto wasContact = user->isContact();
+	using Flag = MTPcontacts_AddContact::Flag;
+	user->session().api().request(MTPcontacts_AddContact(
+		MTP_flags(Flag::f_note
+			| (sharePhone ? Flag::f_add_phone_privacy_exception : Flag(0))),
+		user->inputUser(),
+		MTP_string(first),
+		MTP_string(last),
+		MTP_string(phone),
+		note.text.isEmpty()
+			? MTPTextWithEntities()
+			: MTP_textWithEntities(
+				MTP_string(note.text),
+				Api::EntitiesToMTP(&user->session(), note.entities))
+	)).done([=](const MTPUpdates &result) {
+		user->setName(
+			first,
+			last,
+			user->nameOrPhone,
+			user->username());
+		user->session().api().applyUpdates(result);
+		if (const auto settings = user->barSettings()) {
+			const auto flags = PeerBarSetting::AddContact
+				| PeerBarSetting::BlockContact
+				| PeerBarSetting::ReportSpam;
+			user->setBarSettings(*settings & ~flags);
+		}
+		if (box) {
+			if (!wasContact) {
+				box->showToast(
+					tr::lng_new_contact_add_done(tr::now, lt_user, first));
+			}
+			box->closeBox();
+		}
+		done();
+	}).send();
+}
+
+class Controller {
+public:
+	Controller(
+		not_null<Ui::GenericBox*> box,
+		not_null<Window::SessionController*> window,
+		not_null<UserData*> user,
+		bool focusOnNotes = false);
+
+	void prepare();
+
+private:
+	void setupContent();
+	void setupCover();
+	void setupNameFields();
+	void setupNotesField();
+	void setupPhotoButtons();
+	void setupDeleteContactButton();
+	void setupWarning();
+	void setupSharePhoneNumber();
+	void initNameFields(
+		not_null<Ui::InputField*> first,
+		not_null<Ui::InputField*> last,
+		bool inverted);
+	void showPhotoMenu(bool suggest);
+	void choosePhotoFile(bool suggest);
+	void processChosenPhoto(QImage &&image, bool suggest);
+	void processChosenPhotoWithMarkup(
+		UserpicBuilder::Result &&data,
+		bool suggest);
+	void executeWithDelay(
+		Fn<void()> callback,
+		bool suggest,
+		bool startAnimation = true);
+	void finishIconAnimation(bool suggest);
+
+	not_null<Ui::GenericBox*> _box;
+	not_null<Window::SessionController*> _window;
+	not_null<UserData*> _user;
+	bool _focusOnNotes = false;
+	Ui::Checkbox *_sharePhone = nullptr;
+	Ui::InputField *_notesField = nullptr;
+	Ui::InputField *_firstNameField = nullptr;
+	base::unique_qptr<ChatHelpers::TabbedPanel> _emojiPanel;
+	base::unique_qptr<Ui::PopupMenu> _photoMenu;
+	std::unique_ptr<Ui::AnimatedIcon> _suggestIcon;
+	std::unique_ptr<Ui::AnimatedIcon> _cameraIcon;
+	Ui::RpWidget *_suggestIconWidget = nullptr;
+	Ui::RpWidget *_cameraIconWidget = nullptr;
+	QString _phone;
+	Fn<void()> _focus;
+	Fn<void()> _save;
+	Fn<std::optional<QImage>()> _updatedPersonalPhoto;
+
+};
+
+Controller::Controller(
+	not_null<Ui::GenericBox*> box,
+	not_null<Window::SessionController*> window,
+	not_null<UserData*> user,
+	bool focusOnNotes)
+: _box(box)
+, _window(window)
+, _user(user)
+, _focusOnNotes(focusOnNotes)
+, _phone(UserPhone(user)) {
+}
+
+void Controller::prepare() {
+	setupContent();
+
+	_box->setTitle(_user->isContact()
+		? tr::lng_edit_contact_title()
+		: tr::lng_enter_contact_data());
+
+	_box->addButton(tr::lng_box_done(), _save);
+	_box->addButton(tr::lng_cancel(), [=] { _box->closeBox(); });
+	_box->setFocusCallback(_focus);
+}
+
+void Controller::setupContent() {
+	setupCover();
+	setupNameFields();
+	setupNotesField();
+	setupPhotoButtons();
+	setupDeleteContactButton();
+	setupWarning();
+	setupSharePhoneNumber();
+}
+
+void Controller::setupCover() {
+	const auto cover = _box->addRow(
+		object_ptr<Info::Profile::Cover>(
+			_box,
+			_window,
+			_user,
+			Info::Profile::Cover::Role::EditContact,
+			(_phone.isEmpty()
+				? tr::lng_contact_mobile_hidden()
+				: rpl::single(Ui::FormatPhone(_phone)))),
+		style::margins());
+	_updatedPersonalPhoto = [=] { return cover->updatedPersonalPhoto(); };
+}
+
+void Controller::setupNameFields() {
+	const auto inverted = langFirstNameGoesSecond();
+	_firstNameField = _box->addRow(
+		object_ptr<Ui::InputField>(
+			_box,
+			st::defaultInputField,
+			tr::lng_signup_firstname(),
+			_user->firstName),
+		st::addContactFieldMargin);
+	const auto first = _firstNameField;
+	auto preparedLast = object_ptr<Ui::InputField>(
+		_box,
+		st::defaultInputField,
+		tr::lng_signup_lastname(),
+		_user->lastName);
+	const auto last = inverted
+		? _box->insertRow(
+			_box->rowsCount() - 1,
+			std::move(preparedLast),
+			st::addContactFieldMargin)
+		: _box->addRow(std::move(preparedLast), st::addContactFieldMargin);
+
+	initNameFields(first, last, inverted);
+}
+
+void Controller::initNameFields(
+		not_null<Ui::InputField*> first,
+		not_null<Ui::InputField*> last,
+		bool inverted) {
+	const auto getValue = [](not_null<Ui::InputField*> field) {
+		return TextUtilities::SingleLine(field->getLastText()).trimmed();
+	};
+
+	if (inverted) {
+		_box->setTabOrder(last, first);
+	}
+	_focus = [=] {
+		if (_focusOnNotes && _notesField) {
+			_notesField->setFocusFast();
+			_notesField->setCursorPosition(_notesField->getLastText().size());
+			return;
+		}
+		const auto firstValue = getValue(first);
+		const auto lastValue = getValue(last);
+		const auto empty = firstValue.isEmpty() && lastValue.isEmpty();
+		const auto focusFirst = (inverted != empty);
+		(focusFirst ? first : last)->setFocusFast();
+	};
+	_save = [=] {
+		const auto firstValue = getValue(first);
+		const auto lastValue = getValue(last);
+		const auto empty = firstValue.isEmpty() && lastValue.isEmpty();
+		if (empty) {
+			_focus();
+			(inverted ? last : first)->showError();
+			return;
+		}
+
+		if (_notesField) {
+			const auto limit = Data::PremiumLimits(
+				&_user->session()).contactNoteLengthCurrent();
+			const auto remove = Ui::ComputeFieldCharacterCount(_notesField)
+				- limit;
+			if (remove > 0) {
+				_box->showToast(tr::lng_contact_notes_limit_reached(
+					tr::now,
+					lt_count,
+					remove));
+				_notesField->setFocus();
+				return;
+			}
+		}
+
+		const auto user = _user;
+		const auto personal = _updatedPersonalPhoto
+			? _updatedPersonalPhoto()
+			: std::nullopt;
+		const auto done = [=] {
+			if (personal) {
+				if (personal->isNull()) {
+					user->session().api().peerPhoto().clearPersonal(user);
+				} else {
+					user->session().api().peerPhoto().upload(
+						user,
+						{ base::duplicate(*personal) });
+				}
+			}
+		};
+		const auto noteValue = _notesField
+			? [&] {
+				auto textWithTags = _notesField->getTextWithAppliedMarkdown();
+				return TextWithEntities{
+					base::take(textWithTags.text),
+					TextUtilities::ConvertTextTagsToEntities(
+						base::take(textWithTags.tags)),
+				};
+			}()
+			: TextWithEntities();
+		SendRequest(
+			base::make_weak(_box),
+			user,
+			_sharePhone && _sharePhone->checked(),
+			firstValue,
+			lastValue,
+			_phone,
+			noteValue,
+			done);
+	};
+	const auto submit = [=] {
+		const auto firstValue = first->getLastText().trimmed();
+		const auto lastValue = last->getLastText().trimmed();
+		const auto empty = firstValue.isEmpty() && lastValue.isEmpty();
+		if (inverted ? last->hasFocus() : empty) {
+			first->setFocus();
+		} else if (inverted ? empty : first->hasFocus()) {
+			last->setFocus();
+		} else {
+			_save();
+		}
+	};
+	first->submits() | rpl::on_next(submit, first->lifetime());
+	last->submits() | rpl::on_next(submit, last->lifetime());
+	first->setMaxLength(Ui::EditPeer::kMaxUserFirstLastName);
+	first->setMaxLength(Ui::EditPeer::kMaxUserFirstLastName);
+}
+
+void Controller::setupWarning() {
+	if (_user->isContact() || !_phone.isEmpty()) {
+		return;
+	}
+	_box->addRow(
+		object_ptr<Ui::FlatLabel>(
+			_box,
+			tr::lng_contact_phone_after(tr::now, lt_user, _user->shortName()),
+			st::changePhoneLabel),
+		st::addContactWarningMargin);
+}
+
+void Controller::setupNotesField() {
+	Ui::AddSkip(_box->verticalLayout());
+	Ui::AddDivider(_box->verticalLayout());
+	Ui::AddSkip(_box->verticalLayout());
+	_notesField = _box->addRow(
+		object_ptr<Ui::InputField>(
+			_box,
+			st::notesFieldWithEmoji,
+			Ui::InputField::Mode::MultiLine,
+			tr::lng_contact_add_notes(),
+			QString()),
+		st::addContactFieldMargin);
+	_notesField->setMarkdownSet(Ui::MarkdownSet::Notes);
+	_notesField->setCustomTextContext(Core::TextContext({
+		.session = &_user->session()
+	}));
+	_notesField->setTextWithTags({
+		_user->note().text,
+		TextUtilities::ConvertEntitiesToTextTags(_user->note().entities)
+	});
+
+	_notesField->setMarkdownReplacesEnabled(rpl::single(
+		Ui::MarkdownEnabledState{
+			Ui::MarkdownEnabled{
+				{
+					Ui::InputField::kTagBold,
+					Ui::InputField::kTagItalic,
+					Ui::InputField::kTagUnderline,
+					Ui::InputField::kTagStrikeOut,
+					Ui::InputField::kTagSpoiler
+				}
+			}
+		}
+	));
+
+	const auto container = _box->getDelegate()->outerContainer();
+	using Selector = ChatHelpers::TabbedSelector;
+	_emojiPanel = base::make_unique_q<ChatHelpers::TabbedPanel>(
+		container,
+		_window,
+		object_ptr<Selector>(
+			nullptr,
+			_window->uiShow(),
+			Window::GifPauseReason::Layer,
+			Selector::Mode::EmojiOnly));
+	_emojiPanel->setDesiredHeightValues(
+		1.,
+		st::emojiPanMinHeight / 2,
+		st::emojiPanMinHeight);
+	_emojiPanel->hide();
+	_emojiPanel->selector()->setCurrentPeer(_window->session().user());
+	_emojiPanel->selector()->emojiChosen(
+	) | rpl::on_next([=](ChatHelpers::EmojiChosen data) {
+		Ui::InsertEmojiAtCursor(_notesField->textCursor(), data.emoji);
+	}, _notesField->lifetime());
+	_emojiPanel->selector()->customEmojiChosen(
+	) | rpl::on_next([=](ChatHelpers::FileChosen data) {
+		const auto info = data.document->sticker();
+		if (info
+			&& info->setType == Data::StickersType::Emoji
+			&& !_window->session().premium()) {
+			ShowPremiumPreviewBox(
+				_window,
+				PremiumFeature::AnimatedEmoji);
+		} else {
+			Data::InsertCustomEmoji(_notesField, data.document);
+		}
+	}, _notesField->lifetime());
+
+	const auto emojiButton = Ui::AddEmojiToggleToField(
+		_notesField,
+		_box,
+		_window,
+		_emojiPanel.get(),
+		st::sendGifWithCaptionEmojiPosition);
+	emojiButton->show();
+
+	using Limit = HistoryView::Controls::CharactersLimitLabel;
+	struct LimitState {
+		base::unique_qptr<Limit> charsLimitation;
+	};
+	const auto limitState = _notesField->lifetime().make_state<LimitState>();
+
+	const auto checkCharsLimitation = [=, w = _notesField->window()] {
+		const auto limit = Data::PremiumLimits(
+			&_user->session()).contactNoteLengthCurrent();
+		const auto remove = Ui::ComputeFieldCharacterCount(_notesField)
+			- limit;
+		if (!limitState->charsLimitation) {
+			const auto border = _notesField->st().borderActive;
+			limitState->charsLimitation = base::make_unique_q<Limit>(
+				_box->verticalLayout(),
+				emojiButton,
+				style::al_top,
+				QMargins{ 0, -border - _notesField->st().border, 0, 0 });
+			rpl::combine(
+				limitState->charsLimitation->geometryValue(),
+				_notesField->geometryValue()
+			) | rpl::on_next([=](QRect limit, QRect field) {
+				limitState->charsLimitation->setVisible(
+					(w->mapToGlobal(limit.bottomLeft()).y() - border)
+						< w->mapToGlobal(field.bottomLeft()).y());
+				limitState->charsLimitation->raise();
+			}, limitState->charsLimitation->lifetime());
+		}
+		limitState->charsLimitation->setLeft(remove);
+	};
+
+	_notesField->changes() | rpl::on_next([=] {
+		checkCharsLimitation();
+	}, _notesField->lifetime());
+
+	Ui::AddDividerText(
+		_box->verticalLayout(),
+		tr::lng_contact_add_notes_about());
+}
+
+void Controller::setupPhotoButtons() {
+	if (!_user->isContact()) {
+		return;
+	}
+	const auto iconPlaceholder = st::restoreUserpicIcon.size * 2;
+	auto nameValue = _firstNameField
+		? rpl::merge(
+			rpl::single(_firstNameField->getLastText().trimmed()),
+			_firstNameField->changes() | rpl::map([=] {
+				return _firstNameField->getLastText().trimmed();
+		})) | rpl::map([=](const QString &text) {
+			return text.isEmpty() ? Ui::kQEllipsis : text;
+		})
+		: rpl::single(_user->shortName()) | rpl::type_erased;
+	const auto inner = _box->verticalLayout();
+	Ui::AddSkip(inner);
+
+	const auto suggestBirthdayWrap = inner->add(
+		object_ptr<Ui::SlideWrap<Ui::VerticalLayout>>(
+			inner,
+			object_ptr<Ui::VerticalLayout>(inner)));
+
+	const auto suggestBirthdayButton = Settings::AddButtonWithIcon(
+		suggestBirthdayWrap->entity(),
+		tr::lng_suggest_birthday(),
+		st::settingsButtonLight,
+		{ &st::editContactSuggestBirthday });
+	suggestBirthdayButton->setClickedCallback([=] {
+		Core::App().openInternalUrl(
+			u"internal:edit_birthday:suggest:%1"_q.arg(
+				peerToUser(_user->id).bare),
+			QVariant::fromValue(ClickHandlerContext{
+				.sessionWindow = base::make_weak(_window),
+			}));
+	});
+	suggestBirthdayWrap->toggleOn(rpl::single(!_user->birthday().valid()
+		&& !_user->starsPerMessageChecked()));
+
+	_suggestIcon = Ui::MakeAnimatedIcon({
+		.generator = [] {
+			return std::make_unique<Lottie::FrameGenerator>(
+				Lottie::ReadContent(
+					QByteArray(),
+					u":/animations/photo_suggest_icon.tgs"_q));
+		},
+		.sizeOverride = iconPlaceholder,
+		.colorized = true,
+	});
+
+	_cameraIcon = Ui::MakeAnimatedIcon({
+		.generator = [] {
+			return std::make_unique<Lottie::FrameGenerator>(
+				Lottie::ReadContent(
+					QByteArray(),
+					u":/animations/camera_outline.tgs"_q));
+		},
+		.sizeOverride = iconPlaceholder,
+		.colorized = true,
+	});
+
+	const auto suggestButtonWrap = inner->add(
+		object_ptr<Ui::SlideWrap<Ui::VerticalLayout>>(
+			inner,
+			object_ptr<Ui::VerticalLayout>(inner)));
+	suggestButtonWrap->toggleOn(
+		rpl::single(!_user->starsPerMessageChecked()));
+
+	const auto suggestButton = Settings::AddButtonWithIcon(
+		suggestButtonWrap->entity(),
+		tr::lng_suggest_photo_for(lt_user, rpl::duplicate(nameValue)),
+		st::settingsButtonLight,
+		{ nullptr });
+
+	_suggestIconWidget = Ui::CreateChild<Ui::RpWidget>(suggestButton);
+	_suggestIconWidget->resize(iconPlaceholder);
+	_suggestIconWidget->paintRequest() | rpl::on_next([=] {
+		if (_suggestIcon && _suggestIcon->valid()) {
+			auto p = QPainter(_suggestIconWidget);
+			const auto frame = _suggestIcon->frame(st::lightButtonFg->c);
+			p.drawImage(_suggestIconWidget->rect(), frame);
+		}
+	}, _suggestIconWidget->lifetime());
+
+	suggestButton->sizeValue() | rpl::on_next([=](QSize size) {
+		_suggestIconWidget->move(
+			st::settingsButtonLight.iconLeft - iconPlaceholder.width() / 4,
+			(size.height() - _suggestIconWidget->height()) / 2);
+	}, _suggestIconWidget->lifetime());
+
+	suggestButton->setClickedCallback([=] {
+		if (_suggestIcon && _suggestIcon->valid()) {
+			_suggestIcon->setCustomStartFrame(kAnimationStartFrame);
+			_suggestIcon->setCustomEndFrame(kAnimationEndFrame);
+			_suggestIcon->jumpToStart([=] { _suggestIconWidget->update(); });
+			_suggestIcon->animate([=] { _suggestIconWidget->update(); });
+		}
+		showPhotoMenu(true);
+	});
+
+	const auto setButton = Settings::AddButtonWithIcon(
+		inner,
+		tr::lng_set_photo_for_user(lt_user, rpl::duplicate(nameValue)),
+		st::settingsButtonLight,
+		{ nullptr });
+
+	_cameraIconWidget = Ui::CreateChild<Ui::RpWidget>(setButton);
+	_cameraIconWidget->resize(iconPlaceholder);
+	_cameraIconWidget->paintRequest() | rpl::on_next([=] {
+		if (_cameraIcon && _cameraIcon->valid()) {
+			auto p = QPainter(_cameraIconWidget);
+			const auto frame = _cameraIcon->frame(st::lightButtonFg->c);
+			p.drawImage(_cameraIconWidget->rect(), frame);
+		}
+	}, _cameraIconWidget->lifetime());
+
+	setButton->sizeValue() | rpl::on_next([=](QSize size) {
+		_cameraIconWidget->move(
+			st::settingsButtonLight.iconLeft - iconPlaceholder.width() / 4,
+			(size.height() - _cameraIconWidget->height()) / 2);
+	}, _cameraIconWidget->lifetime());
+
+	setButton->setClickedCallback([=] {
+		if (_cameraIcon && _cameraIcon->valid()) {
+			_cameraIcon->setCustomStartFrame(kAnimationStartFrame);
+			_cameraIcon->setCustomEndFrame(kAnimationEndFrame);
+			_cameraIcon->jumpToStart([=] { _cameraIconWidget->update(); });
+			_cameraIcon->animate([=] { _cameraIconWidget->update(); });
+		}
+		showPhotoMenu(false);
+	});
+
+	const auto resetButtonWrap = inner->add(
+		object_ptr<Ui::SlideWrap<Ui::VerticalLayout>>(
+			inner,
+			object_ptr<Ui::VerticalLayout>(inner)));
+
+	const auto resetButton = Settings::AddButtonWithIcon(
+		resetButtonWrap->entity(),
+		tr::lng_profile_photo_reset(),
+		st::settingsButtonLight,
+		{ nullptr });
+
+	const auto userpicButton = Ui::CreateChild<Ui::UserpicButton>(
+		resetButton,
+		_window,
+		_user,
+		Ui::UserpicButton::Role::Custom,
+		Ui::UserpicButton::Source::NonPersonalIfHasPersonal,
+		st::restoreUserpicIcon);
+	userpicButton->setAttribute(Qt::WA_TransparentForMouseEvents);
+
+	resetButton->sizeValue(
+	) | rpl::on_next([=](QSize size) {
+		userpicButton->move(
+			st::settingsButtonLight.iconLeft,
+			(size.height() - userpicButton->height()) / 2);
+	}, userpicButton->lifetime());
+	resetButtonWrap->toggleOn(
+		_user->session().changes().peerFlagsValue(
+			_user,
+			Data::PeerUpdate::Flag::FullInfo | Data::PeerUpdate::Flag::Photo
+		) | rpl::map([=] {
+			return _user->hasPersonalPhoto();
+		}) | rpl::distinct_until_changed());
+
+	resetButton->setClickedCallback([=] {
+		_window->show(Ui::MakeConfirmBox({
+			.text = tr::lng_profile_photo_reset_sure(
+				tr::now,
+				lt_user,
+				_user->shortName()),
+			.confirmed = [=](Fn<void()> close) {
+				_window->session().api().peerPhoto().clearPersonal(_user);
+				close();
+			},
+			.confirmText = tr::lng_profile_photo_reset_button(tr::now),
+		}));
+	});
+
+	Ui::AddSkip(inner);
+
+	Ui::AddDividerText(
+		inner,
+		tr::lng_contact_photo_replace_info(lt_user, std::move(nameValue)));
+	Ui::AddSkip(inner);
+}
+
+void Controller::setupDeleteContactButton() {
+	if (!_user->isContact()) {
+		return;
+	}
+	const auto inner = _box->verticalLayout();
+	const auto deleteButton = Settings::AddButtonWithIcon(
+		inner,
+		tr::lng_info_delete_contact(),
+		st::settingsAttentionButton,
+		{ nullptr });
+	deleteButton->setClickedCallback([=] {
+		const auto text = tr::lng_sure_delete_contact(
+			tr::now,
+			lt_contact,
+			_user->name());
+		const auto deleteSure = [=](Fn<void()> &&close) {
+			close();
+			_user->session().api().request(MTPcontacts_DeleteContacts(
+				MTP_vector<MTPInputUser>(1, _user->inputUser())
+			)).done([=](const MTPUpdates &result) {
+				_user->session().api().applyUpdates(result);
+				_box->closeBox();
+			}).send();
+		};
+		_window->show(Ui::MakeConfirmBox({
+			.text = text,
+			.confirmed = deleteSure,
+			.confirmText = tr::lng_box_delete(),
+			.confirmStyle = &st::attentionBoxButton,
+		}));
+	});
+	Ui::AddSkip(inner);
+}
+
+void Controller::setupSharePhoneNumber() {
+	const auto settings = _user->barSettings();
+	if (!settings
+		|| !((*settings) & PeerBarSetting::NeedContactsException)) {
+		return;
+	}
+	_sharePhone = _box->addRow(
+		object_ptr<Ui::Checkbox>(
+			_box,
+			tr::lng_contact_share_phone(tr::now),
+			true,
+			st::defaultBoxCheckbox),
+		st::addContactWarningMargin);
+	_box->addRow(
+		object_ptr<Ui::FlatLabel>(
+			_box,
+			tr::lng_contact_phone_will_be_shared(tr::now, lt_user, _user->shortName()),
+			st::changePhoneLabel),
+		st::addContactWarningMargin);
+
+}
+
+void Controller::showPhotoMenu(bool suggest) {
+	_photoMenu = base::make_unique_q<Ui::PopupMenu>(
+		_box,
+		st::popupMenuWithIcons);
+
+	QObject::connect(_photoMenu.get(), &QObject::destroyed, [=] {
+		finishIconAnimation(suggest);
+	});
+
+	_photoMenu->addAction(
+		tr::lng_attach_photo(tr::now),
+		[=] { executeWithDelay([=] { choosePhotoFile(suggest); }, suggest); },
+		&st::menuIconPhoto);
+
+	if (const auto data = QGuiApplication::clipboard()->mimeData()) {
+		if (data->hasImage()) {
+			auto callback = [=] {
+				Editor::PrepareProfilePhoto(
+					_box,
+					&_window->window(),
+					Editor::EditorData{
+						.about = (suggest
+							? tr::lng_profile_suggest_sure(
+								tr::now,
+								lt_user,
+								tr::bold(_user->shortName()),
+								tr::marked)
+							: tr::lng_profile_set_personal_sure(
+								tr::now,
+								lt_user,
+								tr::bold(_user->shortName()),
+								tr::marked)),
+						.confirm = (suggest
+							? tr::lng_profile_suggest_button(tr::now)
+							: tr::lng_profile_set_photo_button(tr::now)),
+						.cropType = Editor::EditorData::CropType::Ellipse,
+						.keepAspectRatio = true,
+					},
+					[=](QImage &&editedImage) {
+						processChosenPhoto(std::move(editedImage), suggest);
+					},
+					qvariant_cast<QImage>(data->imageData()));
+			};
+			_photoMenu->addAction(
+				tr::lng_profile_photo_from_clipboard(tr::now),
+				[=] { executeWithDelay(callback, suggest); },
+				&st::menuIconPhoto);
+		}
+	}
+
+	UserpicBuilder::AddEmojiBuilderAction(
+		_window,
+		_photoMenu.get(),
+		_window->session().api().peerPhoto().emojiListValue(
+			Api::PeerPhoto::EmojiListType::Profile),
+		[=](UserpicBuilder::Result data) {
+			processChosenPhotoWithMarkup(std::move(data), suggest);
+		},
+		false);
+
+	_photoMenu->popup(QCursor::pos());
+}
+
+void Controller::choosePhotoFile(bool suggest) {
+	Editor::PrepareProfilePhotoFromFile(
+		_box,
+		&_window->window(),
+		Editor::EditorData{
+			.about = (suggest
+				? tr::lng_profile_suggest_sure(
+					tr::now,
+					lt_user,
+					tr::bold(_user->shortName()),
+					tr::marked)
+				: tr::lng_profile_set_personal_sure(
+					tr::now,
+					lt_user,
+					tr::bold(_user->shortName()),
+					tr::marked)),
+			.confirm = (suggest
+				? tr::lng_profile_suggest_button(tr::now)
+				: tr::lng_profile_set_photo_button(tr::now)),
+			.cropType = Editor::EditorData::CropType::Ellipse,
+			.keepAspectRatio = true,
+		},
+		[=](QImage &&image) {
+			processChosenPhoto(std::move(image), suggest);
+		});
+}
+
+void Controller::processChosenPhoto(QImage &&image, bool suggest) {
+	Api::PeerPhoto::UserPhoto photo{
+		.image = base::duplicate(image),
+	};
+	if (suggest) {
+		_window->session().api().peerPhoto().suggest(_user, std::move(photo));
+		_window->showPeerHistory(_user->id);
+	} else {
+		_window->session().api().peerPhoto().upload(_user, std::move(photo));
+	}
+}
+
+void Controller::processChosenPhotoWithMarkup(
+		UserpicBuilder::Result &&data,
+		bool suggest) {
+	Api::PeerPhoto::UserPhoto photo{
+		.image = std::move(data.image),
+		.markupDocumentId = data.id,
+		.markupColors = std::move(data.colors),
+	};
+	if (suggest) {
+		_window->session().api().peerPhoto().suggest(_user, std::move(photo));
+		_window->showPeerHistory(_user->id);
+	} else {
+		_window->session().api().peerPhoto().upload(_user, std::move(photo));
+	}
+}
+
+void Controller::finishIconAnimation(bool suggest) {
+	const auto icon = suggest ? _suggestIcon.get() : _cameraIcon.get();
+	const auto widget = suggest ? _suggestIconWidget : _cameraIconWidget;
+	if (icon && icon->valid()) {
+		icon->setCustomStartFrame(icon->frameIndex());
+		icon->setCustomEndFrame(-1);
+		icon->animate([=] { widget->update(); });
+	}
+}
+
+void Controller::executeWithDelay(
+		Fn<void()> callback,
+		bool suggest,
+		bool startAnimation) {
+	const auto icon = suggest ? _suggestIcon.get() : _cameraIcon.get();
+	const auto widget = suggest ? _suggestIconWidget : _cameraIconWidget;
+
+	if (startAnimation && icon && icon->valid()) {
+		icon->setCustomStartFrame(icon->frameIndex());
+		icon->setCustomEndFrame(-1);
+		icon->animate([=] { widget->update(); });
+	}
+
+	if (icon && icon->valid() && icon->animating()) {
+		base::call_delayed(50, [=] {
+			executeWithDelay(callback, suggest, false);
+		});
+	} else {
+		callback();
+	}
+}
+
+} // namespace
+
+void EditContactBox(
+		not_null<Ui::GenericBox*> box,
+		not_null<Window::SessionController*> window,
+		not_null<UserData*> user) {
+	box->setWidth(st::boxWideWidth);
+	box->lifetime().make_state<Controller>(box, window, user)->prepare();
+}
+
+void EditContactNoteBox(
+		not_null<Ui::GenericBox*> box,
+		not_null<Window::SessionController*> window,
+		not_null<UserData*> user) {
+	box->setWidth(st::boxWideWidth);
+	box->lifetime().make_state<Controller>(
+		box,
+		window,
+		user,
+		true)->prepare();
+}