507 lines
15 KiB
C++
507 lines
15 KiB
C++
/*
|
|
This file is part of Telegram Desktop,
|
|
the official desktop version of Telegram messaging app, see https://telegram.org
|
|
|
|
Telegram Desktop is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
It is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
In addition, as a special exception, the copyright holders give permission
|
|
to link the code of portions of this program with the OpenSSL library.
|
|
|
|
Full license: https://github.com/telegramdesktop/tdesktop/blob/master/LICENSE
|
|
Copyright (c) 2014-2017 John Preston, https://desktop.telegram.org
|
|
*/
|
|
#include "info/profile/info_profile_inner_widget.h"
|
|
|
|
#include <rpl/combine.h>
|
|
#include <rpl/flatten_latest.h>
|
|
#include "info/profile/info_profile_button.h"
|
|
#include "info/profile/info_profile_widget.h"
|
|
#include "info/profile/info_profile_text.h"
|
|
#include "info/profile/info_profile_values.h"
|
|
#include "info/profile/info_profile_cover.h"
|
|
#include "info/profile/info_profile_icon.h"
|
|
#include "info/profile/info_profile_members.h"
|
|
#include "boxes/abstract_box.h"
|
|
#include "boxes/add_contact_box.h"
|
|
#include "boxes/confirm_box.h"
|
|
#include "mainwidget.h"
|
|
#include "auth_session.h"
|
|
#include "apiwrap.h"
|
|
#include "window/window_controller.h"
|
|
#include "storage/storage_shared_media.h"
|
|
#include "lang/lang_keys.h"
|
|
#include "styles/style_info.h"
|
|
#include "styles/style_boxes.h"
|
|
#include "ui/widgets/buttons.h"
|
|
#include "ui/widgets/checkbox.h"
|
|
#include "ui/widgets/scroll_area.h"
|
|
#include "ui/wrap/slide_wrap.h"
|
|
#include "ui/wrap/vertical_layout.h"
|
|
#include "history/history_shared_media.h"
|
|
#include "profile/profile_common_groups_section.h"
|
|
|
|
namespace Info {
|
|
namespace Profile {
|
|
|
|
InnerWidget::InnerWidget(
|
|
QWidget *parent,
|
|
rpl::producer<Wrap> &&wrapValue,
|
|
not_null<Window::Controller*> controller,
|
|
not_null<PeerData*> peer)
|
|
: RpWidget(parent)
|
|
, _controller(controller)
|
|
, _peer(peer)
|
|
, _content(setupContent(this, std::move(wrapValue))) {
|
|
_content->heightValue()
|
|
| rpl::start([this](int height) {
|
|
TWidget::resizeToWidth(width());
|
|
_desiredHeight.fire(countDesiredHeight());
|
|
}, lifetime());
|
|
}
|
|
|
|
bool InnerWidget::canHideDetailsEver() const {
|
|
return (_peer->isChat() || _peer->isMegagroup());
|
|
}
|
|
|
|
rpl::producer<bool> InnerWidget::canHideDetails() const {
|
|
using namespace rpl::mappers;
|
|
return MembersCountValue(_peer)
|
|
| rpl::map($1 > 0);
|
|
}
|
|
|
|
object_ptr<Ui::RpWidget> InnerWidget::setupContent(
|
|
RpWidget *parent,
|
|
rpl::producer<Wrap> &&wrapValue) {
|
|
auto result = object_ptr<Ui::VerticalLayout>(parent);
|
|
auto cover = result->add(object_ptr<Cover>(
|
|
result,
|
|
_peer)
|
|
);
|
|
cover->setOnlineCount(rpl::single(0));
|
|
auto details = setupDetails(parent);
|
|
if (canHideDetailsEver()) {
|
|
cover->setToggleShown(canHideDetails());
|
|
result->add(object_ptr<Ui::SlideWrap<>>(
|
|
result,
|
|
std::move(details))
|
|
)->toggleOn(cover->toggledValue());
|
|
} else {
|
|
result->add(std::move(details));
|
|
}
|
|
result->add(setupSharedMedia(result));
|
|
result->add(object_ptr<BoxContentDivider>(result));
|
|
if (auto user = _peer->asUser()) {
|
|
result->add(setupUserActions(result, user));
|
|
//} else if (auto channel = _peer->asChannel()) {
|
|
// if (!channel->isMegagroup()) {
|
|
// setupChannelActions(result, channel);
|
|
// }
|
|
}
|
|
if (_peer->isChat() || _peer->isMegagroup()) {
|
|
_members = result->add(object_ptr<Members>(
|
|
result,
|
|
_controller,
|
|
std::move(wrapValue),
|
|
_peer)
|
|
);
|
|
_members->scrollToRequests()
|
|
| rpl::start([this](Ui::ScrollToRequest request) {
|
|
auto min = (request.ymin < 0)
|
|
? request.ymin
|
|
: mapFromGlobal(_members->mapToGlobal({ 0, request.ymin })).y();
|
|
auto max = (request.ymin < 0)
|
|
? mapFromGlobal(_members->mapToGlobal({ 0, 0 })).y()
|
|
: (request.ymax < 0)
|
|
? request.ymax
|
|
: mapFromGlobal(_members->mapToGlobal({ 0, request.ymax })).y();
|
|
_scrollToRequests.fire({ min, max });
|
|
}, _members->lifetime());
|
|
}
|
|
return std::move(result);
|
|
}
|
|
|
|
object_ptr<Ui::RpWidget> InnerWidget::setupDetails(
|
|
RpWidget *parent) const {
|
|
auto result = object_ptr<Ui::VerticalLayout>(parent);
|
|
result->add(object_ptr<BoxContentDivider>(result));
|
|
result->add(createSkipWidget(result));
|
|
result->add(setupInfo(result));
|
|
result->add(setupMuteToggle(result));
|
|
if (auto user = _peer->asUser()) {
|
|
setupUserButtons(result, user);
|
|
//} else if (auto channel = _peer->asChannel()) {
|
|
// if (!channel->isMegagroup()) {
|
|
// setupChannelButtons(result, channel);
|
|
// }
|
|
}
|
|
result->add(createSkipWidget(result));
|
|
return std::move(result);
|
|
}
|
|
|
|
object_ptr<Ui::RpWidget> InnerWidget::setupInfo(
|
|
RpWidget *parent) const {
|
|
auto result = object_ptr<Ui::VerticalLayout>(parent);
|
|
auto tracker = MultiLineTracker();
|
|
auto addInfoLine = [&](
|
|
LangKey label,
|
|
rpl::producer<TextWithEntities> &&text,
|
|
bool selectByDoubleClick = false,
|
|
const style::FlatLabel &textSt = st::infoLabeled) {
|
|
auto line = result->add(CreateTextWithLabel(
|
|
result,
|
|
Lang::Viewer(label) | WithEmptyEntities(),
|
|
std::move(text),
|
|
textSt,
|
|
st::infoProfileLabeledPadding,
|
|
selectByDoubleClick));
|
|
tracker.track(line);
|
|
return line;
|
|
};
|
|
auto addInfoOneLine = [&](
|
|
LangKey label,
|
|
rpl::producer<TextWithEntities> &&text) {
|
|
addInfoLine(
|
|
label,
|
|
std::move(text),
|
|
true,
|
|
st::infoLabeledOneLine);
|
|
};
|
|
if (auto user = _peer->asUser()) {
|
|
addInfoOneLine(lng_info_mobile_label, PhoneValue(user));
|
|
addInfoLine(lng_info_bio_label, BioValue(user));
|
|
addInfoOneLine(lng_info_username_label, UsernameValue(user));
|
|
} else {
|
|
addInfoOneLine(lng_info_link_label, LinkValue(_peer));
|
|
addInfoLine(lng_info_about_label, AboutValue(_peer));
|
|
}
|
|
result->add(object_ptr<Ui::SlideWrap<>>(
|
|
result,
|
|
object_ptr<Ui::PlainShadow>(result, st::shadowFg),
|
|
st::infoProfileSeparatorPadding)
|
|
)->toggleOn(std::move(tracker).atLeastOneShownValue());
|
|
object_ptr<FloatingIcon>(
|
|
result,
|
|
st::infoIconInformation,
|
|
st::infoInformationIconPosition);
|
|
return std::move(result);
|
|
}
|
|
|
|
object_ptr<Ui::RpWidget> InnerWidget::setupMuteToggle(
|
|
RpWidget *parent) const {
|
|
auto result = object_ptr<Button>(
|
|
parent,
|
|
Lang::Viewer(lng_profile_enable_notifications),
|
|
st::infoNotificationsButton);
|
|
result->toggleOn(
|
|
NotificationsEnabledValue(_peer)
|
|
)->clicks()
|
|
| rpl::start([this](auto) {
|
|
App::main()->updateNotifySetting(
|
|
_peer,
|
|
_peer->isMuted()
|
|
? NotifySettingSetNotify
|
|
: NotifySettingSetMuted);
|
|
}, result->lifetime());
|
|
object_ptr<FloatingIcon>(
|
|
result,
|
|
st::infoIconNotifications,
|
|
st::infoNotificationsIconPosition);
|
|
return std::move(result);
|
|
}
|
|
|
|
void InnerWidget::setupUserButtons(
|
|
Ui::VerticalLayout *wrap,
|
|
not_null<UserData*> user) const {
|
|
using namespace rpl::mappers;
|
|
auto tracker = MultiLineTracker();
|
|
auto topSkip = wrap->add(createSlideSkipWidget(wrap));
|
|
auto addButton = [&](rpl::producer<QString> &&text) {
|
|
auto result = wrap->add(object_ptr<Ui::SlideWrap<Button>>(
|
|
wrap,
|
|
object_ptr<Button>(
|
|
wrap,
|
|
std::move(text),
|
|
st::infoMainButton)));
|
|
tracker.track(result);
|
|
return result;
|
|
};
|
|
addButton(
|
|
Lang::Viewer(lng_profile_send_message) | ToUpperValue()
|
|
)->toggleOn(
|
|
_controller->historyPeer.value()
|
|
| rpl::map($1 != user)
|
|
)->entity()->clicks()
|
|
| rpl::start([this, user](auto&&) {
|
|
_controller->showPeerHistory(
|
|
user,
|
|
Ui::ShowWay::Forward);
|
|
}, wrap->lifetime());
|
|
|
|
addButton(
|
|
Lang::Viewer(lng_info_add_as_contact) | ToUpperValue()
|
|
)->toggleOn(
|
|
CanAddContactValue(user)
|
|
)->entity()->clicks()
|
|
| rpl::start([user](auto&&) {
|
|
auto firstName = user->firstName;
|
|
auto lastName = user->lastName;
|
|
auto phone = user->phone().isEmpty()
|
|
? App::phoneFromSharedContact(user->bareId())
|
|
: user->phone();
|
|
Ui::show(Box<AddContactBox>(firstName, lastName, phone));
|
|
}, wrap->lifetime());
|
|
|
|
topSkip->toggleOn(std::move(tracker).atLeastOneShownValue());
|
|
}
|
|
|
|
object_ptr<Ui::RpWidget> InnerWidget::setupSharedMedia(
|
|
RpWidget *parent) const {
|
|
using namespace rpl::mappers;
|
|
|
|
auto content = object_ptr<Ui::VerticalLayout>(parent);
|
|
auto tracker = MultiLineTracker();
|
|
auto addButton = [&](
|
|
rpl::producer<int> &&count,
|
|
auto textFromCount) {
|
|
auto forked = std::move(count)
|
|
| start_spawning(content->lifetime());
|
|
auto button = content->add(object_ptr<Ui::SlideWrap<Button>>(
|
|
content,
|
|
object_ptr<Button>(
|
|
content,
|
|
rpl::duplicate(forked)
|
|
| rpl::map([textFromCount](int count) {
|
|
return (count > 0)
|
|
? textFromCount(count)
|
|
: QString();
|
|
}),
|
|
st::infoSharedMediaButton))
|
|
)->toggleOn(
|
|
rpl::duplicate(forked)
|
|
| rpl::map($1 > 0));
|
|
tracker.track(button);
|
|
return button;
|
|
};
|
|
using MediaType = Storage::SharedMediaType;
|
|
auto mediaText = [](MediaType type) {
|
|
switch (type) {
|
|
case MediaType::Photo: return lng_profile_photos;
|
|
case MediaType::Video: return lng_profile_videos;
|
|
case MediaType::File: return lng_profile_files;
|
|
case MediaType::MusicFile: return lng_profile_songs;
|
|
case MediaType::Link: return lng_profile_shared_links;
|
|
case MediaType::VoiceFile: return lng_profile_audios;
|
|
case MediaType::RoundFile: return lng_profile_rounds;
|
|
}
|
|
Unexpected("Type in setupSharedMedia()");
|
|
};
|
|
auto addMediaButton = [&](MediaType type) {
|
|
return addButton(
|
|
SharedMediaCountValue(_peer, type),
|
|
[phrase = mediaText(type)](int count) {
|
|
return phrase(lt_count, count);
|
|
}
|
|
)->entity()->clicks()
|
|
| rpl::start([peer = _peer, type](auto&&) {
|
|
SharedMediaShowOverview(type, App::history(peer));
|
|
}, content->lifetime());
|
|
};
|
|
auto addCommonGroupsButton = [&](not_null<UserData*> user) {
|
|
return addButton(
|
|
CommonGroupsCountValue(user),
|
|
[](int count) {
|
|
return lng_profile_common_groups(lt_count, count);
|
|
}
|
|
)->entity()->clicks()
|
|
| rpl::start([peer = _peer](auto&&) {
|
|
App::main()->showSection(
|
|
::Profile::CommonGroups::SectionMemento(
|
|
peer->asUser()),
|
|
anim::type::normal,
|
|
anim::activation::normal);
|
|
}, content->lifetime());
|
|
};
|
|
addMediaButton(MediaType::Photo);
|
|
addMediaButton(MediaType::Video);
|
|
addMediaButton(MediaType::File);
|
|
addMediaButton(MediaType::MusicFile);
|
|
addMediaButton(MediaType::Link);
|
|
if (auto user = _peer->asUser()) {
|
|
addCommonGroupsButton(user);
|
|
}
|
|
addMediaButton(MediaType::VoiceFile);
|
|
addMediaButton(MediaType::RoundFile);
|
|
|
|
auto result = object_ptr<Ui::SlideWrap<Ui::VerticalLayout>>(
|
|
parent,
|
|
object_ptr<Ui::VerticalLayout>(parent)
|
|
);
|
|
result->toggleOn(tracker.atLeastOneShownValue());
|
|
auto layout = result->entity();
|
|
|
|
layout->add(object_ptr<BoxContentDivider>(result));
|
|
auto cover = layout->add(object_ptr<SharedMediaCover>(layout));
|
|
if (canHideDetailsEver()) {
|
|
cover->setToggleShown(canHideDetails());
|
|
layout->add(object_ptr<Ui::SlideWrap<>>(
|
|
layout,
|
|
std::move(content))
|
|
)->toggleOn(cover->toggledValue());
|
|
} else {
|
|
layout->add(std::move(content));
|
|
}
|
|
layout->add(object_ptr<Ui::FixedHeightWidget>(
|
|
layout,
|
|
st::infoSharedMediaBottomSkip)
|
|
)->setAttribute(Qt::WA_TransparentForMouseEvents);
|
|
object_ptr<FloatingIcon>(
|
|
result,
|
|
st::infoIconMediaPhoto,
|
|
st::infoSharedMediaIconPosition);
|
|
return std::move(result);
|
|
}
|
|
|
|
object_ptr<Ui::RpWidget> InnerWidget::setupUserActions(
|
|
RpWidget *parent,
|
|
not_null<UserData*> user) const {
|
|
auto result = object_ptr<Ui::VerticalLayout>(parent);
|
|
result->add(createSkipWidget(result));
|
|
auto addButton = [&](
|
|
rpl::producer<QString> &&text,
|
|
rpl::producer<bool> &&toggleOn,
|
|
auto &&callback,
|
|
const style::InfoProfileButton &st
|
|
= st::infoSharedMediaButton) {
|
|
return result->add(object_ptr<Ui::SlideWrap<Button>>(
|
|
result,
|
|
object_ptr<Button>(
|
|
result,
|
|
std::move(text),
|
|
st))
|
|
)->toggleOn(
|
|
std::move(toggleOn)
|
|
)->entity()->clicks()
|
|
| rpl::start([callback = std::move(callback)](auto&&) {
|
|
callback();
|
|
}, result->lifetime());
|
|
};
|
|
|
|
addButton(
|
|
Lang::Viewer(lng_profile_share_contact),
|
|
CanShareContactValue(user),
|
|
[user] { App::main()->shareContactLayer(user); });
|
|
addButton(
|
|
Lang::Viewer(lng_info_edit_contact),
|
|
IsContactValue(user),
|
|
[user] { Ui::show(Box<AddContactBox>(user)); });
|
|
addButton(
|
|
Lang::Viewer(lng_profile_clear_history),
|
|
rpl::single(true),
|
|
[user] {
|
|
auto confirmation = lng_sure_delete_history(lt_contact, App::peerName(user));
|
|
Ui::show(Box<ConfirmBox>(confirmation, lang(lng_box_delete), st::attentionBoxButton, [user] {
|
|
Ui::hideLayer();
|
|
App::main()->clearHistory(user);
|
|
Ui::showPeerHistory(user, ShowAtUnreadMsgId);
|
|
}));
|
|
});
|
|
addButton(
|
|
Lang::Viewer(lng_profile_delete_conversation),
|
|
rpl::single(true),
|
|
[user] {
|
|
auto confirmation = lng_sure_delete_history(lt_contact, App::peerName(user));
|
|
auto confirmButton = lang(lng_box_delete);
|
|
Ui::show(Box<ConfirmBox>(confirmation, confirmButton, st::attentionBoxButton, [user] {
|
|
Ui::hideLayer();
|
|
Ui::showChatsList();
|
|
App::main()->deleteConversation(user);
|
|
}));
|
|
});
|
|
|
|
if (!user->isSelf()) {
|
|
result->add(CreateSkipWidget(
|
|
result,
|
|
st::infoBlockButtonSkip));
|
|
|
|
auto text = PeerUpdateValue(user, Notify::PeerUpdate::Flag::UserIsBlocked)
|
|
| rpl::map([user](auto&&) {
|
|
switch (user->blockStatus()) {
|
|
case UserData::BlockStatus::Blocked:
|
|
return Lang::Viewer(lng_profile_unblock_user);
|
|
case UserData::BlockStatus::NotBlocked:
|
|
return Lang::Viewer(lng_profile_block_user);
|
|
default:
|
|
return rpl::single(QString());
|
|
}
|
|
})
|
|
| rpl::flatten_latest()
|
|
| rpl::start_spawning(result->lifetime());
|
|
addButton(
|
|
rpl::duplicate(text),
|
|
rpl::duplicate(text)
|
|
| rpl::map([](const QString &text) {
|
|
return !text.isEmpty();
|
|
}),
|
|
[user] {
|
|
if (user->isBlocked()) {
|
|
Auth().api().unblockUser(user);
|
|
} else {
|
|
Auth().api().blockUser(user);
|
|
}
|
|
},
|
|
st::infoBlockButton);
|
|
}
|
|
result->add(createSkipWidget(result));
|
|
|
|
object_ptr<FloatingIcon>(
|
|
result,
|
|
st::infoIconActions,
|
|
st::infoIconPosition);
|
|
return std::move(result);
|
|
}
|
|
|
|
object_ptr<Ui::RpWidget> InnerWidget::createSkipWidget(
|
|
RpWidget *parent) const {
|
|
return Ui::CreateSkipWidget(parent, st::infoProfileSkip);
|
|
}
|
|
|
|
object_ptr<Ui::SlideWrap<>> InnerWidget::createSlideSkipWidget(
|
|
RpWidget *parent) const {
|
|
return Ui::CreateSlideSkipWidget(parent, st::infoProfileSkip);
|
|
}
|
|
|
|
int InnerWidget::countDesiredHeight() const {
|
|
return _content->height() + (_members
|
|
? (_members->desiredHeight() - _members->height())
|
|
: 0);
|
|
}
|
|
|
|
void InnerWidget::visibleTopBottomUpdated(
|
|
int visibleTop,
|
|
int visibleBottom) {
|
|
setChildVisibleTopBottom(_content, visibleTop, visibleBottom);
|
|
}
|
|
|
|
void InnerWidget::saveState(not_null<Memento*> memento) {
|
|
}
|
|
|
|
void InnerWidget::restoreState(not_null<Memento*> memento) {
|
|
}
|
|
|
|
int InnerWidget::resizeGetHeight(int newWidth) {
|
|
_content->resizeToWidth(newWidth);
|
|
_content->moveToLeft(0, 0);
|
|
return qMax(_content->heightNoMargins(), _minHeight);
|
|
}
|
|
|
|
} // namespace Profile
|
|
} // namespace Info
|