Revision control
Copy as Markdown
// Copyright (C) 2023 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
// Qt-Security score:significant reason:default
#include <private/qgraphsglobal_p.h>
#if QT_CONFIG(graphs_2d_line) || QT_CONFIG(graphs_2d_area)
#include <QtGraphs/qlineseries.h>
#endif
#if QT_CONFIG(graphs_2d_scatter)
#include <QtGraphs/qscatterseries.h>
#endif
#if QT_CONFIG(graphs_2d_spline)
#include <QtGraphs/qsplineseries.h>
#endif
#if QT_CONFIG(graphs_2d_high_performance_backend)
#include <QtCanvasPainter/QCanvasPainter>
#endif
#include <QtCore/qmath.h>
#include <QtQuick/private/qquickdraghandler_p.h>
#include <QtQuick/private/qquicktaphandler_p.h>
#include <private/axisrenderer_p.h>
#include <private/charthelpers_p.h>
#include <private/pointrenderer_p.h>
#include <private/qabstractseries_p.h>
#include <private/qgraphsview_p.h>
#include <private/qpolarview_p.h>
#include <private/qxyseries_p.h>
#include <qtgraphs_tracepoints_p.h>
QT_BEGIN_NAMESPACE
Q_TRACE_PREFIX(qtgraphs,
"QT_BEGIN_NAMESPACE" \
"class PointRenderer;" \
"QT_END_NAMESPACE"
)
Q_TRACE_POINT(qtgraphs, QGraphs2DPointRendererAfterPolish_entry, int cleanupSeriesCount);
Q_TRACE_POINT(qtgraphs, QGraphs2DPointRendererAfterPolish_exit);
Q_TRACE_POINT(qtgraphs, QGraphs2DPointRendererUpdateScatterSeries_entry);
Q_TRACE_POINT(qtgraphs, QGraphs2DPointRendererUpdateScatterSeries_exit);
Q_TRACE_POINT(qtgraphs, QGraphs2DPointRendererUpdateLineSeries_entry);
Q_TRACE_POINT(qtgraphs, QGraphs2DPointRendererUpdateLineSeries_exit);
Q_TRACE_POINT(qtgraphs, QGraphs2DPointRendererUpdateSplineSeries_entry);
Q_TRACE_POINT(qtgraphs, QGraphs2DPointRendererUpdateSplineSeries_exit);
static const char *TAG_POINT_COLOR = "pointColor";
static const char *TAG_POINT_BORDER_COLOR = "pointBorderColor";
static const char *TAG_POINT_BORDER_WIDTH = "pointBorderWidth";
static const char *TAG_POINT_SELECTED_COLOR = "pointSelectedColor";
static const char *TAG_POINT_SELECTED = "pointSelected";
static const char *TAG_POINT_VALUE_X = "pointValueX";
static const char *TAG_POINT_VALUE_Y = "pointValueY";
static const char *TAG_POINT_INDEX = "pointIndex";
PointRenderer::PointRenderer(QGraphsView *graph, bool clipPlotArea)
: QQuickItem(graph)
, m_graph(graph)
, m_polarView(qobject_cast<QPolarView *>(graph))
{
setFlag(QQuickItem::ItemHasContents);
setClip(clipPlotArea);
#if QT_CONFIG(graphs_2d_high_quality_backend)
m_shape.setParentItem(this);
m_shape.setPreferredRendererType(QQuickShape::CurveRenderer);
#endif
m_tempMarker = new QQmlComponent(qmlEngine(m_graph), this);
m_tempMarker->loadFromModule(u"QtGraphs2D.impl"_s, u"PointMarker"_s);
m_tapHandler = new QQuickTapHandler(this);
connect(m_tapHandler, &QQuickTapHandler::singleTapped,
this, &PointRenderer::onSingleTapped);
connect(m_tapHandler, &QQuickTapHandler::doubleTapped,
this, &PointRenderer::onDoubleTapped);
connect(m_tapHandler, &QQuickTapHandler::pressedChanged, this, &PointRenderer::onPressedChanged);
}
PointRenderer::~PointRenderer()
{
qDeleteAll(m_groups);
}
void PointRenderer::resetShapePathCount()
{
m_currentShapePathIndex = 0;
#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
}
#if QT_CONFIG(graphs_2d_high_performance_backend)
void PointRenderer::paintSnapshot(const PaintSnapshot &snapshot, QCanvasPainter *p) {
p->setLineJoin(QCanvasPainter::LineJoin::Round);
for (const auto &pointSnapshot : snapshot) {
p->setStrokeStyle(pointSnapshot.strokeColor);
p->setLineWidth(pointSnapshot.lineWidth);
p->setLineCap(pointSnapshot.lineCap);
p->beginPath();
p->addPath(pointSnapshot.painterPath);
p->stroke();
}
}
void PointRenderer::synchronizeData()
{
m_pointPaintSnapshot.clear();
for (const auto &group : std::as_const(m_groups)) {
if (group->painterPath.elementCount() == 0)
continue;
const auto style = getSeriesStyle(group);
qreal width = 1.0;
QCanvasPainter::LineCap capStyle = QCanvasPainter::LineCap::Round;
#if QT_CONFIG(graphs_2d_line) || QT_CONFIG(graphs_2d_area)
if (auto line = qobject_cast<QLineSeries *>(group->series)) {
width = line->width();
switch (line->capStyle()) {
case Qt::PenCapStyle::FlatCap:
capStyle = QCanvasPainter::LineCap::Butt;
break;
case Qt::PenCapStyle::RoundCap:
capStyle = QCanvasPainter::LineCap::Round;
break;
case Qt::PenCapStyle::SquareCap:
capStyle = QCanvasPainter::LineCap::Square;
break;
default:
break;
}
}
#endif
#if QT_CONFIG(graphs_2d_spline)
#if QT_CONFIG(graphs_2d_line)
else
#endif
if (auto spline = qobject_cast<QSplineSeries *>(group->series)) {
width = spline->width();
switch (spline->capStyle()) {
case Qt::PenCapStyle::FlatCap:
capStyle = QCanvasPainter::LineCap::Butt;
break;
case Qt::PenCapStyle::RoundCap:
capStyle = QCanvasPainter::LineCap::Round;
break;
case Qt::PenCapStyle::SquareCap:
capStyle = QCanvasPainter::LineCap::Square;
break;
default:
break;
}
}
#endif
m_pointPaintSnapshot.append({group->painterPath, style.color, width, capStyle});
}
}
PointRenderer::PaintSnapshot PointRenderer::paintSnapshot() const
{
return m_pointPaintSnapshot;
}
#endif
qreal PointRenderer::defaultSize(QXYSeries *series)
{
qreal size = 16.0;
if (series != nullptr) {
#if QT_CONFIG(graphs_2d_line) || QT_CONFIG(graphs_2d_area)
if (auto line = qobject_cast<QLineSeries *>(series))
size = qMax(size, line->width());
#endif
#if (QT_CONFIG(graphs_2d_line) || QT_CONFIG(graphs_2d_area)) && QT_CONFIG(graphs_2d_spline)
else
#endif
#if QT_CONFIG(graphs_2d_spline)
if (auto spline = qobject_cast<QSplineSeries *>(series))
size = qMax(size, spline->width());
#endif
}
return size;
}
void PointRenderer::calculateRenderCoordinates(AxisRenderer *axisRenderer,
QAbstractSeries *series,
qreal origX,
qreal origY,
qreal *renderX,
qreal *renderY)
{
auto &axisX = axisRenderer->getAxisX(series);
auto &axisY = axisRenderer->getAxisY(series);
qreal x = origX;
qreal y = origY;
if (axisX.isLogarithmic) {
float logBase = log(axisX.logBase);
x = log(origX) / logBase;
}
if (axisY.isLogarithmic) {
float logBase = log(axisY.logBase);
y = log(origY) / logBase;
}
if (m_polarView) {
qreal angleFrac = !qFuzzyIsNull(axisX.valueRange) ? (x - axisX.minValue) / axisX.valueRange : 0;
qreal yClamped = std::max(y, axisY.minValue);
qreal radiusFrac = !qFuzzyIsNull(axisY.valueRange) ? (yClamped - axisY.minValue) / axisY.valueRange
: 0;
qreal radius = radiusFrac * m_polarView->polarRadius();
qreal rad = qDegreesToRadians(angleFrac * 360.0);
const QPointF center = m_polarView->polarCenter();
*renderX = center.x() + qSin(rad) * radius;
*renderY = center.y() - qCos(rad) * radius;
return;
}
if (m_graph->orientation() != Qt::Vertical) {
std::swap(x, y);
y = axisY.maxValue - y;
}
auto flipX = axisX.maxValue < axisX.minValue ? -1 : 1;
auto flipY = axisY.maxValue < axisY.minValue ? -1 : 1;
*renderX = m_areaWidth * flipX * x * m_maxHorizontal - m_horizontalOffset;
*renderY = m_areaHeight - m_areaHeight * flipY * y * m_maxVertical
+ m_verticalOffset;
}
void PointRenderer::reverseRenderCoordinates(AxisRenderer *axisRenderer,
QAbstractSeries *series,
qreal renderX,
qreal renderY,
qreal *origX,
qreal *origY)
{
auto &axisX = axisRenderer->getAxisX(series);
auto &axisY = axisRenderer->getAxisY(series);
if (m_polarView) {
const QPointF center = m_polarView->polarCenter();
const qreal dx = renderX - center.x();
const qreal dy = renderY - center.y();
const qreal radius = std::hypot(dx, dy);
qreal angleDeg = qRadiansToDegrees(std::atan2(dx, -dy));
if (angleDeg < 0)
angleDeg += 360.0;
const qreal polarRadius = m_polarView->polarRadius();
qreal x = axisX.minValue + (angleDeg / 360.0) * axisX.valueRange;
qreal y = axisY.minValue
+ (polarRadius != 0 ? radius / polarRadius : 0) * axisY.valueRange;
if (axisX.isLogarithmic)
x = pow(axisX.logBase, x);
if (axisY.isLogarithmic)
y = pow(axisY.logBase, y);
*origX = x;
*origY = y;
return;
}
if (m_graph->orientation() != Qt::Vertical) {
std::swap(renderX, renderY);
renderY = m_areaHeight - renderY;
}
auto flipX = axisX.maxValue < axisX.minValue ? -1 : 1;
auto flipY = axisY.maxValue < axisY.minValue ? -1 : 1;
float x = (renderX + m_horizontalOffset) / (m_areaWidth * flipX * m_maxHorizontal);
float y = (renderY - m_areaHeight - m_verticalOffset)
/ (-1 * m_areaHeight * flipY * m_maxVertical);
if (axisX.isLogarithmic)
x = pow(axisX.logBase, x);
if (axisY.isLogarithmic)
y = pow(axisY.logBase, y);
*origX = x;
*origY = y;
}
PointRenderer::SeriesStyle PointRenderer::getSeriesStyle(PointGroup *group)
{
auto theme = m_graph->theme();
const auto &seriesColors = theme->seriesColors();
const auto &borderColors = theme->borderColors();
qsizetype index = group->colorIndex % seriesColors.size();
QColor color = group->series->color().alpha() != 0 ? group->series->color() : seriesColors.at(index);
color.setAlpha(color.alpha() * group->series->opacity());
QColor selectedColor = group->series->selectedColor().alpha() != 0
? group->series->selectedColor()
: m_graph->theme()->singleHighlightColor();
selectedColor.setAlpha(selectedColor.alpha() * group->series->opacity());
index = group->colorIndex % borderColors.size();
QColor borderColor = borderColors.at(index);
borderColor.setAlpha(borderColor.alpha() * group->series->opacity());
qreal borderWidth = theme->borderWidth();
return {
color,
selectedColor,
borderColor,
borderWidth
};
}
void PointRenderer::updatePointDelegate(
QXYSeries *series, PointGroup *group, qsizetype pointIndex, qreal x, qreal y)
{
const auto style = getSeriesStyle(group);
auto marker = group->markers[pointIndex];
auto &rect = group->rects[pointIndex];
if (marker->property(TAG_POINT_SELECTED).isValid())
marker->setProperty(TAG_POINT_SELECTED, series->isPointSelected(pointIndex));
if (marker->property(TAG_POINT_COLOR).isValid())
marker->setProperty(TAG_POINT_COLOR, style.color);
if (marker->property(TAG_POINT_BORDER_COLOR).isValid())
marker->setProperty(TAG_POINT_BORDER_COLOR, style.borderColor);
if (marker->property(TAG_POINT_BORDER_WIDTH).isValid())
marker->setProperty(TAG_POINT_BORDER_WIDTH, style.borderWidth);
if (marker->property(TAG_POINT_SELECTED_COLOR).isValid())
marker->setProperty(TAG_POINT_SELECTED_COLOR, style.selectedColor);
const auto point = series->points().at(pointIndex);
if (marker->property(TAG_POINT_VALUE_X).isValid())
marker->setProperty(TAG_POINT_VALUE_X, point.x());
if (marker->property(TAG_POINT_VALUE_Y).isValid())
marker->setProperty(TAG_POINT_VALUE_Y, point.y());
if (marker->property(TAG_POINT_INDEX).isValid())
marker->setProperty(TAG_POINT_INDEX, pointIndex);
marker->setX(x - marker->width() / 2.0);
marker->setY(y - marker->height() / 2.0);
marker->setVisible(isValidValue(x) && isValidValue(y));
rect = QRectF(x - marker->width() / 2.0,
y - marker->height() / 2.0,
marker->width(),
marker->height());
}
void PointRenderer::hidePointDelegates(QXYSeries *series)
{
auto *group = m_groups.value(series);
if (group->currentMarker) {
for (int i = 0; i < group->markers.size(); ++i) {
auto *marker = group->markers[i];
marker->setVisible(false);
}
}
group->rects.clear();
}
void PointRenderer::destroyGroupMarkers(PointGroup *group, qsizetype keepCount)
{
for (qsizetype i = keepCount; i < group->markers.size(); ++i)
group->markers.at(i)->deleteLater();
group->markers.resize(keepCount);
group->dragHandlers.resize(keepCount);
if (group == m_pressedGroup && m_pressedPointIndex >= keepCount)
forgetPressedPoint(group->series);
if (group == m_currentHoverGroup && m_currentHoverPointIndex >= keepCount) {
emit group->series->hovered(false, m_currentHoverPoint);
m_currentHoverGroup = nullptr;
m_currentHoverPointIndex = -1;
}
}
void PointRenderer::updateLegendData(QXYSeries *series, QLegendData &legendData)
{
QList<QLegendData> legendDataList = {legendData};
series->d_func()->setLegendData(legendDataList);
}
void PointRenderer::onSingleTapped(QEventPoint eventPoint, Qt::MouseButton button)
{
Q_UNUSED(button)
for (auto &&group : m_groups) {
if (!group->series->isVisible())
continue;
if (!group->series->isSelectable() && !group->series->isDraggable())
continue;
int index = 0;
for (auto &&rect : group->rects) {
if (rect.contains(eventPoint.position())) {
emit group->series->clicked(group->series->at(index).toPoint());
return;
}
index++;
}
}
}
void PointRenderer::onDoubleTapped(QEventPoint eventPoint, Qt::MouseButton button)
{
Q_UNUSED(button)
for (auto &&group : m_groups) {
if (!group->series->isVisible())
continue;
if (!group->series->isSelectable() && !group->series->isDraggable())
continue;
int index = 0;
for (auto &&rect : group->rects) {
if (rect.contains(eventPoint.position())) {
emit group->series->doubleClicked(group->series->at(index).toPoint());
return;
}
index++;
}
}
}
void PointRenderer::onPressedChanged()
{
if (m_tapHandler->isPressed()) {
for (auto &&group : m_groups) {
if (!group->series->isVisible())
continue;
if (!group->series->isSelectable() && !group->series->isDraggable())
continue;
int index = 0;
for (auto &&rect : group->rects) {
if (rect.contains(m_tapHandler->point().position())) {
m_pressedGroup = group;
m_pressedPointIndex = index;
emit group->series->pressed(m_pressedGroup->series->at(index).toPoint());
}
index++;
}
}
} else {
if (m_pressedGroup
&& m_pressedGroup->series->isSelectable()
&& m_pressedGroup->series->isVisible()) {
if (m_pressedGroup->rects[m_pressedPointIndex].contains(
m_tapHandler->point().position())) {
if (m_pressedGroup->series->isPointSelected(m_pressedPointIndex))
m_pressedGroup->series->deselectPoint(m_pressedPointIndex);
else
m_pressedGroup->series->selectPoint(m_pressedPointIndex);
m_previousDelta = QPoint(0, 0);
emit m_pressedGroup->series->released(
m_pressedGroup->series->at(m_pressedPointIndex).toPoint());
}
}
}
}
void PointRenderer::adjustPressedPointIndexForRemoval(QXYSeries *series,
qsizetype removedIndex,
qsizetype removedCount)
{
if (!m_pressedGroup || m_pressedGroup->series != series)
return;
if (m_pressedPointIndex >= removedIndex + removedCount) {
m_pressedPointIndex -= removedCount;
} else if (m_pressedPointIndex >= removedIndex) {
m_pressedGroup = nullptr;
m_pressedPointIndex = 0;
}
}
void PointRenderer::adjustPressedPointIndexForInsertion(QXYSeries *series,
qsizetype insertedIndex,
qsizetype insertedCount)
{
if (!m_pressedGroup || m_pressedGroup->series != series)
return;
if (m_pressedPointIndex >= insertedIndex)
m_pressedPointIndex += insertedCount;
}
void PointRenderer::forgetPressedPoint(QXYSeries *series)
{
if (m_pressedGroup && m_pressedGroup->series == series) {
m_pressedGroup = nullptr;
m_pressedPointIndex = 0;
}
}
#if QT_CONFIG(graphs_2d_scatter)
void PointRenderer::updateScatterSeries(QScatterSeries *series, QLegendData &legendData)
{
auto group = m_groups.value(series);
const auto style = getSeriesStyle(group);
Q_TRACE(QGraphs2DPointRendererUpdateScatterSeries_entry);
if (series->isVisible()) {
auto &&points = series->points();
group->rects.resize(points.size());
for (int i = 0; i < points.size(); ++i) {
qreal x, y;
calculateRenderCoordinates(m_graph->m_axisRenderer,
series,
points[i].x(),
points[i].y(),
&x,
&y);
y *= series->valuesMultiplier();
if (group->currentMarker) {
updatePointDelegate(series, group, i, x, y);
} else {
auto &rect = group->rects[i];
qreal size = defaultSize(series);
rect = QRectF(x - size / 2.0, y - size / 2.0, size, size);
}
}
} else {
hidePointDelegates(series);
}
Q_TRACE(QGraphs2DPointRendererUpdateScatterSeries_exit);
legendData = { style.color, style.borderColor, series->name() };
}
#endif
#if QT_CONFIG(graphs_2d_line) || QT_CONFIG(graphs_2d_area)
void PointRenderer::updateLineSeries(QLineSeries *series, QLegendData &legendData)
{
auto group = m_groups.value(series);
const auto style = getSeriesStyle(group);
#if QT_CONFIG(graphs_2d_high_quality_backend)
if (!m_graph->useCanvasPainter()) {
group->shapePath->setStrokeColor(style.color);
group->shapePath->setStrokeWidth(series->width());
group->shapePath->setFillColor(QColorConstants::Transparent);
Qt::PenCapStyle capStyle = series->capStyle();
if (capStyle == Qt::PenCapStyle::SquareCap)
group->shapePath->setCapStyle(QQuickShapePath::CapStyle::SquareCap);
else if (capStyle == Qt::PenCapStyle::FlatCap)
group->shapePath->setCapStyle(QQuickShapePath::CapStyle::FlatCap);
else if (capStyle == Qt::PenCapStyle::RoundCap)
group->shapePath->setCapStyle(QQuickShapePath::CapStyle::RoundCap);
Qt::PenJoinStyle joinStyle = series->joinStyle();
if (joinStyle == Qt::PenJoinStyle::BevelJoin)
group->shapePath->setJoinStyle(QQuickShapePath::JoinStyle::BevelJoin);
else if (joinStyle == Qt::PenJoinStyle::MiterJoin)
group->shapePath->setJoinStyle(QQuickShapePath::JoinStyle::MiterJoin);
else if (joinStyle == Qt::PenJoinStyle::RoundJoin)
group->shapePath->setJoinStyle(QQuickShapePath::JoinStyle::RoundJoin);
group->shapePath->setStrokeStyle(QQuickShapePath::StrokeStyle(series->strokeStyle()));
group->shapePath->setDashOffset(series->dashOffset());
group->shapePath->setDashPattern(series->dashPattern());
}
#endif
auto &painterPath = group->painterPath;
painterPath.clear();
QPointF previousRenderCoordinates;
Q_TRACE(QGraphs2DPointRendererUpdateLineSeries_entry);
if (series->isVisible()) {
auto &&points = series->points();
group->rects.resize(points.size());
for (int i = 0; i < points.size(); ++i) {
qreal x, y;
calculateRenderCoordinates(m_graph->m_axisRenderer,
series,
points[i].x(),
points[i].y(),
&x,
&y);
y *= series->valuesMultiplier();
if (i == 0)
painterPath.moveTo(x, y);
else {
if (!isValidValue(previousRenderCoordinates.x()) || !isValidValue(previousRenderCoordinates.y())) {
if (isValidValue(x) && isValidValue(y))
painterPath.moveTo(x, y);
} else if (isValidValue(x) && isValidValue(y)) {
switch (series->lineStyle()) {
case QLineSeries::LineStyle::StepLeft:
painterPath.lineTo(x, previousRenderCoordinates.y());
painterPath.lineTo(x, y);
break;
case QLineSeries::LineStyle::StepRight:
painterPath.lineTo(previousRenderCoordinates.x(), y);
painterPath.lineTo(x, y);
break;
case QLineSeries::LineStyle::StepCenter: {
qreal half = (x + previousRenderCoordinates.x()) / 2;
painterPath.lineTo(half, previousRenderCoordinates.y());
painterPath.lineTo(half, y);
painterPath.lineTo(x, y);
} break;
default:
if (m_polarView && i > 0) {
// A direct chord between points more than half a
// turn apart is meaningless on a polar plot; draw
// via the center instead.
auto &axisX = m_graph->m_axisRenderer->getAxisX(series);
// Only the angular distance between the two points matters,
// and axisX.minValue cancels out of the difference, so derive
// it from the x delta rather than from two absolute angles.
const qreal angleDelta = axisX.valueRange != 0
? qAbs((points[i].x() - points[i - 1].x()) / axisX.valueRange
* 360.0)
: 0;
if (angleDelta > 180.0) {
const QPointF center = m_polarView->polarCenter();
painterPath.lineTo(center.x(), center.y());
}
}
painterPath.lineTo(x, y);
break;
}
}
}
previousRenderCoordinates = {x, y};
if (group->currentMarker) {
updatePointDelegate(series, group, i, x, y);
} else {
auto &rect = group->rects[i];
qreal size = defaultSize(series);
rect = QRectF(x - size / 2.0, y - size / 2.0, size, size);
}
}
} else {
hidePointDelegates(series);
}
#if QT_CONFIG(graphs_2d_high_quality_backend)
if (!m_graph->useCanvasPainter())
group->shapePath->setPath(painterPath);
#endif
Q_TRACE(QGraphs2DPointRendererUpdateLineSeries_exit);
legendData = { style.color, style.borderColor, series->name() };
}
#endif
#if QT_CONFIG(graphs_2d_spline)
void PointRenderer::updateSplineSeries(QSplineSeries *series, QLegendData &legendData)
{
auto group = m_groups.value(series);
const auto style = getSeriesStyle(group);
#if QT_CONFIG(graphs_2d_high_quality_backend)
if (!m_graph->useCanvasPainter()) {
group->shapePath->setStrokeColor(style.color);
group->shapePath->setStrokeWidth(series->width());
group->shapePath->setFillColor(QColorConstants::Transparent);
Qt::PenCapStyle capStyle = series->capStyle();
if (capStyle == Qt::PenCapStyle::SquareCap)
group->shapePath->setCapStyle(QQuickShapePath::CapStyle::SquareCap);
else if (capStyle == Qt::PenCapStyle::FlatCap)
group->shapePath->setCapStyle(QQuickShapePath::CapStyle::FlatCap);
else if (capStyle == Qt::PenCapStyle::RoundCap)
group->shapePath->setCapStyle(QQuickShapePath::CapStyle::RoundCap);
}
#endif
auto &painterPath = group->painterPath;
painterPath.clear();
if (series->isVisible()) {
auto &&points = series->points();
group->rects.resize(points.size());
auto fittedPoints = series->getControlPoints();
Q_TRACE(QGraphs2DPointRendererUpdateSplineSeries_entry);
for (int i = 0, j = 0; i < points.size(); ++i, ++j) {
qreal x, y;
calculateRenderCoordinates(m_graph->m_axisRenderer,
series,
points[i].x(),
points[i].y(),
&x,
&y);
qreal valuesMultiplier = series->valuesMultiplier();
y *= valuesMultiplier;
if (i == 0) {
painterPath.moveTo(x, y);
} else {
qreal x1, y1, x2, y2;
calculateRenderCoordinates(m_graph->m_axisRenderer,
series,
fittedPoints[j - 1].x(),
fittedPoints[j - 1].y(),
&x1,
&y1);
calculateRenderCoordinates(m_graph->m_axisRenderer,
series,
fittedPoints[j].x(),
fittedPoints[j].y(),
&x2,
&y2);
y1 *= valuesMultiplier;
y2 *= valuesMultiplier;
painterPath.cubicTo(x1, y1, x2, y2, x, y);
++j;
}
if (group->currentMarker) {
updatePointDelegate(series, group, i, x, y);
} else {
auto &rect = group->rects[i];
qreal size = defaultSize(series);
rect = QRectF(x - size / 2.0, y - size / 2.0, size, size);
}
}
Q_TRACE(QGraphs2DPointRendererUpdateSplineSeries_exit);
} else {
hidePointDelegates(series);
}
#if QT_CONFIG(graphs_2d_high_quality_backend)
if (!m_graph->useCanvasPainter())
group->shapePath->setPath(painterPath);
#endif
legendData = { style.color, style.borderColor, series->name() };
}
#endif
void PointRenderer::handlePolish(QXYSeries *series)
{
auto theme = m_graph->theme();
if (!theme) {
qCCritical(lcCritical2D, "Theme not found");
return;
}
if (!m_graph->m_axisRenderer) {
qCCritical(lcCritical2D, "Axis renderer not found.");
return;
}
if (series->points().isEmpty()) {
auto group = m_groups.value(series);
if (group) {
#if QT_CONFIG(graphs_2d_high_quality_backend)
if (group->shapePath) {
auto &painterPath = group->painterPath;
painterPath.clear();
group->shapePath->setPath(painterPath);
}
#endif
destroyGroupMarkers(group);
}
return;
}
if (width() <= 0 || height() <= 0)
return;
m_areaWidth = width();
m_areaHeight = height();
auto &axisX = m_graph->m_axisRenderer->getAxisX(series);
auto &axisY = m_graph->m_axisRenderer->getAxisY(series);
m_maxVertical = axisY.valueRange > 0 ? 1.0 / axisY.valueRange : 100.0;
m_maxHorizontal = axisX.valueRange > 0 ? 1.0 / axisX.valueRange : 100.0;
auto vmin = axisY.minValue > axisY.maxValue ? std::abs(axisY.minValue) : axisY.minValue;
m_verticalOffset = (vmin / axisY.valueRange) * m_areaHeight;
auto hmin = axisX.minValue > axisX.maxValue ? std::abs(axisX.minValue) : axisX.minValue;
m_horizontalOffset = (hmin / axisX.valueRange) * m_areaWidth;
if (!m_groups.contains(series)) {
PointGroup *group = new PointGroup();
group->series = series;
m_groups.insert(series, group);
connect(series, &QXYSeries::pointRemoved, this, [this, series](qsizetype index) {
adjustPressedPointIndexForRemoval(series, index, 1);
});
connect(series, &QXYSeries::pointsRemoved, this,
[this, series](qsizetype index, qsizetype count) {
adjustPressedPointIndexForRemoval(series, index, count);
});
connect(series, &QXYSeries::pointAdded, this, [this, series](qsizetype index) {
adjustPressedPointIndexForInsertion(series, index, 1);
});
connect(series, &QXYSeries::pointsAdded, this,
[this, series](qsizetype start, qsizetype end) {
adjustPressedPointIndexForInsertion(series, start, end - start + 1);
});
connect(series, &QXYSeries::pointsReplaced, this, [this, series]() {
forgetPressedPoint(series);
});
#if QT_CONFIG(graphs_2d_high_quality_backend)
if (series->type() != QAbstractSeries::SeriesType::Scatter) {
group->shapePath = new QQuickShapePath(&m_shape);
group->shapePath->setAsynchronous(true);
auto data = m_shape.data();
data.append(&data, group->shapePath);
}
#endif
}
auto group = m_groups.value(series);
if (series->type() != QAbstractSeries::SeriesType::Scatter) {
#if QT_CONFIG(graphs_2d_high_quality_backend)
auto data = m_shape.data();
group->shapePath = qobject_cast<QQuickShapePath *>(data.at(&data, m_currentShapePathIndex));
#endif
m_currentShapePathIndex++;
}
qsizetype pointCount = series->points().size();
if ((series->type() == QAbstractSeries::SeriesType::Scatter) && !series->pointDelegate())
group->currentMarker = m_tempMarker;
else if (series->pointDelegate())
group->currentMarker = series->pointDelegate();
else
group->currentMarker = nullptr;
if (group->currentMarker != group->previousMarker)
destroyGroupMarkers(group);
group->previousMarker = group->currentMarker;
if (group->currentMarker) {
qsizetype markerCount = group->markers.size();
if (markerCount < pointCount) {
auto size = defaultSize();
for (qsizetype i = markerCount; i < pointCount; ++i) {
QQuickItem *item = qobject_cast<QQuickItem *>(
group->currentMarker->createWithInitialProperties({{"implicitWidth", size}, {"implicitHeight", size}},
group->currentMarker->creationContext()));
item->setParent(this);
item->setParentItem(this);
QQuickDragHandler *handler = new QQuickDragHandler(item);
handler->setEnabled(series->isDraggable());
connect(series, &QXYSeries::draggableChanged, this, [handler, series]() {
handler->setEnabled(series->isDraggable());
});
group->markers << item;
group->dragHandlers << handler;
connect(handler, &QQuickDragHandler::translationChanged, this, [&]() {
if (m_pressedGroup) {
float w = width();
float h = height();
double maxVertical
= axisY.valueRange > 0
? 1.0 / axisY.valueRange
: 100.0;
double maxHorizontal
= axisX.valueRange > 0
? 1.0 / axisX.valueRange
: 100.0;
if (m_pressedPointIndex < m_pressedGroup->dragHandlers.size()) {
QPoint currentDelta = m_pressedGroup->dragHandlers
.at(m_pressedPointIndex)
->activeTranslation()
.toPoint();
QPoint delta = currentDelta - m_previousDelta;
m_previousDelta = currentDelta;
qreal deltaX = delta.x() / w / maxHorizontal;
qreal deltaY = -delta.y() / h / maxVertical;
QPointF point = m_pressedGroup->series->at(m_pressedPointIndex)
+ QPointF(deltaX, deltaY);
m_pressedGroup->series->replace(m_pressedPointIndex, point);
}
}
});
connect(handler, &QQuickDragHandler::grabChanged, this,
[&](QPointingDevice::GrabTransition transition, QEventPoint point) {
Q_UNUSED(point)
if (transition == QPointingDevice::UngrabExclusive ||
transition == QPointingDevice::UngrabPassive) {
m_previousDelta = QPoint(0, 0);
}
});
}
} else if (markerCount > pointCount) {
destroyGroupMarkers(group, pointCount);
}
} else if (group->markers.size() > 0) {
destroyGroupMarkers(group);
}
for (auto &&marker : group->markers)
marker->setZ(group->series->zValue());
if (group->colorIndex < 0) {
group->colorIndex = m_graph->graphSeriesCount();
m_graph->setGraphSeriesCount(group->colorIndex + 1);
}
QLegendData legendData;
#if QT_CONFIG(graphs_2d_scatter)
if (auto scatter = qobject_cast<QScatterSeries *>(series))
updateScatterSeries(scatter, legendData);
#endif
#if QT_CONFIG(graphs_2d_scatter) && (QT_CONFIG(graphs_2d_line) || QT_CONFIG(graphs_2d_area))
else
#endif
#if QT_CONFIG(graphs_2d_line) || QT_CONFIG(graphs_2d_area)
if (auto line = qobject_cast<QLineSeries *>(series))
updateLineSeries(line, legendData);
#endif
#if (QT_CONFIG(graphs_2d_line) || QT_CONFIG(graphs_2d_area)) && QT_CONFIG(graphs_2d_spline)
else
#endif
#if QT_CONFIG(graphs_2d_spline)
if (auto spline = qobject_cast<QSplineSeries *>(series))
updateSplineSeries(spline, legendData);
#endif
updateLegendData(series, legendData);
}
void PointRenderer::afterPolish(QList<QAbstractSeries *> &cleanupSeries)
{
Q_TRACE_SCOPE(QGraphs2DPointRendererAfterPolish, static_cast<int>(cleanupSeries.count()));
Q_UNUSED(cleanupSeries);
#if QT_CONFIG(graphs_2d_high_quality_backend)
auto data = m_shape.data();
for (qsizetype i = m_currentShapePathIndex, count = data.count(&data); i < count; ++i) {
auto shapePath = qobject_cast<QQuickShapePath *>(data.at(&data, i));
if (shapePath) {
QPainterPath empty;
shapePath->setPath(empty);
}
}
#endif
}
void PointRenderer::updateSeries(QXYSeries *series)
{
Q_UNUSED(series);
}
void PointRenderer::seriesAboutToBeRemoved(QAbstractSeries *series)
{
if (auto *xySeries = qobject_cast<QXYSeries *>(series)) {
auto iter = m_groups.find(xySeries);
if (iter != m_groups.end()) {
auto group = (*iter);
disconnect(xySeries, &QXYSeries::pointRemoved, this, nullptr);
disconnect(xySeries, &QXYSeries::pointsRemoved, this, nullptr);
disconnect(xySeries, &QXYSeries::pointAdded, this, nullptr);
disconnect(xySeries, &QXYSeries::pointsAdded, this, nullptr);
disconnect(xySeries, &QXYSeries::pointsReplaced, this, nullptr);
destroyGroupMarkers(group);
delete *iter;
m_groups.erase(iter);
}
}
}
void PointRenderer::afterUpdate(QList<QAbstractSeries *> &cleanupSeries)
{
Q_UNUSED(cleanupSeries);
}
bool PointRenderer::handleHoverMove(QHoverEvent *event)
{
bool handled = false;
const QPointF &position = event->position();
PointGroup *hoveredGroup = nullptr;
qsizetype hoveredPointIndex = -1;
qreal closestPointDistance = -1;
for (auto &&group : m_groups) {
if (!group->series->isHoverable() || !group->series->isVisible())
continue;
qsizetype pointIndex = 0;
for (auto &&rect : group->rects) {
if (rect.contains(position.toPoint())) {
const QPointF &delta = position - rect.center();
const qreal distance = qSqrt(delta.x() * delta.x() + delta.y() * delta.y());
if (!hoveredGroup || distance < closestPointDistance) {
closestPointDistance = distance;
hoveredGroup = group;
hoveredPointIndex = pointIndex;
}
}
pointIndex++;
}
auto axisRenderer = group->series->graph()->m_axisRenderer;
auto &axisX = axisRenderer->getAxisX(group->series);
auto &axisY = axisRenderer->getAxisY(group->series);
bool isHNegative = axisX.maxValue < axisX.minValue;
bool isVNegative = axisY.maxValue < axisY.minValue;
if (group->series->type() == QAbstractSeries::SeriesType::Scatter) {
const QString &name = group->series->name();
bool hovering = false;
int index = 0;
for (auto &&rect : group->rects) {
if (rect.contains(position.toPoint())) {
if (!group->hover) {
group->hover = true;
emit group->series->hoverEnter(name, position, group->series->at(index));
}
emit group->series->hover(name, position, group->series->at(index));
hovering = true;
}
index++;
}
if (!hovering && group->hover) {
group->hover = false;
emit group->series->hoverExit(name, position);
}
} else {
const qreal x0 = event->position().x();
const qreal y0 = event->position().y();
const qreal hoverSize = defaultSize(group->series) / 2.0;
const QString &name = group->series->name();
auto &&points = group->series->points();
// True when line, false when spline
const bool isLine = group->series->type() == QAbstractSeries::SeriesType::Line;
if (points.size() >= 2) {
bool hovering = false;
auto subpath = group->painterPath.toSubpathPolygons();
if (group->painterPath.elementCount() != points.size())
m_graph->ensurePolished();
for (int i = 0; i < points.size() - 1; i++) {
qreal x1, y1, x2, y2;
if (i == 0) {
auto element1 = group->painterPath.elementAt(0);
auto element2 = group->painterPath.elementAt(isLine ? 1 : 3);
x1 = isHNegative ? element2.x : element1.x;
y1 = element1.y;
x2 = isHNegative ? element1.x : element2.x;
y2 = element2.y;
} else {
bool n = isVNegative | isHNegative;
// Each Spline (cubicTo) has 3 elements where third one is the x & y.
// So content of elements are:
// With Spline:
// [0] : MoveToElement
// [1] : 1. CurveToElement (c1x, c1y)
// [2] : 1. CurveToDataElement (c2x, c2y)
// [3] : 1. CurveToDataElement (x, y)
// [4] : 2. CurveToElement (c1x, c1y)
// ...
// With Line:
// [0] : MoveToElement
// [1] : 1. LineToElement (x, y)
// [2] : 2. LineToElement (x, y)
// ...
int element1Index = n ? (i + 1) : i;
int element2Index = n ? i : (i + 1);
element1Index = isLine ? element1Index : element1Index * 3;
element2Index = isLine ? element2Index : element2Index * 3;
auto element1 = group->painterPath.elementAt(element1Index);
auto element2 = group->painterPath.elementAt(element2Index);
x1 = element1.x;
y1 = element1.y;
x2 = element2.x;
y2 = element2.y;
}
if (isLine) {
qreal denominator = (x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1);
qreal hoverDistance = qAbs((x2 - x1) * (y1 - y0) - (x1 - x0) * (y2 - y1))
/ qSqrt(denominator);
if (hoverDistance < hoverSize) {
qreal alpha = 0;
qreal extrapolation = 0;
if (x2 - x1 >= y2 - y1) {
if (x2 - x1 != 0) {
alpha = ((x2 - x1) - (x0 - x1)) / qAbs(x2 - x1);
extrapolation = hoverSize / qAbs(x2 - x1);
}
} else {
if (y2 - y1 != 0) {
alpha = ((y2 - y1) - (y0 - y1)) / qAbs(y2 - y1);
extrapolation = hoverSize / qAbs(y2 - y1);
}
}
if (alpha >= -extrapolation && alpha <= 1.0 + extrapolation) {
bool n = isVNegative | isHNegative;
const QPointF &point1 = points[n ? i + 1 : i];
const QPointF &point2 = points[n ? i : i + 1];
QPointF point = (point2 * (1.0 - alpha)) + (point1 * alpha);
if (!group->hover) {
group->hover = true;
group->series->setHovered(true);
emit group->series->hoverEnter(name, position, point);
}
emit group->series->hover(name, position, point);
hovering = true;
handled = true;
}
}
} else { // Spline
auto segments = subpath[0];
for (auto it = segments.begin(); it != segments.end(); ++it) {
if (std::next(it, 1) == segments.end())
break;
auto it2 = std::next(it, 1);
qreal denominator = (it2->x() - it->x()) * (it2->x() - it->x())
+ (it2->y() - it->y()) * (it2->y() - it->y());
qreal hoverDistance = qAbs((it2->x() - it->x()) * (it->y() - y0)
- (it->x() - x0) * (it2->y() - it->y()))
/ qSqrt(denominator);
if (hoverDistance < hoverSize) {
qreal alpha = 0;
qreal extrapolation = 0;
if (it2->x() - it->x() >= it2->y() - it->y()) {
if (it2->x() - it->x() != 0) {
alpha = ((it2->x() - it->x()) - (x0 - it->x()))
/ qAbs(it2->x() - it->x());
extrapolation = hoverSize / qAbs(it2->x() - it->x());
}
} else {
if (it2->y() - it->y() != 0) {
alpha = ((it2->y() - it->y()) - (y0 - it->y()))
/ qAbs(it2->y() - it->y());
extrapolation = hoverSize / qAbs(it2->y() - it->y());
}
}
if (alpha >= -extrapolation && alpha <= 1.0 + extrapolation) {
qreal cx1, cy1, cx2, cy2;
reverseRenderCoordinates(axisRenderer,
group->series,
it->x(),
it->y(),
&cx1,
&cy1);
reverseRenderCoordinates(axisRenderer,
group->series,
it2->x(),
it2->y(),
&cx2,
&cy2);
const QPointF &point1 = {cx1, cy1};
const QPointF &point2 = {cx2, cy2};
QPointF point = (point2 * (1.0 - alpha)) + (point1 * alpha);
if (!group->hover) {
group->hover = true;
emit group->series->hoverEnter(name, position, point);
}
emit group->series->hover(name, position, point);
hovering = true;
handled = true;
}
}
}
}
}
if (!hovering && group->hover) {
group->hover = false;
group->series->setHovered(false);
emit group->series->hoverExit(name, position);
handled = true;
}
}
}
}
if (hoveredGroup != m_currentHoverGroup || hoveredPointIndex != m_currentHoverPointIndex) {
if (m_currentHoverGroup)
emit m_currentHoverGroup->series->hovered(false, m_currentHoverPoint);
if (hoveredGroup) {
m_currentHoverPoint = hoveredGroup->series->at(hoveredPointIndex);
emit hoveredGroup->series->hovered(true, m_currentHoverPoint);
}
m_currentHoverGroup = hoveredGroup;
m_currentHoverPointIndex = hoveredPointIndex;
handled = true;
}
return handled;
}
QPointF PointRenderer::reverseRenderCoordinates(QAbstractSeries *series, qreal x, qreal y)
{
m_areaWidth = width();
m_areaHeight = height();
auto &axisX = m_graph->m_axisRenderer->getAxisX(series);
auto &axisY = m_graph->m_axisRenderer->getAxisY(series);
m_maxVertical = axisY.valueRange > 0 ? 1.0 / axisY.valueRange : 100.0;
m_maxHorizontal = axisX.valueRange > 0 ? 1.0 / axisX.valueRange : 100.0;
auto vmin = axisY.minValue > axisY.maxValue ? std::abs(axisY.minValue) : axisY.minValue;
m_verticalOffset = (vmin / axisY.valueRange) * m_areaHeight;
auto hmin = axisX.minValue > axisX.maxValue ? std::abs(axisX.minValue) : axisX.minValue;
m_horizontalOffset = (hmin / axisX.valueRange) * m_areaWidth;
qreal x0;
qreal y0;
reverseRenderCoordinates(m_graph->m_axisRenderer, series, x, y, &x0, &y0);
return QPointF(x0, y0);
}
QT_END_NAMESPACE
#include "moc_pointrenderer_p.cpp"