Revision control
Copy as Markdown
// Copyright (C) 2024 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
// Qt-Security score:significant reason:default
#include <QtGraphs/qpieseries.h>
#include <QtGraphs/qpieslice.h>
#include <QtQuick/private/qquicktaphandler_p.h>
#include <QtQuick/private/qquicktext_p.h>
#include "pierenderer_p.h"
#include <limits>
#include <private/pierenderer_p.h>
#include <private/qabstractseries_p.h>
#include <private/qgraphsview_p.h>
#include <private/qpieseries_p.h>
#include <private/qpieslice_p.h>
#include <private/qquickdraghandler_p.h>
#if QT_CONFIG(graphs_2d_high_quality_backend)
#include <private/qquickshape_p.h>
#endif
#if QT_CONFIG(graphs_2d_high_performance_backend)
#include <QtCanvasPainter/QCanvasPainter>
#endif
#include <qtgraphs_tracepoints_p.h>
QT_BEGIN_NAMESPACE
Q_TRACE_PREFIX(qtgraphs,
"QT_BEGIN_NAMESPACE" \
"class PieRenderer;" \
"QT_END_NAMESPACE"
)
Q_TRACE_POINT(qtgraphs, QGraphs2DPieRendererAfterPolish_entry, int cleanupSeriesCount);
Q_TRACE_POINT(qtgraphs, QGraphs2DPieRendererAfterPolish_exit);
Q_TRACE_POINT(qtgraphs, QGraphs2DPieRendererHandlePolish_entry, int sliceCount);
Q_TRACE_POINT(qtgraphs, QGraphs2DPieRendererHandlePolish_exit);
constexpr qreal qrealMax = std::numeric_limits<qreal>::max();
PieRenderer::PieRenderer(QGraphsView *graph, bool clipPlotArea)
: QQuickItem(graph)
, m_graph(graph)
, m_painterPath()
{
setFlag(QQuickItem::ItemHasContents);
setClip(clipPlotArea);
#if QT_CONFIG(graphs_2d_high_quality_backend)
m_shape = new QQuickShape(this);
m_shape->setParentItem(this);
m_shape->setPreferredRendererType(QQuickShape::CurveRenderer);
#endif
m_tapHandler = new QQuickTapHandler(this);
connect(m_tapHandler, &QQuickTapHandler::singleTapped, this, &PieRenderer::onSingleTapped);
connect(m_tapHandler, &QQuickTapHandler::doubleTapped, this, &PieRenderer::onDoubleTapped);
connect(m_tapHandler, &QQuickTapHandler::pressedChanged, this, &PieRenderer::onPressedChanged);
m_dragHandler = new QQuickDragHandler(this);
m_dragHandler->setTarget(nullptr);
connect(m_dragHandler, &QQuickDragHandler::grabChanged, this, &PieRenderer::onGrabChanged);
connect(m_dragHandler,
&QQuickDragHandler::translationChanged,
this,
&PieRenderer::onTranslationChanged);
}
PieRenderer::~PieRenderer() {}
void PieRenderer::setSize(QSizeF size)
{
QQuickItem::setSize(size);
}
#if QT_CONFIG(graphs_2d_high_performance_backend)
void PieRenderer::paintSnapshot(const PaintSnapshot &paintSnapshot, QCanvasPainter *p)
{
for (auto it = paintSnapshot.cbegin(); it != paintSnapshot.cend(); it++) {
const auto &data = it.value();
if (data.seriesVisible) {
// border color
QColor borderColor = data.resolvedBorderColor;
// border width
qreal borderWidth = data.resolvedBorderWidth;
// color
QColor color = data.resolvedColor;
p->setFillStyle(color);
p->setStrokeStyle(borderColor);
p->setLineWidth(borderWidth);
p->beginPath();
p->addPath(data.shapePainterPath);
p->fill();
p->stroke();
}
QColor labelTextColor = data.resolvedLabelTextColor;
if (data.seriesVisible && data.labelPathVisible) {
p->setStrokeStyle(labelTextColor);
p->beginPath();
p->addPath(data.labelPainterPath);
p->stroke();
}
}
}
void PieRenderer::synchronizeData()
{
m_paintSnapshot = m_activeSlices;
}
PieRenderer::PaintSnapshot PieRenderer::paintSnapshot() const
{
return m_paintSnapshot;
}
#endif
void PieRenderer::updateActiveSlices(QPieSeries *series, QList<QPieSlice *> slicelist)
{
for (QPieSlice *slice : std::as_const(slicelist)) {
QPieSlicePrivate *d = slice->d_func();
#if QT_CONFIG(graphs_2d_high_quality_backend)
QQuickShapePath *shapePath = d->m_shapePath;
QQuickShapePath *labelPath = d->m_labelPath;
auto labelElements = labelPath->pathElements();
auto pathElements = shapePath->pathElements();
#endif
auto labelItem = d->m_labelItem;
auto it = m_activeSlices.find(slice);
if (it == m_activeSlices.end()) {
#if QT_CONFIG(graphs_2d_high_quality_backend)
auto data = m_shape->data();
data.append(&data, shapePath);
#endif
SliceData sliceData{};
sliceData.initialized = false;
#if QT_CONFIG(graphs_2d_high_quality_backend)
sliceData.shapePath = shapePath;
#endif
it = m_activeSlices.insert(slice, sliceData);
}
it->seriesVisible = series->isVisible();
#if QT_CONFIG(graphs_2d_high_quality_backend)
QQuickShape *labelShape = d->m_labelShape;
labelShape->setVisible(series->isVisible() && d->m_isLabelVisible);
#endif
labelItem->setVisible(series->isVisible() && d->m_isLabelVisible);
updateActiveSlices(series, slice->subSlices());
if (!series->isVisible()) {
#if QT_CONFIG(graphs_2d_high_quality_backend)
pathElements.clear(&pathElements);
labelElements.clear(&labelElements);
#endif
continue;
}
#if QT_CONFIG(graphs_2d_high_quality_backend)
if (!shapePath->parent())
shapePath->setParent(m_shape);
#endif
if (!d->m_labelItem->parent()) {
d->m_labelItem->setParent(this);
d->m_labelItem->setParentItem(this);
}
#if QT_CONFIG(graphs_2d_high_quality_backend)
if (!labelShape->parent()) {
labelShape->setParent(this);
labelShape->setParentItem(this);
}
#endif
}
}
void PieRenderer::handlePolish(QPieSeries *series)
{
#if QT_CONFIG(graphs_2d_high_quality_backend)
// The shape's paths are only refreshed while the canvas painter is off, so leaving it
// visible after a switch to the canvas painter would keep drawing the geometry from the
// last polish underneath that backend's output.
m_shape->setVisible(!m_graph->useCanvasPainter());
#endif
auto slices = series->slices();
updateActiveSlices(series, slices);
if (!series->isVisible())
return;
QPointF center = QPointF(size().width() * series->horizontalPosition(),
size().height() * series->verticalPosition());
qreal radius = size().width() > size().height() ? size().height() : size().width();
radius *= (.5 * series->pieSize());
QGraphsTheme *theme = m_graph->theme();
if (!theme) {
qCCritical(lcCritical2D, "Theme not found.");
return;
}
if (m_colorIndex < 0)
m_colorIndex = m_graph->graphSeriesCount();
m_graph->setGraphSeriesCount(m_colorIndex + series->slices().size());
QList<QLegendData> legendDataList;
auto slicelist = series->slices();
Q_TRACE(QGraphs2DPieRendererHandlePolish_entry, static_cast<int>(slicelist.count()));
handleSlicesPolish(series, legendDataList, slicelist, series->startAngle(), series->endAngle(),
center, radius, 1.0);
Q_TRACE(QGraphs2DPieRendererHandlePolish_exit);
series->d_func()->setLegendData(legendDataList);
}
void PieRenderer::handleSlicesPolish(QPieSeries *series,
QList<QLegendData> &legendDataList,
QList<QPieSlice *> slicelist,
qreal startAngle,
qreal endAngle,
QPointF center,
qreal radius,
qreal radiusRatio)
{
QGraphsTheme *theme = m_graph->theme();
int sliceIndex = 0;
qreal sliceAngle = startAngle;
for (QPieSlice *slice : std::as_const(slicelist)) {
m_painterPath.clear();
auto *d = QPieSlicePrivate::get(slice);
d->setStartAngle(sliceAngle);
d->setAngleSpan((endAngle - startAngle) * slice->percentage()
* series->valuesMultiplier());
// update slice
#if QT_CONFIG(graphs_2d_high_quality_backend)
QQuickShapePath *shapePath = d->m_shapePath;
#endif
// border color
const auto &borderColors = theme->borderColors();
int index = sliceIndex % borderColors.size();
QColor borderColor = borderColors.at(index);
if (d->m_borderColor.isValid() && d->m_borderColor.alpha() != 0)
borderColor = d->m_borderColor;
// color
const auto &seriesColors = theme->seriesColors();
index = sliceIndex % seriesColors.size();
QColor color = seriesColors.at(index);
if (d->m_color.isValid() && d->m_color.alpha() != 0)
color = d->m_color;
// border width
qreal borderWidth = theme->borderWidth();
if (d->m_borderWidth >= 1.0)
borderWidth = d->m_borderWidth;
#if QT_CONFIG(graphs_2d_high_quality_backend)
shapePath->setStrokeColor(borderColor);
shapePath->setFillColor(color);
shapePath->setStrokeWidth(borderWidth);
#endif
QColor labelTextColor = theme->labelTextColor();
if (d->m_labelColor.isValid())
labelTextColor = d->m_labelColor;
d->m_labelItem->setColor(labelTextColor);
#if QT_CONFIG(graphs_2d_high_quality_backend)
d->m_labelPath->setStrokeColor(labelTextColor);
#endif
if (!m_activeSlices.contains(slice))
continue;
m_activeSlices[slice].sliceIndex = sliceIndex;
m_activeSlices[slice].resolvedColor = color;
m_activeSlices[slice].resolvedBorderColor = borderColor;
m_activeSlices[slice].resolvedBorderWidth = borderWidth;
m_activeSlices[slice].resolvedLabelTextColor = labelTextColor;
m_activeSlices[slice].labelPathVisible = d->m_isLabelPathVisible;
qreal radian = qDegreesToRadians(slice->startAngle());
qreal startBigX = radius * qSin(radian) * radiusRatio;
qreal startBigY = radius * qCos(radian) * radiusRatio;
qreal startSmallX = startBigX * series->holeSize();
qreal startSmallY = startBigY * series->holeSize();
qreal explodeDistance = .0;
if (slice->isExploded())
explodeDistance = slice->explodeDistanceFactor() * radius;
radian = qDegreesToRadians(slice->startAngle() + (slice->angleSpan() * .5));
qreal xShift = center.x() + (explodeDistance * qSin(radian));
qreal yShift = center.y() - (explodeDistance * qCos(radian));
qreal pointX = startBigY * qSin(radian) + startBigX * qCos(radian);
qreal pointY = startBigY * qCos(radian) - startBigX * qSin(radian);
qreal newCenterX = center.x() + (explodeDistance * qSin(radian));
qreal newCenterY = center.y() - (explodeDistance * qCos(radian));
QRectF rect(newCenterX - radius * radiusRatio,
newCenterY - radius * radiusRatio,
radius * 2 * radiusRatio,
radius * 2 * radiusRatio);
#if QT_CONFIG(graphs_2d_high_quality_backend)
shapePath->setStartX(center.x());
shapePath->setStartY(center.y());
#endif
if (series->holeSize() > 0) {
QRectF insideRect(center.x() - series->holeSize() * radius
+ (explodeDistance * qSin(radian)),
center.y() - series->holeSize() * radius
- (explodeDistance * qCos(radian)),
series->holeSize() * radius * 2,
series->holeSize() * radius * 2);
m_painterPath.arcMoveTo(rect, -slice->startAngle() + 90);
m_painterPath.arcTo(rect, -slice->startAngle() + 90, -slice->angleSpan());
m_painterPath.arcTo(insideRect,
-slice->startAngle() + 90 - slice->angleSpan(),
slice->angleSpan());
m_painterPath.closeSubpath();
} else {
m_painterPath.moveTo(rect.center());
m_painterPath.arcTo(rect, -slice->startAngle() + 90, -slice->angleSpan());
m_painterPath.closeSubpath();
}
radian = qDegreesToRadians(slice->angleSpan());
pointX = startSmallY * qSin(radian) + startSmallX * qCos(radian);
pointY = startSmallY * qCos(radian) - startSmallX * qSin(radian);
d->m_largeArc = {xShift + pointX, yShift - pointY};
#if QT_CONFIG(graphs_2d_high_quality_backend)
if (!m_graph->useCanvasPainter())
shapePath->setPath(m_painterPath);
else
#endif
d->m_shapePainterPath = m_painterPath;
m_activeSlices[slice].shapePainterPath = std::exchange(m_painterPath, {});
radian = qDegreesToRadians(slice->startAngle() + (slice->angleSpan() * .5));
startBigX = radius * qSin(radian) * radiusRatio;
startBigY = radius * qCos(radian) * radiusRatio;
pointX = radius * (1.0 + d->m_labelArmLengthFactor) * qSin(radian);
pointY = radius * (1.0 + d->m_labelArmLengthFactor) * qCos(radian);
m_painterPath.moveTo(xShift + startBigX, yShift - startBigY);
m_painterPath.lineTo(xShift + pointX, yShift - pointY);
d->m_centerLine = {xShift + pointX, yShift - pointY};
d->m_labelArm = {xShift + pointX, yShift - pointY};
auto labelWidth = radian > M_PI ? -d->m_labelItem->width() : d->m_labelItem->width();
m_painterPath.lineTo(d->m_labelArm.x() + labelWidth, d->m_labelArm.y());
d->setLabelPosition(d->m_labelPosition);
#if QT_CONFIG(graphs_2d_high_quality_backend)
if (!m_graph->useCanvasPainter())
d->m_labelPath->setPath(m_painterPath);
else
#endif
d->m_labelPainterPath = m_painterPath;
m_activeSlices[slice].labelPainterPath = m_painterPath;
sliceAngle += slice->angleSpan();
sliceIndex++;
handleSlicesPolish(series,
legendDataList,
slice->subSlices(),
slice->startAngle(),
slice->startAngle() + slice->angleSpan(),
{newCenterX, newCenterY},
radius,
radiusRatio * slice->subSlicesRatio());
legendDataList.push_back({color, borderColor, d->m_labelText});
}
}
void PieRenderer::afterPolish(QList<QAbstractSeries *> &cleanupSeries)
{
Q_TRACE(QGraphs2DPieRendererAfterPolish_entry, static_cast<int>(cleanupSeries.count()));
Q_UNUSED(cleanupSeries);
}
void PieRenderer::handleSlicesAfterPolish(QList<QPieSlice *> slicelist)
{
for (QPieSlice *slice : std::as_const(slicelist)) {
const auto *d = QPieSlicePrivate::get(slice);
#if QT_CONFIG(graphs_2d_high_quality_backend)
auto labelElements = d->m_labelPath->pathElements();
auto shapeElements = d->m_shapePath->pathElements();
labelElements.clear(&labelElements);
shapeElements.clear(&shapeElements);
#endif
slice->deleteLater();
freeSlice(d);
m_activeSlices.remove(slice);
handleSlicesAfterPolish(slice->subSlices());
}
Q_TRACE(QGraphs2DPieRendererAfterPolish_exit);
}
void PieRenderer::updateSeries(QPieSeries *series)
{
auto needPolish = false;
for (auto &sliceData : m_activeSlices) {
if (!sliceData.initialized) {
sliceData.initialized = true;
needPolish = true;
}
}
if (needPolish)
handlePolish(series);
}
void PieRenderer::seriesAboutToBeRemoved(QAbstractSeries *series)
{
if (auto pieSeries = qobject_cast<QPieSeries *>(series)) {
handleSlicesAfterPolish(pieSeries->slices());
#if QT_CONFIG(graphs_2d_high_quality_backend)
rebuildShapePaths();
#endif
}
}
void PieRenderer::afterUpdate(QList<QAbstractSeries *> &cleanupSeries)
{
Q_UNUSED(cleanupSeries);
}
void PieRenderer::markedDeleted(QList<QPieSlice *> deleted)
{
auto emptyPath = QPainterPath{};
for (auto slice : deleted) {
const auto d = QPieSlicePrivate::get(slice);
#if QT_CONFIG(graphs_2d_high_quality_backend)
d->m_shapePath->setPath(emptyPath);
d->m_labelPath->setPath(emptyPath);
#endif
d->m_shapePainterPath.clear();
d->m_labelPainterPath.clear();
freeSlice(d);
m_activeSlices.remove(slice);
}
// We could mark m_currentHoverSlice null only if
// it matches to a deleted slice, but as removals
// affect other slices positions it is probably
// better to just always disable current hovering.
m_currentHoverSlice = nullptr;
#if QT_CONFIG(graphs_2d_high_quality_backend)
rebuildShapePaths();
#endif
}
bool PieRenderer::isPointInSlice(QPointF point, QPieSlice *slice, qreal *angle)
{
QPieSeries* series = slice->series();
QPointF center = QPointF(size().width() * series->horizontalPosition(),
size().height() * series->verticalPosition());
qreal radius = size().width() > size().height() ? size().height() : size().width();
radius *= (.5 * series->pieSize());
qreal explodeDistance = .0;
if (slice->isExploded())
explodeDistance = slice->explodeDistanceFactor() * radius;
qreal radian = qDegreesToRadians(slice->startAngle() + (slice->angleSpan() * .5));
qreal xShift = center.x() + explodeDistance * qSin(radian);
qreal yShift = center.y() - explodeDistance * qCos(radian);
QPointF adjustedPosition = QPointF(point.x() - xShift,
point.y() - yShift);
qreal foundAngle = qRadiansToDegrees(qAtan2(adjustedPosition.y(), adjustedPosition.x())) + 90;
if (foundAngle < 0)
foundAngle += 360;
if (angle)
*angle = foundAngle;
// Check if we are in a sub slice
if (isPointInSubSlices(point, slice))
return false;
QPieSlicePrivate *d = slice->d_func();
QPainterPath painterPath;
#if QT_CONFIG(graphs_2d_high_quality_backend)
QQuickShapePath *shapePath = d->m_shapePath;
if (!m_graph->useCanvasPainter())
painterPath = shapePath->path();
else
#endif
painterPath = d->m_shapePainterPath;
return painterPath.contains(point);
}
bool PieRenderer::isPointInSubSlices(QPointF point, QPieSlice *slice)
{
auto slices = slice->subSlices();
for (const auto &subSlice : std::as_const(slices)) {
QPieSlicePrivate *d = subSlice->d_func();
QPainterPath painterPath;
#if QT_CONFIG(graphs_2d_high_quality_backend)
QQuickShapePath *shapePath = d->m_shapePath;
if (!m_graph->useCanvasPainter())
painterPath = shapePath->path();
else
#endif
painterPath = d->m_shapePainterPath;
if (painterPath.contains(point))
return true;
if (isPointInSubSlices(point, subSlice))
return true;
}
return false;
}
qreal PieRenderer::distanceToSegment(const QVector2D p, const QVector2D segmentStart,
const QVector2D segmentEnd)
{
static qreal maxdistance = 15.0;
QVector2D line(segmentEnd - segmentStart);
QVector2D startToP(p - segmentStart);
qreal t = QVector2D::dotProduct(startToP, line) / line.lengthSquared();
t = qBound(0.0, t, 1.0);
QVector2D proj = segmentStart + t * line;
qreal distance = (p - proj).length();
return distance <= maxdistance ? distance : qrealMax;
}
void PieRenderer::freeSlice(const QPieSlicePrivate *privSlice)
{
#if QT_CONFIG(graphs_2d_high_quality_backend)
privSlice->m_labelShape->deleteLater();
privSlice->m_shapePath->deleteLater();
#endif
privSlice->m_labelItem->deleteLater();
}
#if QT_CONFIG(graphs_2d_high_quality_backend)
// QQuickShape keeps raw pointers to its shape paths and never drops a path that gets destroyed,
// so a path freed by freeSlice() would stay in the shape's list and be dereferenced on the next
// path change. There is no way to remove a single path, so reset the list and re-add the paths
// of the slices that are still active. The shape draws its paths in list order, so re-add them
// in series and slice order to keep the original stacking.
void PieRenderer::rebuildShapePaths()
{
auto data = m_shape->data();
data.clear(&data);
for (QObject *object : std::as_const(m_graph->m_seriesList)) {
if (auto pieSeries = qobject_cast<QPieSeries *>(object))
appendShapePaths(data, pieSeries->slices());
}
}
void PieRenderer::appendShapePaths(QQmlListProperty<QObject> &data,
const QList<QPieSlice *> &slicelist)
{
for (QPieSlice *slice : slicelist) {
auto it = m_activeSlices.constFind(slice);
if (it != m_activeSlices.cend())
data.append(&data, it->shapePath);
appendShapePaths(data, slice->subSlices());
}
}
#endif
bool PieRenderer::handleHoverMove(QHoverEvent *event)
{
bool handled = false;
const QPointF &position = event->position();
bool hovering = false;
QList<QPieSlice *> list = m_activeSlices.keys();
for (const auto &slice : std::as_const(list)) {
if (!slice->series()->isHoverable())
continue;
qreal angle;
if (isPointInSlice(position, slice, &angle)) {
const QString &name = slice->series()->name();
const QPointF value(slice->startAngle(), angle);
if (!m_currentHoverSlice) {
m_currentHoverSlice = slice;
slice->series()->setHovered(true);
emit slice->series()->hoverEnter(name, position, value);
}
if (m_currentHoverSlice != slice) {
slice->series()->setHovered(true);
emit m_currentHoverSlice->series()->hoverExit(name, position);
emit slice->series()->hoverEnter(name, position, value);
m_currentHoverSlice = slice;
}
emit slice->series()->hover(name, position, value);
hovering = true;
handled = true;
}
}
if (!hovering && m_currentHoverSlice) {
m_currentHoverSlice->series()->setHovered(false);
emit m_currentHoverSlice->series()->
hoverExit(m_currentHoverSlice->series()->name(), position);
m_currentHoverSlice = nullptr;
handled = true;
}
return handled;
}
void PieRenderer::onSingleTapped(QEventPoint eventPoint, Qt::MouseButton button)
{
Q_UNUSED(button)
QList<QPieSlice *> list = m_activeSlices.keys();
for (const auto &pieSlice : std::as_const(list)) {
if (!pieSlice->series()->isSelectable())
continue;
if (isPointInSlice(eventPoint.position(), pieSlice)) {
emit pieSlice->series()->clicked(pieSlice);
return;
}
}
}
void PieRenderer::onDoubleTapped(QEventPoint eventPoint, Qt::MouseButton button)
{
Q_UNUSED(button)
QList<QPieSlice *> list = m_activeSlices.keys();
for (const auto &pieSlice : std::as_const(list)) {
if (!pieSlice->series()->isSelectable())
continue;
if (isPointInSlice(eventPoint.position(), pieSlice)) {
emit pieSlice->series()->doubleClicked(pieSlice);
return;
}
}
}
void PieRenderer::onPressedChanged()
{
QList<QPieSlice *> list = m_activeSlices.keys();
for (const auto &pieSlice : std::as_const(list)) {
if (!pieSlice->series()->isSelectable())
continue;
if (isPointInSlice(m_tapHandler->point().position(), pieSlice)) {
if (m_tapHandler->isPressed())
emit pieSlice->series()->pressed(pieSlice);
else
emit pieSlice->series()->released(pieSlice);
return;
}
}
}
void PieRenderer::onGrabChanged(QPointingDevice::GrabTransition transition, QEventPoint eventPoint)
{
QList<QPieSlice *> slices = m_activeSlices.keys();
if (transition == QPointingDevice::GrabTransition::GrabPassive) {
const qreal radiusRatio = 1.0;
for (const auto &slice : std::as_const(slices)) {
if (isPointInSlice(eventPoint.position(), slice)) {
m_dragSlice = slice;
// Slice side length
qreal radius = size().width() > size().height() ? size().height() : size().width();
radius *= (.5 * slice->series()->pieSize());
m_dragState.dragSeriesRadius = radius;
qreal startAngle = -slice->startAngle() + 90;
qreal startRadian = qDegreesToRadians(startAngle);
qreal endRadian = qDegreesToRadians(startAngle - slice->angleSpan());
QVector2D center(size().width() * slice->series()->horizontalPosition(),
size().height() * slice->series()->verticalPosition());
m_dragState.dragSeriesCenter = center;
QVector2D leftEndPoint(center.x() + (radius * radiusRatio * qCos(startRadian)),
center.y() - (radius * radiusRatio * qSin(startRadian)));
QVector2D rightEndPoint(center.x() + (radius * radiusRatio * qCos(endRadian)),
center.y() - (radius * radiusRatio * qSin(endRadian)));
qreal d_left =
distanceToSegment(QVector2D(eventPoint.position()), center, leftEndPoint);
qreal d_right =
distanceToSegment(QVector2D(eventPoint.position()), center, rightEndPoint);
if (d_left < qrealMax && d_left < d_right)
m_closerEdge = Qt::LeftEdge;
else if (d_right < qrealMax && d_left > d_right)
m_closerEdge = Qt::RightEdge;
else
return;
m_dragState.dragging = true;
break;
}
}
} else if (transition == QPointingDevice::UngrabPassive) {
m_dragSlice = nullptr;
m_dragState.dragging = false;
}
}
void PieRenderer::onTranslationChanged(QVector2D delta)
{
if (!m_dragState.dragging)
return;
qreal startAngle = -m_dragSlice->startAngle() + 90;
qreal startRadian = qDegreesToRadians(startAngle);
qreal endRadian = qDegreesToRadians(startAngle - m_dragSlice->angleSpan());
QVector2D leftEndPoint(
m_dragState.dragSeriesCenter.x() + (m_dragState.dragSeriesRadius * qCos(startRadian)),
m_dragState.dragSeriesCenter.y() - (m_dragState.dragSeriesRadius * qSin(startRadian)));
QVector2D rightEndPoint(
m_dragState.dragSeriesCenter.x() + (m_dragState.dragSeriesRadius * qCos(endRadian)),
m_dragState.dragSeriesCenter.y() - (m_dragState.dragSeriesRadius * qSin(endRadian)));
// Calculate the edge
QVector2D edgeCenter;
if (m_closerEdge == Qt::LeftEdge)
edgeCenter = (leftEndPoint - m_dragState.dragSeriesCenter) / 2;
else if (m_closerEdge == Qt::RightEdge)
edgeCenter = (rightEndPoint - m_dragState.dragSeriesCenter) / 2;
QVector2D perpendicular(-edgeCenter.y(), edgeCenter.x());
perpendicular.normalize();
delta.normalize();
float dragAmount = QVector2D::dotProduct(delta, perpendicular);
if (qAbs(dragAmount) < qCos((qDegreesToRadians(45))))
return;
const float sensitivity = 0.1f;
qreal change = dragAmount * sensitivity;
change = m_closerEdge == Qt::RightEdge ? change : change * -1;
m_dragSlice->setValue(m_dragSlice->value() + change);
}
QT_END_NAMESPACE
#include "moc_pierenderer_p.cpp"