tdesktop/Telegram/SourceFiles/ui/chat/attach/attach_album_preview.cpp

542 lines
15 KiB
C++
Raw Normal View History

/*
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 "ui/chat/attach/attach_album_preview.h"
#include "ui/chat/attach/attach_album_thumbnail.h"
#include "ui/chat/attach/attach_prepare.h"
#include "styles/style_chat.h"
#include "styles/style_boxes.h"
#include "styles/style_layers.h"
#include <QtWidgets/QApplication>
namespace Ui {
namespace {
constexpr auto kDragDuration = crl::time(200);
} // namespace
AlbumPreview::AlbumPreview(
QWidget *parent,
gsl::span<Ui::PreparedFile> items,
SendFilesWay way)
: RpWidget(parent)
, _sendWay(way)
, _dragTimer([=] { switchToDrag(); }) {
setMouseTracking(true);
prepareThumbs(items);
updateSize();
updateFileRows();
}
AlbumPreview::~AlbumPreview() = default;
void AlbumPreview::setSendWay(SendFilesWay way) {
if (_sendWay != way) {
cancelDrag();
_sendWay = way;
}
updateSize();
updateFileRows();
update();
}
void AlbumPreview::updateFileRows() {
Expects(_order.size() == _thumbs.size());
2020-10-15 14:27:16 +00:00
const auto isFile = !_sendWay.sendImagesAsPhotos();
for (auto i = 0; i < _order.size(); i++) {
_thumbs[i]->updateFileRow(isFile ? _order[i] : -1);
}
}
std::vector<int> AlbumPreview::takeOrder() {
//Expects(_thumbs.size() == _order.size());
//Expects(_itemsShownDimensions.size() == _order.size());
auto reordered = std::vector<std::unique_ptr<AlbumThumbnail>>();
auto reorderedShownDimensions = std::vector<QSize>();
reordered.reserve(_thumbs.size());
reorderedShownDimensions.reserve(_itemsShownDimensions.size());
for (auto index : _order) {
reordered.push_back(std::move(_thumbs[index]));
reorderedShownDimensions.push_back(_itemsShownDimensions[index]);
}
_thumbs = std::move(reordered);
_itemsShownDimensions = std::move(reorderedShownDimensions);
return std::exchange(_order, defaultOrder());
}
auto AlbumPreview::generateOrderedLayout() const
-> std::vector<GroupMediaLayout> {
auto layout = LayoutMediaGroup(
_itemsShownDimensions,
st::sendMediaPreviewSize,
st::historyGroupWidthMin / 2,
st::historyGroupSkip / 2);
Assert(layout.size() == _order.size());
return layout;
}
std::vector<int> AlbumPreview::defaultOrder(int count) const {
if (count < 0) {
count = _order.size();
}
return ranges::views::ints(0, count) | ranges::to_vector;
}
void AlbumPreview::prepareThumbs(gsl::span<Ui::PreparedFile> items) {
_order = defaultOrder(items.size());
_itemsShownDimensions = ranges::views::all(
_order
) | ranges::views::transform([&](int index) {
return items[index].shownDimensions;
}) | ranges::to_vector;
const auto count = int(_order.size());
const auto layout = generateOrderedLayout();
_thumbs.reserve(count);
for (auto i = 0; i != count; ++i) {
_thumbs.push_back(std::make_unique<AlbumThumbnail>(
items[i],
layout[i],
this,
[=] { changeThumbByIndex(thumbIndex(thumbUnderCursor())); },
[=] { deleteThumbByIndex(thumbIndex(thumbUnderCursor())); }));
}
_thumbsHeight = countLayoutHeight(layout);
_photosHeight = ranges::accumulate(ranges::views::all(
_thumbs
) | ranges::views::transform([](const auto &thumb) {
return thumb->photoHeight();
2020-10-19 15:37:59 +00:00
}), 0) + (count - 1) * st::sendMediaRowSkip;
2020-10-19 15:37:59 +00:00
const auto &st = st::attachPreviewThumbLayout;
_filesHeight = count * st.thumbSize
+ (count - 1) * st::sendMediaRowSkip;
}
int AlbumPreview::contentLeft() const {
return (st::boxWideWidth - st::sendMediaPreviewSize) / 2;
}
int AlbumPreview::contentTop() const {
return 0;
}
AlbumThumbnail *AlbumPreview::findThumb(QPoint position) const {
position -= QPoint(contentLeft(), contentTop());
auto top = 0;
2020-10-15 14:27:16 +00:00
const auto isPhotosWay = _sendWay.sendImagesAsPhotos();
2020-10-19 15:37:59 +00:00
const auto skip = st::sendMediaRowSkip;
auto find = [&](const auto &thumb) {
2020-10-17 09:51:55 +00:00
if (_sendWay.groupFiles() && _sendWay.sendImagesAsPhotos()) {
return thumb->containsPoint(position);
2020-10-15 14:27:16 +00:00
} else {
const auto bottom = top + (isPhotosWay
? thumb->photoHeight()
2020-10-19 15:37:59 +00:00
: st::attachPreviewThumbLayout.thumbSize);
const auto isUnderTop = (position.y() > top);
top = bottom + skip;
return isUnderTop && (position.y() < bottom);
}
return false;
};
const auto i = ranges::find_if(_thumbs, std::move(find));
return (i == _thumbs.end()) ? nullptr : i->get();
}
not_null<AlbumThumbnail*> AlbumPreview::findClosestThumb(
QPoint position) const {
Expects(_draggedThumb != nullptr);
if (const auto exact = findThumb(position)) {
return exact;
}
auto result = _draggedThumb;
auto distance = _draggedThumb->distanceTo(position);
for (const auto &thumb : _thumbs) {
const auto check = thumb->distanceTo(position);
if (check < distance) {
distance = check;
result = thumb.get();
}
}
return result;
}
int AlbumPreview::orderIndex(
not_null<AlbumThumbnail*> thumb) const {
const auto i = ranges::find_if(_order, [&](int index) {
return (_thumbs[index].get() == thumb);
});
Assert(i != _order.end());
return int(i - _order.begin());
}
void AlbumPreview::cancelDrag() {
_thumbsHeightAnimation.stop();
_finishDragAnimation.stop();
_shrinkAnimation.stop();
if (_draggedThumb) {
_draggedThumb->moveInAlbum({ 0, 0 });
_draggedThumb = nullptr;
}
if (_suggestedThumb) {
const auto suggestedIndex = orderIndex(_suggestedThumb);
if (suggestedIndex > 0) {
_thumbs[_order[suggestedIndex - 1]]->suggestMove(0., [] {});
}
if (suggestedIndex < int(_order.size() - 1)) {
_thumbs[_order[suggestedIndex + 1]]->suggestMove(0., [] {});
}
_suggestedThumb->suggestMove(0., [] {});
_suggestedThumb->finishAnimations();
_suggestedThumb = nullptr;
}
_paintedAbove = nullptr;
update();
}
void AlbumPreview::finishDrag() {
Expects(_draggedThumb != nullptr);
Expects(_suggestedThumb != nullptr);
if (_suggestedThumb != _draggedThumb) {
const auto currentIndex = orderIndex(_draggedThumb);
const auto newIndex = orderIndex(_suggestedThumb);
const auto delta = (currentIndex < newIndex) ? 1 : -1;
const auto realIndex = _order[currentIndex];
for (auto i = currentIndex; i != newIndex; i += delta) {
_order[i] = _order[i + delta];
}
_order[newIndex] = realIndex;
const auto layout = generateOrderedLayout();
for (auto i = 0, count = int(_order.size()); i != count; ++i) {
_thumbs[_order[i]]->moveToLayout(layout[i]);
}
_finishDragAnimation.start([=] { update(); }, 0., 1., kDragDuration);
updateSizeAnimated(layout);
} else {
for (const auto &thumb : _thumbs) {
thumb->resetLayoutAnimation();
}
_draggedThumb->animateLayoutToInitial();
_finishDragAnimation.start([=] { update(); }, 0., 1., kDragDuration);
}
}
int AlbumPreview::countLayoutHeight(
const std::vector<GroupMediaLayout> &layout) const {
const auto accumulator = [](int current, const auto &item) {
return std::max(current, item.geometry.y() + item.geometry.height());
};
return ranges::accumulate(layout, 0, accumulator);
}
void AlbumPreview::updateSizeAnimated(
const std::vector<GroupMediaLayout> &layout) {
const auto newHeight = countLayoutHeight(layout);
if (newHeight != _thumbsHeight) {
_thumbsHeightAnimation.start(
[=] { updateSize(); },
_thumbsHeight,
newHeight,
kDragDuration);
_thumbsHeight = newHeight;
}
}
void AlbumPreview::updateSize() {
const auto newHeight = [&] {
2020-10-17 09:51:55 +00:00
if (!_sendWay.sendImagesAsPhotos()) {
return _filesHeight;
} else if (!_sendWay.groupFiles()) {
2020-10-15 14:27:16 +00:00
return _photosHeight;
} else {
return int(base::SafeRound(_thumbsHeightAnimation.value(
2020-10-17 09:51:55 +00:00
_thumbsHeight)));
}
}();
if (height() != newHeight) {
resize(st::boxWideWidth, newHeight);
}
}
void AlbumPreview::paintEvent(QPaintEvent *e) {
Painter p(this);
2020-10-17 09:51:55 +00:00
if (!_sendWay.sendImagesAsPhotos()) {
paintFiles(p, e->rect());
} else if (!_sendWay.groupFiles()) {
2020-10-15 14:27:16 +00:00
paintPhotos(p, e->rect());
} else {
2020-10-17 09:51:55 +00:00
paintAlbum(p);
}
}
void AlbumPreview::paintAlbum(Painter &p) const {
const auto shrink = _shrinkAnimation.value(_draggedThumb ? 1. : 0.);
const auto moveProgress = _finishDragAnimation.value(1.);
const auto left = contentLeft();
const auto top = contentTop();
for (const auto &thumb : _thumbs) {
if (thumb.get() != _paintedAbove) {
thumb->paintInAlbum(p, left, top, shrink, moveProgress);
}
}
if (_paintedAbove) {
_paintedAbove->paintInAlbum(p, left, top, shrink, moveProgress);
}
}
void AlbumPreview::paintPhotos(Painter &p, QRect clip) const {
const auto left = (st::boxWideWidth - st::sendMediaPreviewSize) / 2;
auto top = 0;
const auto outerWidth = width();
for (const auto &thumb : _thumbs) {
const auto bottom = top + thumb->photoHeight();
const auto guard = gsl::finally([&] {
2020-10-19 15:37:59 +00:00
top = bottom + st::sendMediaRowSkip;
});
if (top >= clip.y() + clip.height()) {
break;
} else if (bottom <= clip.y()) {
continue;
}
thumb->paintPhoto(p, left, top, outerWidth);
}
}
void AlbumPreview::paintFiles(Painter &p, QRect clip) const {
2020-10-19 15:37:59 +00:00
const auto fileHeight = st::attachPreviewThumbLayout.thumbSize
+ st::sendMediaRowSkip;
const auto bottom = clip.y() + clip.height();
const auto from = std::clamp(clip.y() / fileHeight, 0, int(_thumbs.size()));
const auto till = std::clamp((bottom + fileHeight - 1) / fileHeight, 0, int(_thumbs.size()));
const auto left = (st::boxWideWidth - st::sendMediaPreviewSize) / 2;
const auto outerWidth = width();
auto top = from * fileHeight;
for (auto i = from; i != till; ++i) {
_thumbs[i]->paintFile(p, left, top, outerWidth);
top += fileHeight;
}
}
int AlbumPreview::thumbIndex(AlbumThumbnail *thumb) {
if (!thumb) {
return -1;
}
const auto thumbIt = ranges::find_if(_thumbs, [&](auto &t) {
return t.get() == thumb;
});
Expects(thumbIt != _thumbs.end());
return std::distance(_thumbs.begin(), thumbIt);
}
AlbumThumbnail *AlbumPreview::thumbUnderCursor() {
return findThumb(mapFromGlobal(QCursor::pos()));
}
void AlbumPreview::deleteThumbByIndex(int index) {
if (index < 0) {
return;
}
const auto orderIt = ranges::find(_order, index);
Expects(orderIt != _order.end());
_order.erase(orderIt);
ranges::for_each(_order, [=](auto &i) {
if (i > index) {
i--;
}
});
_thumbDeleted.fire(std::move(index));
}
void AlbumPreview::changeThumbByIndex(int index) {
if (index < 0) {
return;
}
_thumbChanged.fire(std::move(index));
}
void AlbumPreview::modifyThumbByIndex(int index) {
if (index < 0) {
return;
}
_thumbModified.fire(std::move(index));
}
void AlbumPreview::thumbButtonsCallback(
not_null<AlbumThumbnail*> thumb,
AttachButtonType type) {
const auto index = thumbIndex(thumb);
switch (type) {
case AttachButtonType::None: return;
case AttachButtonType::Edit: changeThumbByIndex(index); break;
case AttachButtonType::Delete: deleteThumbByIndex(index); break;
case AttachButtonType::Modify:
cancelDrag();
modifyThumbByIndex(index);
break;
}
}
void AlbumPreview::mousePressEvent(QMouseEvent *e) {
if (_finishDragAnimation.animating()) {
return;
}
const auto position = e->pos();
cancelDrag();
if (const auto thumb = findThumb(position)) {
_draggedStartPosition = position;
_pressedThumb = thumb;
_pressedButtonType = thumb->buttonTypeFromPoint(position);
const auto isAlbum = _sendWay.sendImagesAsPhotos()
&& _sendWay.groupFiles();
if (!isAlbum) {
return;
}
if (_pressedButtonType == AttachButtonType::None) {
switchToDrag();
} else if (_pressedButtonType == AttachButtonType::Modify) {
_dragTimer.callOnce(QApplication::startDragTime());
}
}
}
void AlbumPreview::mouseMoveEvent(QMouseEvent *e) {
2020-10-15 14:27:16 +00:00
if (!_sendWay.sendImagesAsPhotos()) {
applyCursor(style::cur_default);
return;
}
if (_dragTimer.isActive()) {
_dragTimer.cancel();
switchToDrag();
}
2020-10-17 09:51:55 +00:00
const auto isAlbum = _sendWay.sendImagesAsPhotos()
&& _sendWay.groupFiles();
if (isAlbum && _draggedThumb) {
const auto position = e->pos();
_draggedThumb->moveInAlbum(position - _draggedStartPosition);
updateSuggestedDrag(_draggedThumb->center());
update();
} else {
const auto thumb = findThumb(e->pos());
const auto regularCursor = isAlbum
? style::cur_pointer
: style::cur_default;
const auto cursor = thumb
? (thumb->buttonsContainPoint(e->pos())
? style::cur_pointer
: regularCursor)
: style::cur_default;
applyCursor(cursor);
}
}
void AlbumPreview::applyCursor(style::cursor cursor) {
if (_cursor != cursor) {
_cursor = cursor;
setCursor(_cursor);
}
}
void AlbumPreview::updateSuggestedDrag(QPoint position) {
auto closest = findClosestThumb(position);
auto closestIndex = orderIndex(closest);
const auto draggedIndex = orderIndex(_draggedThumb);
const auto closestIsBeforePoint = closest->isPointAfter(position);
if (closestIndex < draggedIndex && closestIsBeforePoint) {
closest = _thumbs[_order[++closestIndex]].get();
} else if (closestIndex > draggedIndex && !closestIsBeforePoint) {
closest = _thumbs[_order[--closestIndex]].get();
}
if (_suggestedThumb == closest) {
return;
}
const auto last = int(_order.size()) - 1;
if (_suggestedThumb) {
const auto suggestedIndex = orderIndex(_suggestedThumb);
if (suggestedIndex < draggedIndex && suggestedIndex > 0) {
const auto previous = _thumbs[_order[suggestedIndex - 1]].get();
previous->suggestMove(0., [=] { update(); });
} else if (suggestedIndex > draggedIndex && suggestedIndex < last) {
const auto next = _thumbs[_order[suggestedIndex + 1]].get();
next->suggestMove(0., [=] { update(); });
}
_suggestedThumb->suggestMove(0., [=] { update(); });
}
_suggestedThumb = closest;
const auto suggestedIndex = closestIndex;
if (_suggestedThumb != _draggedThumb) {
const auto delta = (suggestedIndex < draggedIndex) ? 1. : -1.;
if (delta > 0. && suggestedIndex > 0) {
const auto previous = _thumbs[_order[suggestedIndex - 1]].get();
previous->suggestMove(-delta, [=] { update(); });
} else if (delta < 0. && suggestedIndex < last) {
const auto next = _thumbs[_order[suggestedIndex + 1]].get();
next->suggestMove(-delta, [=] { update(); });
}
_suggestedThumb->suggestMove(delta, [=] { update(); });
}
}
void AlbumPreview::mouseReleaseEvent(QMouseEvent *e) {
if (_draggedThumb) {
finishDrag();
_shrinkAnimation.start(
[=] { update(); },
1.,
0.,
AlbumThumbnail::kShrinkDuration);
_draggedThumb = nullptr;
_suggestedThumb = nullptr;
update();
} else if (const auto thumb = base::take(_pressedThumb)) {
const auto was = _pressedButtonType;
const auto now = thumb->buttonTypeFromPoint(e->pos());
if (was == now) {
thumbButtonsCallback(thumb, now);
}
}
_pressedButtonType = AttachButtonType::None;
}
void AlbumPreview::switchToDrag() {
_paintedAbove
= _suggestedThumb
= _draggedThumb
= base::take(_pressedThumb);
_shrinkAnimation.start(
[=] { update(); },
0.,
1.,
AlbumThumbnail::kShrinkDuration);
applyCursor(style::cur_sizeall);
update();
}
rpl::producer<int> AlbumPreview::thumbModified() const {
return _thumbModified.events();
}
} // namespace Ui