tdesktop/Telegram/SourceFiles/ui/special_buttons.cpp

928 lines
23 KiB
C++
Raw Normal View History

2016-05-19 17:18:23 +00:00
/*
This file is part of Telegram Desktop,
the official desktop application for the Telegram messaging service.
2016-05-19 17:18:23 +00:00
For license and copyright information please follow this link:
https://github.com/telegramdesktop/tdesktop/blob/master/LEGAL
2016-05-19 17:18:23 +00:00
*/
#include "ui/special_buttons.h"
2016-05-19 17:18:23 +00:00
#include "styles/style_boxes.h"
2020-10-10 09:15:37 +00:00
#include "styles/style_chat.h"
#include "dialogs/dialogs_layout.h"
#include "ui/effects/ripple_animation.h"
2018-05-04 16:57:50 +00:00
#include "ui/effects/radial_animation.h"
#include "ui/image/image_prepare.h"
#include "ui/empty_userpic.h"
2019-09-13 12:22:54 +00:00
#include "ui/ui_utility.h"
#include "data/data_photo.h"
#include "data/data_session.h"
2019-04-15 11:54:03 +00:00
#include "data/data_folder.h"
#include "data/data_channel.h"
2020-05-28 14:32:10 +00:00
#include "data/data_cloud_file.h"
#include "data/data_changes.h"
#include "data/data_user.h"
#include "data/data_streaming.h"
#include "data/data_file_origin.h"
#include "history/history.h"
#include "core/file_utilities.h"
#include "core/application.h"
#include "boxes/photo_crop_box.h"
#include "boxes/confirm_box.h"
#include "media/streaming/media_streaming_instance.h"
#include "media/streaming/media_streaming_player.h"
#include "media/streaming/media_streaming_document.h"
#include "window/window_session_controller.h"
#include "lang/lang_keys.h"
2019-07-24 11:45:24 +00:00
#include "main/main_session.h"
#include "apiwrap.h"
#include "mainwidget.h"
#include "facades.h"
#include "app.h"
2016-05-19 17:18:23 +00:00
namespace Ui {
namespace {
2018-12-23 17:23:36 +00:00
QString CropTitle(not_null<PeerData*> peer) {
if (peer->isChat() || peer->isMegagroup()) {
2019-06-19 15:09:03 +00:00
return tr::lng_create_group_crop(tr::now);
2018-12-23 17:23:36 +00:00
} else if (peer->isChannel()) {
2019-06-19 15:09:03 +00:00
return tr::lng_create_channel_crop(tr::now);
2018-12-23 17:23:36 +00:00
} else {
2019-06-19 15:09:03 +00:00
return tr::lng_settings_crop_profile(tr::now);
2018-12-23 17:23:36 +00:00
}
}
template <typename Callback>
QPixmap CreateSquarePixmap(int width, Callback &&paintCallback) {
auto size = QSize(width, width) * cIntRetinaFactor();
auto image = QImage(size, QImage::Format_ARGB32_Premultiplied);
image.setDevicePixelRatio(cRetinaFactor());
image.fill(Qt::transparent);
{
Painter p(&image);
paintCallback(p);
}
return App::pixmapFromImageInPlace(std::move(image));
};
template <typename Callback>
void SuggestPhoto(
const QImage &image,
2018-12-23 17:23:36 +00:00
const QString &title,
Callback &&callback) {
auto badAspect = [](int a, int b) {
return (a >= 10 * b);
};
if (image.isNull()
|| badAspect(image.width(), image.height())
|| badAspect(image.height(), image.width())) {
Ui::show(
2019-06-19 15:09:03 +00:00
Box<InformBox>(tr::lng_bad_photo(tr::now)),
2019-09-18 11:19:05 +00:00
Ui::LayerOption::KeepOther);
return;
}
2018-12-23 17:23:36 +00:00
const auto box = Ui::show(
Box<PhotoCropBox>(image, title),
2019-09-18 11:19:05 +00:00
Ui::LayerOption::KeepOther);
box->ready(
) | rpl::start_with_next(
std::forward<Callback>(callback),
box->lifetime());
}
template <typename Callback>
void SuggestPhotoFile(
const FileDialog::OpenResult &result,
2018-12-23 17:23:36 +00:00
const QString &title,
Callback &&callback) {
if (result.paths.isEmpty() && result.remoteContent.isEmpty()) {
return;
}
auto image = [&] {
if (!result.remoteContent.isEmpty()) {
return App::readImage(result.remoteContent);
} else if (!result.paths.isEmpty()) {
return App::readImage(result.paths.front());
}
return QImage();
}();
SuggestPhoto(
image,
2018-12-23 17:23:36 +00:00
title,
std::forward<Callback>(callback));
}
template <typename Callback>
void ShowChoosePhotoBox(
QPointer<QWidget> parent,
2018-12-23 17:23:36 +00:00
const QString &title,
Callback &&callback) {
2020-10-13 10:00:35 +00:00
auto filter = FileDialog::ImagesOrAllFilter();
auto handleChosenPhoto = [
2018-12-23 17:23:36 +00:00
title,
callback = std::forward<Callback>(callback)
](auto &&result) mutable {
2018-12-23 17:23:36 +00:00
SuggestPhotoFile(result, title, std::move(callback));
};
FileDialog::GetOpenPath(
parent,
2019-06-19 15:09:03 +00:00
tr::lng_choose_image(tr::now),
filter,
std::move(handleChosenPhoto));
}
} // namespace
2016-05-19 17:18:23 +00:00
HistoryDownButton::HistoryDownButton(QWidget *parent, const style::TwoIconButton &st) : RippleButton(parent, st.ripple)
, _st(st) {
resize(_st.width, _st.height);
2016-05-19 17:18:23 +00:00
setCursor(style::cur_pointer);
hide();
2016-05-19 17:18:23 +00:00
}
QImage HistoryDownButton::prepareRippleMask() const {
return Ui::RippleAnimation::ellipseMask(QSize(_st.rippleAreaSize, _st.rippleAreaSize));
}
QPoint HistoryDownButton::prepareRippleStartPosition() const {
return mapFromGlobal(QCursor::pos()) - _st.rippleAreaPosition;
}
2016-05-19 17:18:23 +00:00
void HistoryDownButton::paintEvent(QPaintEvent *e) {
Painter p(this);
const auto over = isOver();
const auto down = isDown();
((over || down) ? _st.iconBelowOver : _st.iconBelow).paint(p, _st.iconPosition, width());
2019-04-02 09:13:30 +00:00
paintRipple(p, _st.rippleAreaPosition.x(), _st.rippleAreaPosition.y());
((over || down) ? _st.iconAboveOver : _st.iconAbove).paint(p, _st.iconPosition, width());
if (_unreadCount > 0) {
auto unreadString = QString::number(_unreadCount);
Dialogs::Layout::UnreadBadgeStyle st;
st.align = style::al_center;
st.font = st::historyToDownBadgeFont;
st.size = st::historyToDownBadgeSize;
st.sizeId = Dialogs::Layout::UnreadBadgeInHistoryToDown;
Dialogs::Layout::paintUnreadCount(p, unreadString, width(), 0, st, nullptr, 4);
}
2016-05-19 17:18:23 +00:00
}
void HistoryDownButton::setUnreadCount(int unreadCount) {
if (_unreadCount != unreadCount) {
_unreadCount = unreadCount;
update();
}
}
UserpicButton::UserpicButton(
QWidget *parent,
2018-12-23 17:23:36 +00:00
const QString &cropTitle,
Role role,
const style::UserpicButton &st)
: RippleButton(parent, st.changeButton.ripple)
, _st(st)
2018-12-23 17:23:36 +00:00
, _cropTitle(cropTitle)
, _role(role) {
Expects(_role == Role::ChangePhoto);
_waiting = false;
prepare();
}
UserpicButton::UserpicButton(
QWidget *parent,
not_null<Window::SessionController*> controller,
not_null<PeerData*> peer,
Role role,
const style::UserpicButton &st)
: RippleButton(parent, st.changeButton.ripple)
, _st(st)
, _controller(controller)
, _peer(peer)
2018-12-23 17:23:36 +00:00
, _cropTitle(CropTitle(_peer))
, _role(role) {
processPeerPhoto();
prepare();
setupPeerViewers();
}
UserpicButton::UserpicButton(
QWidget *parent,
not_null<PeerData*> peer,
Role role,
const style::UserpicButton &st)
: RippleButton(parent, st.changeButton.ripple)
, _st(st)
, _peer(peer)
2018-12-23 17:23:36 +00:00
, _cropTitle(CropTitle(_peer))
, _role(role) {
2018-04-06 16:23:09 +00:00
Expects(_role != Role::OpenProfile);
_waiting = false;
prepare();
}
void UserpicButton::prepare() {
resize(_st.size);
_notShownYet = _waiting;
if (!_waiting) {
prepareUserpicPixmap();
}
setClickHandlerByRole();
}
void UserpicButton::setClickHandlerByRole() {
switch (_role) {
case Role::ChangePhoto:
addClickHandler(App::LambdaDelayed(
_st.changeButton.ripple.hideDuration,
this,
[this] { changePhotoLazy(); }));
break;
case Role::OpenPhoto:
addClickHandler([=] {
openPeerPhoto();
});
break;
case Role::OpenProfile:
addClickHandler([this] {
Expects(_controller != nullptr);
_controller->showPeerInfo(_peer);
});
break;
}
}
void UserpicButton::changePhotoLazy() {
auto callback = crl::guard(
this,
[this](QImage &&image) { setImage(std::move(image)); });
2018-12-23 17:23:36 +00:00
ShowChoosePhotoBox(this, _cropTitle, std::move(callback));
}
void UserpicButton::uploadNewPeerPhoto() {
auto callback = crl::guard(this, [=](QImage &&image) {
2019-07-24 11:13:51 +00:00
_peer->session().api().uploadPeerPhoto(_peer, std::move(image));
});
2018-12-23 17:23:36 +00:00
ShowChoosePhotoBox(this, _cropTitle, std::move(callback));
}
void UserpicButton::openPeerPhoto() {
Expects(_peer != nullptr);
Expects(_controller != nullptr);
if (_changeOverlayEnabled && _cursorInChangeOverlay) {
uploadNewPeerPhoto();
return;
}
const auto id = _peer->userpicPhotoId();
if (!id) {
return;
}
2019-07-24 11:13:51 +00:00
const auto photo = _peer->owner().photo(id);
if (photo->date) {
Core::App().showPhoto(photo, _peer);
}
}
void UserpicButton::setupPeerViewers() {
_peer->session().changes().peerUpdates(
_peer,
Data::PeerUpdate::Flag::Photo
2020-05-28 14:32:10 +00:00
) | rpl::start_with_next([=] {
processNewPeerPhoto();
update();
}, lifetime());
2019-07-24 11:13:51 +00:00
_peer->session().downloaderTaskFinished(
2020-05-28 14:32:10 +00:00
) | rpl::filter([=] {
return _waiting;
}) | rpl::start_with_next([=] {
if (!_userpicView || _userpicView->image()) {
_waiting = false;
startNewPhotoShowing();
}
}, lifetime());
}
void UserpicButton::paintEvent(QPaintEvent *e) {
Painter p(this);
if (!_waiting && _notShownYet) {
_notShownYet = false;
startAnimation();
}
auto photoPosition = countPhotoPosition();
auto photoLeft = photoPosition.x();
auto photoTop = photoPosition.y();
if (showSavedMessages()) {
Ui::EmptyUserpic::PaintSavedMessages(
p,
photoPosition.x(),
photoPosition.y(),
width(),
_st.photoSize);
2020-09-11 15:33:26 +00:00
} else if (showRepliesMessages()) {
Ui::EmptyUserpic::PaintRepliesMessages(
p,
photoPosition.x(),
photoPosition.y(),
width(),
_st.photoSize);
} else {
2019-04-02 09:13:30 +00:00
if (_a_appearance.animating()) {
p.drawPixmapLeft(photoPosition, width(), _oldUserpic);
2019-04-02 09:13:30 +00:00
p.setOpacity(_a_appearance.value(1.));
}
paintUserpicFrame(p, photoPosition);
}
if (_role == Role::ChangePhoto) {
auto over = isOver() || isDown();
if (over) {
PainterHighQualityEnabler hq(p);
p.setPen(Qt::NoPen);
p.setBrush(_userpicHasImage
? st::msgDateImgBg
: _st.changeButton.textBgOver);
p.drawEllipse(
photoLeft,
photoTop,
_st.photoSize,
_st.photoSize);
}
paintRipple(
p,
photoLeft,
photoTop,
_userpicHasImage
? &st::shadowFg->c
: &_st.changeButton.ripple.color->c);
if (over || !_userpicHasImage) {
auto iconLeft = (_st.changeIconPosition.x() < 0)
? (_st.photoSize - _st.changeIcon.width()) / 2
: _st.changeIconPosition.x();
auto iconTop = (_st.changeIconPosition.y() < 0)
? (_st.photoSize - _st.changeIcon.height()) / 2
: _st.changeIconPosition.y();
_st.changeIcon.paint(
p,
photoLeft + iconLeft,
photoTop + iconTop,
width());
}
} else if (_changeOverlayEnabled) {
2019-04-02 09:13:30 +00:00
auto current = _changeOverlayShown.value(
(isOver() || isDown()) ? 1. : 0.);
auto barHeight = anim::interpolate(
0,
_st.uploadHeight,
current);
if (barHeight > 0) {
auto barLeft = photoLeft;
auto barTop = photoTop + _st.photoSize - barHeight;
auto rect = QRect(
barLeft,
barTop,
_st.photoSize,
barHeight);
p.setClipRect(rect);
{
PainterHighQualityEnabler hq(p);
p.setPen(Qt::NoPen);
p.setBrush(_st.uploadBg);
p.drawEllipse(
photoLeft,
photoTop,
_st.photoSize,
_st.photoSize);
}
auto iconLeft = (_st.uploadIconPosition.x() < 0)
? (_st.photoSize - _st.uploadIcon.width()) / 2
: _st.uploadIconPosition.x();
auto iconTop = (_st.uploadIconPosition.y() < 0)
? (_st.uploadHeight - _st.uploadIcon.height()) / 2
: _st.uploadIconPosition.y();
if (iconTop < barHeight) {
_st.uploadIcon.paint(
p,
barLeft + iconLeft,
barTop + iconTop,
width());
}
}
}
}
void UserpicButton::paintUserpicFrame(Painter &p, QPoint photoPosition) {
checkStreamedIsStarted();
if (_streamed
&& _streamed->player().ready()
&& !_streamed->player().videoSize().isEmpty()) {
const auto paused = _controller->isGifPausedAtLeastFor(
Window::GifPauseReason::RoundPlaying);
auto request = Media::Streaming::FrameRequest();
auto size = QSize{ _st.photoSize, _st.photoSize };
request.outer = size * cIntRetinaFactor();
request.resize = size * cIntRetinaFactor();
request.radius = ImageRoundRadius::Ellipse;
p.drawImage(QRect(photoPosition, size), _streamed->frame(request));
if (!paused) {
_streamed->markFrameShown();
}
} else {
p.drawPixmapLeft(photoPosition, width(), _userpic);
}
}
QPoint UserpicButton::countPhotoPosition() const {
auto photoLeft = (_st.photoPosition.x() < 0)
? (width() - _st.photoSize) / 2
: _st.photoPosition.x();
auto photoTop = (_st.photoPosition.y() < 0)
? (height() - _st.photoSize) / 2
: _st.photoPosition.y();
return { photoLeft, photoTop };
}
QImage UserpicButton::prepareRippleMask() const {
return Ui::RippleAnimation::ellipseMask(QSize(
_st.photoSize,
_st.photoSize));
}
QPoint UserpicButton::prepareRippleStartPosition() const {
return (_role == Role::ChangePhoto)
? mapFromGlobal(QCursor::pos()) - countPhotoPosition()
: DisabledRippleStartPosition();
}
void UserpicButton::processPeerPhoto() {
Expects(_peer != nullptr);
2020-05-28 14:32:10 +00:00
_userpicView = _peer->createUserpicView();
_waiting = _userpicView && !_userpicView->image();
if (_waiting) {
_peer->loadUserpic();
}
if (_role == Role::OpenPhoto) {
if (_peer->userpicPhotoUnknown()) {
_peer->updateFullForced();
}
_canOpenPhoto = (_peer->userpicPhotoId() != 0);
updateCursor();
updateVideo();
}
}
void UserpicButton::updateCursor() {
Expects(_role == Role::OpenPhoto);
auto pointer = _canOpenPhoto
|| (_changeOverlayEnabled && _cursorInChangeOverlay);
setPointerCursor(pointer);
}
bool UserpicButton::createStreamingObjects(not_null<PhotoData*> photo) {
Expects(_peer != nullptr);
using namespace Media::Streaming;
const auto origin = _peer->isUser()
? Data::FileOriginUserPhoto(_peer->asUser()->bareId(), photo->id)
: Data::FileOrigin(Data::FileOriginPeerPhoto(_peer->id));
_streamed = std::make_unique<Instance>(
photo->owner().streaming().sharedDocument(photo, origin),
nullptr);
_streamed->lockPlayer();
_streamed->player().updates(
) | rpl::start_with_next_error([=](Update &&update) {
handleStreamingUpdate(std::move(update));
}, [=](Error &&error) {
handleStreamingError(std::move(error));
}, _streamed->lifetime());
if (_streamed->ready()) {
streamingReady(base::duplicate(_streamed->info()));
}
if (!_streamed->valid()) {
clearStreaming();
return false;
}
return true;
}
void UserpicButton::clearStreaming() {
_streamed = nullptr;
_streamedPhoto = nullptr;
}
void UserpicButton::handleStreamingUpdate(Media::Streaming::Update &&update) {
using namespace Media::Streaming;
v::match(update.data, [&](Information &update) {
streamingReady(std::move(update));
}, [&](const PreloadedVideo &update) {
}, [&](const UpdateVideo &update) {
this->update();
}, [&](const PreloadedAudio &update) {
}, [&](const UpdateAudio &update) {
}, [&](const WaitingForData &update) {
}, [&](MutedByOther) {
}, [&](Finished) {
});
}
void UserpicButton::handleStreamingError(Media::Streaming::Error &&error) {
Expects(_peer != nullptr);
_streamedPhoto->setVideoPlaybackFailed();
_streamedPhoto = nullptr;
_streamed = nullptr;
}
void UserpicButton::streamingReady(Media::Streaming::Information &&info) {
update();
}
void UserpicButton::updateVideo() {
Expects(_role == Role::OpenPhoto);
const auto id = _peer->userpicPhotoId();
if (!id) {
clearStreaming();
return;
}
const auto photo = _peer->owner().photo(id);
if (!photo->date || !photo->videoCanBePlayed()) {
clearStreaming();
return;
} else if (_streamed && _streamedPhoto == photo) {
return;
}
if (!createStreamingObjects(photo)) {
photo->setVideoPlaybackFailed();
return;
}
_streamedPhoto = photo;
checkStreamedIsStarted();
}
void UserpicButton::checkStreamedIsStarted() {
Expects(!_streamed || _streamedPhoto);
if (!_streamed) {
return;
} else if (_streamed->paused()) {
_streamed->resume();
}
if (_streamed && !_streamed->active() && !_streamed->failed()) {
const auto position = _streamedPhoto->videoStartPosition();
auto options = Media::Streaming::PlaybackOptions();
options.position = position;
options.mode = Media::Streaming::Mode::Video;
options.loop = true;
_streamed->play(options);
}
}
void UserpicButton::mouseMoveEvent(QMouseEvent *e) {
RippleButton::mouseMoveEvent(e);
if (_role == Role::OpenPhoto) {
updateCursorInChangeOverlay(e->pos());
}
}
void UserpicButton::updateCursorInChangeOverlay(QPoint localPos) {
auto photoPosition = countPhotoPosition();
auto overlayRect = QRect(
photoPosition.x(),
photoPosition.y() + _st.photoSize - _st.uploadHeight,
_st.photoSize,
_st.uploadHeight);
auto inOverlay = overlayRect.contains(localPos);
setCursorInChangeOverlay(inOverlay);
}
void UserpicButton::leaveEventHook(QEvent *e) {
if (_role == Role::OpenPhoto) {
setCursorInChangeOverlay(false);
}
return RippleButton::leaveEventHook(e);
}
void UserpicButton::setCursorInChangeOverlay(bool inOverlay) {
Expects(_role == Role::OpenPhoto);
if (_cursorInChangeOverlay != inOverlay) {
_cursorInChangeOverlay = inOverlay;
updateCursor();
}
}
void UserpicButton::processNewPeerPhoto() {
if (_userpicCustom) {
return;
}
processPeerPhoto();
if (!_waiting) {
grabOldUserpic();
startNewPhotoShowing();
}
}
void UserpicButton::grabOldUserpic() {
auto photoRect = QRect(
countPhotoPosition(),
QSize(_st.photoSize, _st.photoSize)
);
_oldUserpic = GrabWidget(this, photoRect);
}
void UserpicButton::startNewPhotoShowing() {
auto oldUniqueKey = _userpicUniqueKey;
prepareUserpicPixmap();
update();
if (_notShownYet) {
return;
}
if (oldUniqueKey != _userpicUniqueKey
|| _a_appearance.animating()) {
startAnimation();
}
}
void UserpicButton::startAnimation() {
2019-04-02 09:13:30 +00:00
_a_appearance.stop();
_a_appearance.start([this] { update(); }, 0, 1, _st.duration);
}
void UserpicButton::switchChangePhotoOverlay(bool enabled) {
Expects(_role == Role::OpenPhoto);
if (_changeOverlayEnabled != enabled) {
_changeOverlayEnabled = enabled;
if (enabled) {
if (isOver()) {
startChangeOverlayAnimation();
}
updateCursorInChangeOverlay(
mapFromGlobal(QCursor::pos()));
} else {
2019-04-02 09:13:30 +00:00
_changeOverlayShown.stop();
update();
}
}
}
void UserpicButton::showSavedMessagesOnSelf(bool enabled) {
if (_showSavedMessagesOnSelf != enabled) {
_showSavedMessagesOnSelf = enabled;
update();
}
}
bool UserpicButton::showSavedMessages() const {
return _showSavedMessagesOnSelf && _peer && _peer->isSelf();
}
2020-09-11 15:33:26 +00:00
bool UserpicButton::showRepliesMessages() const {
return _showSavedMessagesOnSelf && _peer && _peer->isRepliesChat();
}
void UserpicButton::startChangeOverlayAnimation() {
auto over = isOver() || isDown();
_changeOverlayShown.start(
[this] { update(); },
over ? 0. : 1.,
over ? 1. : 0.,
st::slideWrapDuration);
update();
}
void UserpicButton::onStateChanged(
State was,
StateChangeSource source) {
RippleButton::onStateChanged(was, source);
if (_changeOverlayEnabled) {
auto mask = (StateFlag::Over | StateFlag::Down);
auto wasOver = (was & mask) != 0;
auto nowOver = (state() & mask) != 0;
if (wasOver != nowOver) {
startChangeOverlayAnimation();
}
}
}
void UserpicButton::setImage(QImage &&image) {
grabOldUserpic();
auto size = QSize(_st.photoSize, _st.photoSize);
auto small = image.scaled(
size * cIntRetinaFactor(),
Qt::IgnoreAspectRatio,
Qt::SmoothTransformation);
Images::prepareCircle(small);
_userpic = App::pixmapFromImageInPlace(std::move(small));
_userpic.setDevicePixelRatio(cRetinaFactor());
_userpicCustom = _userpicHasImage = true;
_result = std::move(image);
startNewPhotoShowing();
}
void UserpicButton::prepareUserpicPixmap() {
if (_userpicCustom) {
return;
}
auto size = _st.photoSize;
auto paintButton = [&](Painter &p, const style::color &color) {
PainterHighQualityEnabler hq(p);
p.setBrush(color);
p.setPen(Qt::NoPen);
p.drawEllipse(0, 0, size, size);
};
_userpicHasImage = _peer
2020-05-28 14:32:10 +00:00
? (_peer->currentUserpic(_userpicView) || _role != Role::ChangePhoto)
: false;
_userpic = CreateSquarePixmap(size, [&](Painter &p) {
if (_userpicHasImage) {
2020-05-28 14:32:10 +00:00
_peer->paintUserpic(p, _userpicView, 0, 0, _st.photoSize);
} else {
paintButton(p, _st.changeButton.textBg);
}
});
_userpicUniqueKey = _userpicHasImage
2020-05-28 14:32:10 +00:00
? _peer->userpicUniqueKey(_userpicView)
: InMemoryKey();
}
2019-04-15 11:54:03 +00:00
// // #feed
//FeedUserpicButton::FeedUserpicButton(
// QWidget *parent,
// not_null<Window::SessionController*> controller,
2019-04-15 11:54:03 +00:00
// not_null<Data::Feed*> feed,
// const style::FeedUserpicButton &st)
//: AbstractButton(parent)
//, _st(st)
//, _controller(controller)
//, _feed(feed) {
// prepare();
//}
//
//void FeedUserpicButton::prepare() {
// resize(_st.size);
//
2019-07-24 11:13:51 +00:00
// _feed->owner().feedUpdated(
2019-04-15 11:54:03 +00:00
// ) | rpl::filter([=](const Data::FeedUpdate &update) {
// return (update.feed == _feed)
// && (update.flag == Data::FeedUpdateFlag::Channels);
// }) | rpl::start_with_next([=] {
// crl::on_main(this, [=] { checkParts(); });
// }, lifetime());
//
// refreshParts();
//}
//
//void FeedUserpicButton::checkParts() {
// if (!partsAreValid()) {
// refreshParts();
// }
//}
//
//bool FeedUserpicButton::partsAreValid() const {
// const auto &channels = _feed->channels();
// const auto count = std::min(int(channels.size()), 4);
// if (count != _parts.size()) {
// return false;
// }
// for (auto i = 0; i != count; ++i) {
// if (channels[i]->peer != _parts[i].channel) {
// return false;
// }
// }
// return true;
//}
//
//void FeedUserpicButton::refreshParts() {
// const auto &channels = _feed->channels();
// const auto count = std::min(int(channels.size()), 4);
//
// const auto createButton = [&](not_null<ChannelData*> channel) {
// auto result = base::make_unique_q<Ui::UserpicButton>(
// this,
// _controller,
// channel,
// Ui::UserpicButton::Role::Custom,
// _st.innerPart);
// result->setAttribute(Qt::WA_TransparentForMouseEvents);
// result->show();
// return result;
// };
//
// const auto position = countInnerPosition();
// auto x = position.x();
// auto y = position.y();
// const auto delta = _st.innerSize - _st.innerPart.photoSize;
// _parts.clear();
// for (auto i = 0; i != count; ++i) {
// const auto channel = channels[i]->peer->asChannel();
// _parts.push_back({ channel, createButton(channel) });
// _parts.back().button->moveToLeft(x, y);
// switch (i) {
// case 0:
// case 2: x += delta; break;
// case 1: x -= delta; y += delta; break;
// }
// }
//}
//
//QPoint FeedUserpicButton::countInnerPosition() const {
// auto innerLeft = (_st.innerPosition.x() < 0)
// ? (width() - _st.innerSize) / 2
// : _st.innerPosition.x();
// auto innerTop = (_st.innerPosition.y() < 0)
// ? (height() - _st.innerSize) / 2
// : _st.innerPosition.y();
// return { innerLeft, innerTop };
//}
SilentToggle::SilentToggle(QWidget *parent, not_null<ChannelData*> channel)
: IconButton(parent, st::historySilentToggle)
, _channel(channel)
2019-07-24 11:13:51 +00:00
, _checked(channel->owner().notifySilentPosts(_channel)) {
Expects(!channel->owner().notifySilentPostsUnknown(_channel));
if (_checked) {
refreshIconOverrides();
}
setMouseTracking(true);
}
void SilentToggle::mouseMoveEvent(QMouseEvent *e) {
IconButton::mouseMoveEvent(e);
if (rect().contains(e->pos())) {
Ui::Tooltip::Show(1000, this);
} else {
Ui::Tooltip::Hide();
}
}
void SilentToggle::setChecked(bool checked) {
if (_checked != checked) {
_checked = checked;
refreshIconOverrides();
}
}
void SilentToggle::refreshIconOverrides() {
const auto iconOverride = _checked
? &st::historySilentToggleOn
: nullptr;
const auto iconOverOverride = _checked
? &st::historySilentToggleOnOver
: nullptr;
setIconOverride(iconOverride, iconOverOverride);
}
void SilentToggle::leaveEventHook(QEvent *e) {
IconButton::leaveEventHook(e);
Ui::Tooltip::Hide();
}
void SilentToggle::mouseReleaseEvent(QMouseEvent *e) {
setChecked(!_checked);
IconButton::mouseReleaseEvent(e);
Ui::Tooltip::Show(0, this);
2019-07-24 11:13:51 +00:00
_channel->owner().updateNotifySettings(
_channel,
2018-09-21 16:28:46 +00:00
std::nullopt,
_checked);
}
QString SilentToggle::tooltipText() const {
2019-06-19 15:09:03 +00:00
return _checked
? tr::lng_wont_be_notified(tr::now)
: tr::lng_will_be_notified(tr::now);
}
QPoint SilentToggle::tooltipPos() const {
return QCursor::pos();
}
2019-09-16 11:14:06 +00:00
bool SilentToggle::tooltipWindowActive() const {
return Ui::AppInFocus() && InFocusChain(window());
2019-09-16 11:14:06 +00:00
}
2016-05-19 17:18:23 +00:00
} // namespace Ui