tdesktop/Telegram/SourceFiles/window/section_widget.cpp

219 lines
5.9 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 "window/section_widget.h"
2018-01-09 17:08:31 +00:00
#include "mainwidget.h"
2019-09-13 12:22:54 +00:00
#include "ui/ui_utility.h"
#include "window/section_memento.h"
#include "window/window_slide_animation.h"
2018-01-09 17:08:31 +00:00
#include "window/themes/window_theme.h"
#include "window/window_session_controller.h"
2019-09-13 12:22:54 +00:00
#include <rpl/range.h>
namespace Window {
AbstractSectionWidget::AbstractSectionWidget(
QWidget *parent,
not_null<SessionController*> controller,
PaintedBackground paintedBackground)
: RpWidget(parent)
, _controller(controller) {
if (paintedBackground == PaintedBackground::Section) {
controller->repaintBackgroundRequests(
) | rpl::start_with_next([=] {
update();
}, lifetime());
}
}
2019-07-24 11:45:24 +00:00
Main::Session &AbstractSectionWidget::session() const {
return _controller->session();
}
SectionWidget::SectionWidget(
QWidget *parent,
not_null<Window::SessionController*> controller,
PaintedBackground paintedBackground)
: AbstractSectionWidget(parent, controller, paintedBackground) {
}
void SectionWidget::setGeometryWithTopMoved(
const QRect &newGeometry,
int topDelta) {
_topDelta = topDelta;
bool willBeResized = (size() != newGeometry.size());
if (geometry() != newGeometry) {
2019-09-13 12:22:54 +00:00
auto weak = Ui::MakeWeak(this);
setGeometry(newGeometry);
if (!weak) {
return;
}
}
if (!willBeResized) {
resizeEvent(nullptr);
}
_topDelta = 0;
}
void SectionWidget::showAnimated(
SlideDirection direction,
const SectionSlideParams &params) {
if (_showAnimation) return;
showChildren();
auto myContentCache = grabForShowAnimation(params);
hideChildren();
showAnimatedHook(params);
_showAnimation = std::make_unique<SlideAnimation>();
_showAnimation->setDirection(direction);
_showAnimation->setRepaintCallback([this] { update(); });
_showAnimation->setFinishedCallback([this] { showFinished(); });
_showAnimation->setPixmaps(
params.oldContentCache,
myContentCache);
_showAnimation->setTopBarShadow(params.withTopBarShadow);
_showAnimation->setWithFade(params.withFade);
_showAnimation->start();
show();
}
2020-12-14 14:48:10 +00:00
std::shared_ptr<SectionMemento> SectionWidget::createMemento() {
return nullptr;
}
void SectionWidget::showFast() {
show();
showFinished();
}
2019-09-13 12:22:54 +00:00
QPixmap SectionWidget::grabForShowAnimation(
const SectionSlideParams &params) {
return Ui::GrabWidget(this);
}
2020-06-10 18:08:17 +00:00
void SectionWidget::PaintBackground(
not_null<Window::SessionController*> controller,
not_null<QWidget*> widget,
QRect clip) {
2018-01-09 17:08:31 +00:00
Painter p(widget);
const auto background = Window::Theme::Background();
const auto fullHeight = controller->content()->height();
if (const auto color = background->colorForFill()) {
p.fillRect(clip, *color);
return;
}
const auto gradient = background->gradientForFill();
const auto fill = QSize(widget->width(), fullHeight);
2020-06-10 18:08:17 +00:00
auto fromy = controller->content()->backgroundFromY();
auto state = controller->backgroundState(fill);
const auto paintCache = [&](const CachedBackground &cache) {
const auto to = QRect(
QPoint(cache.x, fromy + cache.y),
cache.pixmap.size() / cIntRetinaFactor());
if (cache.area == fill) {
p.drawPixmap(to, cache.pixmap);
} else {
const auto sx = fill.width() / float64(cache.area.width());
const auto sy = fill.height() / float64(cache.area.height());
const auto round = [](float64 value) -> int {
return (value >= 0.)
? int(std::ceil(value))
: int(std::floor(value));
};
const auto sto = QPoint(round(to.x() * sx), round(to.y() * sy));
p.drawPixmap(
sto.x(),
sto.y(),
round((to.x() + to.width()) * sx) - sto.x(),
round((to.y() + to.height()) * sy) - sto.y(),
cache.pixmap);
}
};
2021-08-16 10:24:15 +00:00
const auto hasNow = !state.now.pixmap.isNull();
const auto goodNow = hasNow && (state.now.area == fill);
const auto useCache = goodNow || (hasNow && !gradient.isNull());
if (useCache) {
if (state.shown < 1. && !gradient.isNull()) {
paintCache(state.was);
p.setOpacity(state.shown);
}
paintCache(state.now);
return;
}
const auto patternOpacity = background->paper().patternOpacity();
const auto &prepared = background->prepared();
if (!prepared.isNull() && !background->tile()) {
const auto hq = PainterHighQualityEnabler(p);
const auto rects = Window::Theme::ComputeBackgroundRects(
fill,
prepared.size());
if (!gradient.isNull()) {
p.drawImage(rects.to, gradient);
p.setCompositionMode(QPainter::CompositionMode_SoftLight);
p.setOpacity(patternOpacity);
}
auto to = rects.to;
to.moveTop(to.top() + fromy);
p.drawImage(to, prepared, rects.from);
return;
}
if (!gradient.isNull()) {
const auto hq = PainterHighQualityEnabler(p);
p.drawImage(QRect(QPoint(0, fromy), fill), gradient);
p.setCompositionMode(QPainter::CompositionMode_SoftLight);
p.setOpacity(patternOpacity);
}
if (!prepared.isNull()) {
const auto &tiled = background->preparedForTiled();
auto left = clip.left();
auto top = clip.top();
auto right = clip.left() + clip.width();
auto bottom = clip.top() + clip.height();
auto w = tiled.width() / cRetinaFactor();
auto h = tiled.height() / cRetinaFactor();
auto sx = qFloor(left / w);
auto sy = qFloor((top - fromy) / h);
auto cx = qCeil(right / w);
auto cy = qCeil((bottom - fromy) / h);
for (auto i = sx; i < cx; ++i) {
for (auto j = sy; j < cy; ++j) {
p.drawImage(QPointF(i * w, fromy + j * h), tiled);
}
2018-01-09 17:08:31 +00:00
}
}
}
void SectionWidget::paintEvent(QPaintEvent *e) {
if (_showAnimation) {
Painter p(this);
_showAnimation->paintContents(p, e->rect());
}
}
void SectionWidget::showFinished() {
_showAnimation.reset();
if (isHidden()) return;
showChildren();
showFinishedHook();
setInnerFocus();
}
rpl::producer<int> SectionWidget::desiredHeight() const {
return rpl::single(height());
}
SectionWidget::~SectionWidget() = default;
} // namespace Window