398 lines
11 KiB
C++
398 lines
11 KiB
C++
/*
|
|
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/widgets/continuous_sliders.h"
|
|
|
|
#include "ui/painter.h"
|
|
#include "base/timer.h"
|
|
#include "base/platform/base_platform_info.h"
|
|
|
|
namespace Ui {
|
|
namespace {
|
|
|
|
constexpr auto kByWheelFinishedTimeout = 1000;
|
|
|
|
} // namespace
|
|
|
|
ContinuousSlider::ContinuousSlider(QWidget *parent) : RpWidget(parent) {
|
|
setCursor(style::cur_pointer);
|
|
}
|
|
|
|
void ContinuousSlider::setDisabled(bool disabled) {
|
|
if (_disabled != disabled) {
|
|
_disabled = disabled;
|
|
setCursor(_disabled ? style::cur_default : style::cur_pointer);
|
|
update();
|
|
}
|
|
}
|
|
|
|
void ContinuousSlider::setMoveByWheel(bool move) {
|
|
if (move != moveByWheel()) {
|
|
if (move) {
|
|
_byWheelFinished = std::make_unique<base::Timer>([=] {
|
|
if (_changeFinishedCallback) {
|
|
_changeFinishedCallback(getCurrentValue());
|
|
}
|
|
});
|
|
} else {
|
|
_byWheelFinished = nullptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
QRect ContinuousSlider::getSeekRect() const {
|
|
const auto decrease = getSeekDecreaseSize();
|
|
return isHorizontal()
|
|
? QRect(decrease.width() / 2, 0, width() - decrease.width(), height())
|
|
: QRect(0, decrease.height() / 2, width(), height() - decrease.width());
|
|
}
|
|
|
|
float64 ContinuousSlider::value() const {
|
|
return getCurrentValue();
|
|
}
|
|
|
|
void ContinuousSlider::setValue(float64 value) {
|
|
setValue(value, -1);
|
|
}
|
|
|
|
void ContinuousSlider::setValue(float64 value, float64 receivedTill) {
|
|
if (_value != value || _receivedTill != receivedTill) {
|
|
_value = value;
|
|
_receivedTill = receivedTill;
|
|
update();
|
|
}
|
|
}
|
|
|
|
void ContinuousSlider::setFadeOpacity(float64 opacity) {
|
|
_fadeOpacity = opacity;
|
|
update();
|
|
}
|
|
|
|
void ContinuousSlider::mouseMoveEvent(QMouseEvent *e) {
|
|
if (_mouseDown) {
|
|
updateDownValueFromPos(e->pos());
|
|
}
|
|
}
|
|
|
|
float64 ContinuousSlider::computeValue(const QPoint &pos) const {
|
|
const auto seekRect = myrtlrect(getSeekRect());
|
|
const auto result = isHorizontal() ?
|
|
(pos.x() - seekRect.x()) / float64(seekRect.width()) :
|
|
(1. - (pos.y() - seekRect.y()) / float64(seekRect.height()));
|
|
const auto snapped = std::clamp(result, 0., 1.);
|
|
return _adjustCallback ? _adjustCallback(snapped) : snapped;
|
|
}
|
|
|
|
void ContinuousSlider::mousePressEvent(QMouseEvent *e) {
|
|
_mouseDown = true;
|
|
_downValue = computeValue(e->pos());
|
|
update();
|
|
if (_changeProgressCallback) {
|
|
_changeProgressCallback(_downValue);
|
|
}
|
|
}
|
|
|
|
void ContinuousSlider::mouseReleaseEvent(QMouseEvent *e) {
|
|
if (_mouseDown) {
|
|
_mouseDown = false;
|
|
if (_changeFinishedCallback) {
|
|
_changeFinishedCallback(_downValue);
|
|
}
|
|
_value = _downValue;
|
|
update();
|
|
}
|
|
}
|
|
|
|
void ContinuousSlider::wheelEvent(QWheelEvent *e) {
|
|
if (_mouseDown || !moveByWheel()) {
|
|
return;
|
|
}
|
|
constexpr auto step = static_cast<int>(QWheelEvent::DefaultDeltasPerStep);
|
|
constexpr auto coef = 1. / (step * 10.);
|
|
|
|
auto deltaX = e->angleDelta().x(), deltaY = e->angleDelta().y();
|
|
if (Platform::IsMac()) {
|
|
deltaY *= -1;
|
|
} else {
|
|
deltaX *= -1;
|
|
}
|
|
auto delta = (qAbs(deltaX) > qAbs(deltaY)) ? deltaX : deltaY;
|
|
auto finalValue = std::clamp(_value + delta * coef, 0., 1.);
|
|
setValue(finalValue);
|
|
if (_changeProgressCallback) {
|
|
_changeProgressCallback(finalValue);
|
|
}
|
|
_byWheelFinished->callOnce(kByWheelFinishedTimeout);
|
|
}
|
|
|
|
void ContinuousSlider::updateDownValueFromPos(const QPoint &pos) {
|
|
_downValue = computeValue(pos);
|
|
update();
|
|
if (_changeProgressCallback) {
|
|
_changeProgressCallback(_downValue);
|
|
}
|
|
}
|
|
|
|
void ContinuousSlider::enterEventHook(QEnterEvent *e) {
|
|
setOver(true);
|
|
}
|
|
|
|
void ContinuousSlider::leaveEventHook(QEvent *e) {
|
|
setOver(false);
|
|
}
|
|
|
|
void ContinuousSlider::setOver(bool over) {
|
|
if (_over == over) return;
|
|
|
|
_over = over;
|
|
auto from = _over ? 0. : 1., to = _over ? 1. : 0.;
|
|
_overAnimation.start([=] { update(); }, from, to, getOverDuration());
|
|
}
|
|
|
|
FilledSlider::FilledSlider(QWidget *parent, const style::FilledSlider &st) : ContinuousSlider(parent)
|
|
, _st(st) {
|
|
}
|
|
|
|
QSize FilledSlider::getSeekDecreaseSize() const {
|
|
return QSize(0, 0);
|
|
}
|
|
|
|
float64 FilledSlider::getOverDuration() const {
|
|
return _st.duration;
|
|
}
|
|
|
|
void FilledSlider::paintEvent(QPaintEvent *e) {
|
|
auto p = QPainter(this);
|
|
PainterHighQualityEnabler hq(p);
|
|
|
|
p.setPen(Qt::NoPen);
|
|
|
|
const auto masterOpacity = fadeOpacity();
|
|
const auto disabled = isDisabled();
|
|
const auto over = getCurrentOverFactor();
|
|
const auto lineWidth = _st.lineWidth + ((_st.fullWidth - _st.lineWidth) * over);
|
|
const auto lineWidthRounded = std::floor(lineWidth);
|
|
const auto lineWidthPartial = lineWidth - lineWidthRounded;
|
|
const auto seekRect = getSeekRect();
|
|
const auto value = getCurrentValue();
|
|
const auto from = seekRect.x();
|
|
const auto mid = qRound(from + value * seekRect.width());
|
|
const auto end = from + seekRect.width();
|
|
if (mid > from) {
|
|
p.setOpacity(masterOpacity);
|
|
p.fillRect(from, height() - lineWidthRounded, (mid - from), lineWidthRounded, disabled ? _st.disabledFg : _st.activeFg);
|
|
if (lineWidthPartial > 0.01) {
|
|
p.setOpacity(masterOpacity * lineWidthPartial);
|
|
p.fillRect(from, height() - lineWidthRounded - 1, (mid - from), 1, disabled ? _st.disabledFg : _st.activeFg);
|
|
}
|
|
}
|
|
if (end > mid && over > 0) {
|
|
p.setOpacity(masterOpacity * over);
|
|
p.fillRect(mid, height() - lineWidthRounded, (end - mid), lineWidthRounded, _st.inactiveFg);
|
|
if (lineWidthPartial > 0.01) {
|
|
p.setOpacity(masterOpacity * over * lineWidthPartial);
|
|
p.fillRect(mid, height() - lineWidthRounded - 1, (end - mid), 1, _st.inactiveFg);
|
|
}
|
|
}
|
|
}
|
|
|
|
MediaSlider::MediaSlider(QWidget *parent, const style::MediaSlider &st) : ContinuousSlider(parent)
|
|
, _st(st) {
|
|
}
|
|
|
|
QSize MediaSlider::getSeekDecreaseSize() const {
|
|
return _alwaysDisplayMarker ? _st.seekSize : QSize();
|
|
}
|
|
|
|
float64 MediaSlider::getOverDuration() const {
|
|
return _st.duration;
|
|
}
|
|
|
|
void MediaSlider::disablePaint(bool disabled) {
|
|
_paintDisabled = disabled;
|
|
}
|
|
|
|
void MediaSlider::addDivider(float64 atValue, const QSize &size) {
|
|
_dividers.push_back(Divider{ atValue, size });
|
|
}
|
|
|
|
void MediaSlider::setActiveFgOverride(std::optional<QColor> color) {
|
|
_activeFgOverride = color;
|
|
update();
|
|
}
|
|
|
|
void MediaSlider::paintEvent(QPaintEvent *e) {
|
|
if (_paintDisabled) {
|
|
return;
|
|
}
|
|
auto p = QPainter(this);
|
|
PainterHighQualityEnabler hq(p);
|
|
|
|
p.setPen(Qt::NoPen);
|
|
p.setOpacity(fadeOpacity());
|
|
|
|
const auto horizontal = isHorizontal();
|
|
const auto radius = _st.width / 2;
|
|
const auto disabled = isDisabled();
|
|
const auto over = getCurrentOverFactor();
|
|
const auto seekRect = getSeekRect();
|
|
|
|
// invert colors and value for vertical
|
|
const auto value = horizontal
|
|
? getCurrentValue()
|
|
: (1. - getCurrentValue());
|
|
|
|
// receivedTill is not supported for vertical
|
|
const auto receivedTill = horizontal
|
|
? getCurrentReceivedTill()
|
|
: value;
|
|
|
|
const auto markerFrom = (horizontal ? seekRect.x() : seekRect.y());
|
|
const auto markerLength = horizontal
|
|
? seekRect.width()
|
|
: seekRect.height();
|
|
const auto from = 0;
|
|
const auto length = (horizontal ? width() : height());
|
|
const auto alwaysSeekSize = horizontal
|
|
? _st.seekSize.width()
|
|
: _st.seekSize.height();
|
|
const auto mid = _alwaysDisplayMarker
|
|
? qRound(from
|
|
+ (alwaysSeekSize / 2.)
|
|
+ value * (length - alwaysSeekSize))
|
|
: qRound(from + value * length);
|
|
const auto till = horizontal
|
|
? std::max(mid, qRound(from + receivedTill * length))
|
|
: mid;
|
|
const auto end = from + length;
|
|
const auto activeFg = disabled
|
|
? _st.activeFgDisabled
|
|
: _activeFgOverride
|
|
? QBrush(*_activeFgOverride)
|
|
: anim::brush(_st.activeFg, _st.activeFgOver, over);
|
|
const auto receivedTillFg = _st.receivedTillFg;
|
|
const auto inactiveFg = disabled
|
|
? _st.inactiveFgDisabled
|
|
: anim::brush(_st.inactiveFg, _st.inactiveFgOver, over);
|
|
if (mid > from) {
|
|
const auto fromClipRect = horizontal
|
|
? QRect(0, 0, mid, height())
|
|
: QRect(0, 0, width(), mid);
|
|
const auto till = std::min(mid + radius, end);
|
|
const auto fromRect = horizontal
|
|
? QRect(from, (height() - _st.width) / 2, till - from, _st.width)
|
|
: QRect((width() - _st.width) / 2, from, _st.width, till - from);
|
|
p.setClipRect(fromClipRect);
|
|
p.setBrush(horizontal ? activeFg : inactiveFg);
|
|
p.drawRoundedRect(fromRect, radius, radius);
|
|
}
|
|
if (till > mid) {
|
|
Assert(horizontal);
|
|
auto clipRect = QRect(mid, 0, till - mid, height());
|
|
const auto left = std::max(mid - radius, from);
|
|
const auto right = std::min(till + radius, end);
|
|
const auto rect = QRect(
|
|
left,
|
|
(height() - _st.width) / 2,
|
|
right - left,
|
|
_st.width);
|
|
p.setClipRect(clipRect);
|
|
p.setBrush(receivedTillFg);
|
|
p.drawRoundedRect(rect, radius, radius);
|
|
}
|
|
if (end > till) {
|
|
const auto endClipRect = horizontal
|
|
? QRect(till, 0, width() - till, height())
|
|
: QRect(0, till, width(), height() - till);
|
|
const auto begin = std::max(till - radius, from);
|
|
const auto endRect = horizontal
|
|
? QRect(
|
|
begin,
|
|
(height() - _st.width) / 2,
|
|
end - begin,
|
|
_st.width)
|
|
: QRect(
|
|
(width() - _st.width) / 2,
|
|
begin,
|
|
_st.width,
|
|
end - begin);
|
|
p.setClipRect(endClipRect);
|
|
p.setBrush(horizontal ? inactiveFg : activeFg);
|
|
p.drawRoundedRect(endRect, radius, radius);
|
|
}
|
|
if (!_dividers.empty()) {
|
|
p.setClipRect(rect());
|
|
for (const auto ÷r : _dividers) {
|
|
const auto dividerValue = horizontal
|
|
? divider.atValue
|
|
: (1. - divider.atValue);
|
|
const auto dividerMid = base::SafeRound(from
|
|
+ dividerValue * length);
|
|
const auto &size = divider.size;
|
|
const auto rect = horizontal
|
|
? QRect(
|
|
dividerMid - size.width() / 2,
|
|
(height() - size.height()) / 2,
|
|
size.width(),
|
|
size.height())
|
|
: QRect(
|
|
(width() - size.height()) / 2,
|
|
dividerMid - size.width() / 2,
|
|
size.height(),
|
|
size.width());
|
|
p.setBrush(((value < dividerValue) == horizontal)
|
|
? inactiveFg
|
|
: activeFg);
|
|
const auto dividerRadius = size.width() / 2.;
|
|
p.drawRoundedRect(rect, dividerRadius, dividerRadius);
|
|
}
|
|
}
|
|
const auto markerSizeRatio = disabled
|
|
? 0.
|
|
: (_alwaysDisplayMarker ? 1. : over);
|
|
if (markerSizeRatio > 0) {
|
|
const auto position = qRound(markerFrom + value * markerLength)
|
|
- (horizontal
|
|
? (_st.seekSize.width() / 2)
|
|
: (_st.seekSize.height() / 2));
|
|
const auto seekButton = horizontal
|
|
? QRect(
|
|
position,
|
|
(height() - _st.seekSize.height()) / 2,
|
|
_st.seekSize.width(),
|
|
_st.seekSize.height())
|
|
: QRect(
|
|
(width() - _st.seekSize.width()) / 2,
|
|
position,
|
|
_st.seekSize.width(),
|
|
_st.seekSize.height());
|
|
const auto size = horizontal
|
|
? _st.seekSize.width()
|
|
: _st.seekSize.height();
|
|
const auto remove = static_cast<int>(
|
|
((1. - markerSizeRatio) * size) / 2.);
|
|
if (remove * 2 < size) {
|
|
p.setClipRect(rect());
|
|
p.setBrush(activeFg);
|
|
const auto xshift = horizontal
|
|
? std::max(
|
|
seekButton.x() + seekButton.width() - remove - width(),
|
|
0) + std::min(seekButton.x() + remove, 0)
|
|
: 0;
|
|
const auto yshift = horizontal
|
|
? 0
|
|
: std::max(
|
|
seekButton.y() + seekButton.height() - remove - height(),
|
|
0) + std::min(seekButton.y() + remove, 0);
|
|
p.drawEllipse(seekButton.marginsRemoved(
|
|
QMargins(remove, remove, remove, remove)
|
|
).translated(-xshift, -yshift));
|
|
}
|
|
}
|
|
}
|
|
|
|
} // namespace Ui
|