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 "datetimeaxis/qdatetimeaxis.h"
#include "qabstractaxis.h"
#include "valueaxis/qvalueaxis.h"
#if QT_CONFIG(graphs_2d_bar)
#include <QtGraphs/QBarCategoryAxis>
#include <private/qbarseries_p.h>
#endif
#include <QtGraphs/QGraphsTheme>
#include <private/axisrenderer_p.h>
#include <private/qabstractaxis_p.h>
#include <private/qdatetimeaxis_p.h>
#include <private/qgraphsview_p.h>
#include <private/qvalueaxis_p.h>
#include <private/qlogvalueaxis_p.h>
#include <private/commonutils_p.h>
#include <QtQuick/private/qquickdraghandler_p.h>
#include <qfontmetrics.h>
#include <qtgraphs_tracepoints_p.h>
QT_BEGIN_NAMESPACE
Q_TRACE_PREFIX(qtgraphs,
"QT_BEGIN_NAMESPACE" \
"#include <qnamespace.h>" \
"class AxisRenderer;" \
"QT_END_NAMESPACE"
)
Q_TRACE_METADATA(qtgraphs, "ENUM { } Qt::Orientation;")
Q_TRACE_POINT(qtgraphs, QGraphs2DAxisRendererUpdateDateTimeXAxisLabels_entry);
Q_TRACE_POINT(qtgraphs, QGraphs2DAxisRendererUpdateDateTimeXAxisLabels_exit);
Q_TRACE_POINT(qtgraphs, QGraphs2DAxisRendererUpdateAxisLabelItems_entry, int labelItemCount, int neededCount);
Q_TRACE_POINT(qtgraphs, QGraphs2DAxisRendererUpdateAxisLabelItems_exit);
Q_TRACE_POINT(qtgraphs, QGraphs2DAxisRendererUpdateDateTimeYAxisLabels_entry);
Q_TRACE_POINT(qtgraphs, QGraphs2DAxisRendererUpdateDateTimeYAxisLabels_exit);
Q_TRACE_POINT(qtgraphs, QGraphs2DAxisRendererUpdateValueXAxisLabels_entry);
Q_TRACE_POINT(qtgraphs, QGraphs2DAxisRendererUpdateValueXAxisLabels_exit);
Q_TRACE_POINT(qtgraphs, QGraphs2DAxisRendererUpdateValueYAxisLabels_entry);
Q_TRACE_POINT(qtgraphs, QGraphs2DAxisRendererUpdateValueYAxisLabels_exit);
Q_TRACE_POINT(qtgraphs, QGraphs2DAxisRendererUpdateLogValueXAxisLabels_entry);
Q_TRACE_POINT(qtgraphs, QGraphs2DAxisRendererUpdateLogValueXAxisLabels_exit);
Q_TRACE_POINT(qtgraphs, QGraphs2DAxisRendererUpdateLogValueYAxisLabels_entry);
Q_TRACE_POINT(qtgraphs, QGraphs2DAxisRendererUpdateLogValueYAxisLabels_exit);
Q_TRACE_POINT(qtgraphs, QGraphs2DAxisRendererUpdateBarYAxisLabels_entry);
Q_TRACE_POINT(qtgraphs, QGraphs2DAxisRendererUpdateBarYAxisLabels_exit);
Q_TRACE_POINT(qtgraphs, QGraphs2DAxisRendererUpdateBarXAxisLabels_entry);
Q_TRACE_POINT(qtgraphs, QGraphs2DAxisRendererUpdateBarXAxisLabels_exit);
Q_TRACE_POINT(qtgraphs, QGraphs2DAxisRendererUpdateAxis_entry);
Q_TRACE_POINT(qtgraphs, QGraphs2DAxisRendererUpdateAxis_exit);
Q_TRACE_POINT(qtgraphs, QGraphs2DAxisRendererHandlePolish_entry, Qt::Orientation orientation);
Q_TRACE_POINT(qtgraphs, QGraphs2DAxisRendererHandlePolish_exit);
AxisRenderer::AxisRenderer(QQuickItem *parent)
: QQuickItem(parent)
{
m_graph = qobject_cast<QGraphsView *>(parent);
setFlag(QQuickItem::ItemHasContents);
if (m_axes1.empty())
m_axes1.emplace_back();
if (m_axes2.empty())
m_axes2.emplace_back();
}
AxisRenderer::~AxisRenderer() {}
QGraphsTheme *AxisRenderer::theme() const
{
return m_graph->m_theme;
}
void AxisRenderer::initialize()
{
if (m_initialized) {
return;
}
if (!window()) {
qCDebug(lcGraphs2D, "window doesn't exist.");
return;
}
if (m_axisGrid)
m_axisGrid->componentComplete();
if (m_axisGridShadow)
m_axisGridShadow->componentComplete();
for (auto&& ax : *m_horzAxes) {
if (ax.line)
ax.line->componentComplete();
if (ax.ticker)
ax.ticker->componentComplete();
if (ax.lineShadow)
ax.lineShadow->componentComplete();
if (ax.tickerShadow)
ax.tickerShadow->componentComplete();
}
for (auto&& ax : *m_vertAxes) {
if (ax.line)
ax.line->componentComplete();
if (ax.ticker)
ax.ticker->componentComplete();
if (ax.lineShadow)
ax.lineShadow->componentComplete();
if (ax.tickerShadow)
ax.tickerShadow->componentComplete();
}
m_initialized = true;
}
QVector2D AxisRenderer::windowToAxisCoords(QVector2D coords)
{
float x = coords.x();
float y = coords.y();
x /= width() - m_graph->m_marginLeft - m_graph->m_marginRight
- m_y1AxisWidth - m_y2AxisWidth;
y /= height() - m_graph->m_marginTop - m_graph->m_marginBottom
- m_x1AxisHeight - m_x2AxisHeight;
x *= (*m_horzAxes)[0].valueRange;
y *= (*m_vertAxes)[0].valueRange;
return QVector2D(x, y);
}
bool AxisRenderer::calculateZoom(QAbstractAxis *axis, qreal delta)
{
qreal zoom = 1.0;
std::function<void(qreal zoom)> setZoom;
switch (axis->type()) {
case QAbstractAxis::AxisType::Value: {
auto valueAxis = qobject_cast<QValueAxis *>(axis);
zoom = valueAxis->zoom();
setZoom = [valueAxis](qreal zoom) {valueAxis->setZoom(zoom); };
break;
}
case QAbstractAxis::AxisType::DateTime: {
auto dateTimeAxis = qobject_cast<QDateTimeAxis *>(axis);
zoom = dateTimeAxis->zoom();
setZoom = [dateTimeAxis](qreal zoom) {dateTimeAxis->setZoom(zoom); };
break;
}
case QAbstractAxis::AxisType::LogValue: {
auto logAxis = qobject_cast<QLogValueAxis *>(axis);
zoom = logAxis->zoom();
setZoom = [logAxis](qreal zoom) {logAxis->setZoom(zoom); };
break;
}
default: {
return false;
}
}
qreal change = 0.0;
if (delta > 0)
change = zoom * m_graph->m_zoomSensitivity;
else if (delta < 0)
change = -zoom * m_graph->m_zoomSensitivity;
zoom += change;
if (zoom < 0.01f)
zoom = 0.01;
setZoom(zoom);
return true;
}
bool AxisRenderer::zoom(qreal delta)
{
if (m_graph->zoomStyle() != QGraphsView::ZoomStyle::Center)
return false;
bool hzoomed = !zoomsHorizontalAxis() || calculateZoom((*m_horzAxes)[0].axis, delta);
bool vzoomed = calculateZoom((*m_vertAxes)[0].axis, delta);
return hzoomed && vzoomed;
}
const AxisRenderer::AxisProperties &AxisRenderer::getAxisX(QAbstractSeries *series) const
{
for (auto &&ax : *m_horzAxes) {
if (ax.axis && (ax.axis == series->axisX() || ax.axis == series->axisY()))
return ax;
}
return (*m_horzAxes)[0];
}
const AxisRenderer::AxisProperties &AxisRenderer::getAxisY(QAbstractSeries *series) const
{
for (auto &&ax : *m_vertAxes) {
if (ax.axis && (ax.axis == series->axisX() || ax.axis == series->axisY()))
return ax;
}
return (*m_vertAxes)[0];
}
bool AxisRenderer::handleWheel(QWheelEvent *event)
{
return zoom(-event->angleDelta().y());
}
void AxisRenderer::handlePinchScale(qreal delta)
{
zoom(delta - 1.0);
}
void AxisRenderer::handlePinchGrab(QPointingDevice::GrabTransition transition, QEventPoint point)
{
Q_UNUSED(transition)
Q_UNUSED(point)
}
void AxisRenderer::onTranslationChanged(QVector2D delta)
{
if (!m_dragState.dragging)
return;
m_dragState.delta += delta;
auto hax = (*m_horzAxes)[0].axis;
auto vax = (*m_vertAxes)[0].axis;
if (m_graph->zoomAreaEnabled() && m_graph->m_zoomAreaItem) {
m_graph->m_zoomAreaItem->setVisible(true);
qreal x = m_dragState.touchPositionAtPress.x();
if (m_dragState.delta.x() < 0)
x += m_dragState.delta.x();
qreal y = m_dragState.touchPositionAtPress.y();
if (m_dragState.delta.y() < 0)
y += m_dragState.delta.y();
qreal width = qAbs(m_dragState.delta.x());
qreal height = qAbs(m_dragState.delta.y());
m_graph->m_zoomAreaItem->setX(x);
m_graph->m_zoomAreaItem->setY(y);
m_graph->m_zoomAreaItem->setWidth(width);
m_graph->m_zoomAreaItem->setHeight(height);
}
if (m_graph->panStyle() != QGraphsView::PanStyle::Drag)
return;
QVector2D change(m_dragState.delta);
change = windowToAxisCoords(change);
change.setX(-change.x());
if (hax->type() == QAbstractAxis::AxisType::Value) {
auto axis = qobject_cast<QValueAxis *>(hax);
axis->setPan(m_dragState.panAtPress.x() + change.x());
} else if (hax->type() == QAbstractAxis::AxisType::DateTime) {
auto axis = qobject_cast<QDateTimeAxis *>(hax);
axis->setPan(m_dragState.panAtPress.x() + change.x());
} else if (hax->type() == QAbstractAxis::AxisType::LogValue) {
auto axis = qobject_cast<QLogValueAxis *>(hax);
axis->setPan(m_dragState.panAtPress.x() + change.x());
}
if (vax->type() == QAbstractAxis::AxisType::Value) {
auto axis = qobject_cast<QValueAxis *>(vax);
axis->setPan(m_dragState.panAtPress.y() + change.y());
} else if (vax->type() == QAbstractAxis::AxisType::DateTime) {
auto axis = qobject_cast<QDateTimeAxis *>(vax);
axis->setPan(m_dragState.panAtPress.y() + change.y());
} else if (vax->type() == QAbstractAxis::AxisType::LogValue) {
auto axis = qobject_cast<QLogValueAxis *>(vax);
axis->setPan(m_dragState.panAtPress.y() + change.y());
}
}
void AxisRenderer::onGrabChanged(QPointingDevice::GrabTransition transition, QEventPoint point)
{
const QPointF position = point.position();
auto &hax = (*m_horzAxes)[0];
auto &vax = (*m_vertAxes)[0];
auto htype = hax.axis->type();
auto vtype = vax.axis->type();
if (transition == QPointingDevice::GrabPassive
&& point.pressPosition() == point.position()) {
m_dragState.dragging = true;
m_dragState.touchPositionAtPress = QVector2D(position);
m_dragState.delta = QVector2D(0, 0);
if (htype == QAbstractAxis::AxisType::Value) {
auto axis = qobject_cast<QValueAxis *>(hax.axis);
m_dragState.panAtPress.setX(axis->pan());
} else if (htype == QAbstractAxis::AxisType::DateTime) {
auto axis = qobject_cast<QDateTimeAxis *>(hax.axis);
m_dragState.panAtPress.setX(axis->pan());
} else if (htype == QAbstractAxis::AxisType::LogValue) {
auto axis = qobject_cast<QLogValueAxis *>(hax.axis);
m_dragState.panAtPress.setX(axis->pan());
}
if (vtype == QAbstractAxis::AxisType::Value) {
auto axis = qobject_cast<QValueAxis *>(vax.axis);
m_dragState.panAtPress.setY(axis->pan());
} else if (vtype == QAbstractAxis::AxisType::DateTime) {
auto axis = qobject_cast<QDateTimeAxis *>(vax.axis);
m_dragState.panAtPress.setY(axis->pan());
} else if (vtype == QAbstractAxis::AxisType::LogValue) {
auto axis = qobject_cast<QLogValueAxis *>(vax.axis);
m_dragState.panAtPress.setY(axis->pan());
}
} else if (m_dragState.dragging && transition == QPointingDevice::UngrabExclusive) {
m_dragState.dragging = false;
if (!m_graph->zoomAreaEnabled())
return;
if (m_graph->m_zoomAreaItem)
m_graph->m_zoomAreaItem->setVisible(false);
QVector2D zoomBoxEnd(position);
auto center = (m_dragState.touchPositionAtPress + zoomBoxEnd) / 2;
auto size = (m_dragState.touchPositionAtPress - zoomBoxEnd);
size.setX(qAbs(size.x()));
size.setY(qAbs(size.y()));
if (int(size.x()) == 0 || int(size.y()) == 0)
return;
size = windowToAxisCoords(size);
center -= QVector2D(m_graph->m_marginLeft + m_y1AxisWidth, m_graph->m_marginTop);
center = windowToAxisCoords(center);
center -= QVector2D(hax.valueRange / 2.0f, vax.valueRange / 2.0f);
if (!zoomsHorizontalAxis()) {
// Polar views only zoom around the radial (vertical) axis.
} else if (htype == QAbstractAxis::AxisType::Value) {
auto axis = qobject_cast<QValueAxis *>(hax.axis);
axis->setZoom(hax.valueRangeZoomless / size.x());
axis->setPan(axis->pan() + center.x());
} else if (htype == QAbstractAxis::AxisType::DateTime){
auto axis = qobject_cast<QDateTimeAxis *>(hax.axis);
axis->setZoom(hax.valueRangeZoomless / size.x());
axis->setPan(axis->pan() + center.x());
} else if (htype == QAbstractAxis::AxisType::LogValue){
auto axis = qobject_cast<QLogValueAxis *>(hax.axis);
axis->setZoom(hax.valueRangeZoomless / size.x());
axis->setPan(axis->pan() + center.x());
}
if (vtype == QAbstractAxis::AxisType::Value) {
auto axis = qobject_cast<QValueAxis *>(vax.axis);
axis->setZoom(vax.valueRangeZoomless / size.y());
axis->setPan(axis->pan() - center.y());
} else if (vtype == QAbstractAxis::AxisType::DateTime){
auto axis = qobject_cast<QDateTimeAxis *>(vax.axis);
axis->setZoom(vax.valueRangeZoomless / size.y());
axis->setPan(axis->pan() - center.y());
} else if (vtype == QAbstractAxis::AxisType::LogValue){
auto axis = qobject_cast<QLogValueAxis *>(vax.axis);
axis->setZoom(vax.valueRangeZoomless / size.y());
axis->setPan(axis->pan() - center.y());
}
}
}
void AxisRenderer::handlePolish()
{
Q_TRACE_SCOPE(QGraphs2DAxisRendererHandlePolish, m_graph->orientation());
if (m_graph->panStyle() != QGraphsView::PanStyle::None
|| m_graph->zoomStyle() != QGraphsView::ZoomStyle::None || m_graph->zoomAreaEnabled()) {
if (!m_dragHandler)
createDragHandler();
} else if (m_dragHandler) {
deleteDragHandler();
}
updateAxis();
}
void AxisRenderer::populateAxisItems()
{
// See if series is horizontal, so axis should also switch places.
bool vertical = true;
if (m_graph->orientation() == Qt::Orientation::Horizontal)
vertical = false;
if (vertical) {
m_horzAxes = &m_axes1;
m_vertAxes = &m_axes2;
} else {
m_horzAxes = &m_axes2;
m_vertAxes = &m_axes1;
}
if (vertical != m_wasVertical) {
// Orientation has changed, so clear possible custom elements
for (auto&& ax : m_axes1) {
if (ax.title)
ax.title->deleteLater();
if (ax.line)
ax.line->deleteLater();
if (ax.ticker)
ax.ticker->deleteLater();
if (ax.lineShadow)
ax.lineShadow->deleteLater();
if (ax.tickerShadow)
ax.tickerShadow->deleteLater();
for (auto&& item : ax.textItems)
item->deleteLater();
}
for (auto&& ax : m_axes2) {
if (ax.title)
ax.title->deleteLater();
if (ax.line)
ax.line->deleteLater();
if (ax.ticker)
ax.ticker->deleteLater();
if (ax.lineShadow)
ax.lineShadow->deleteLater();
if (ax.tickerShadow)
ax.tickerShadow->deleteLater();
for (auto&& item : ax.textItems)
item->deleteLater();
}
m_axes1.clear();
m_axes2.clear();
m_wasVertical = vertical;
}
if (m_axes1.empty())
m_axes1.emplace_back();
if (m_axes2.empty())
m_axes2.emplace_back();
m_axes1[0].axis = m_graph->axisX();
m_axes2[0].axis = m_graph->axisY();
for (auto&& s : m_graph->m_seriesList) {
if (auto series = qobject_cast<QAbstractSeries *>(s)) {
if (series->axisX() && series->axisX() != m_graph->axisX()) {
bool contains = false;
for (auto&& ax : m_axes1) {
if (ax.axis == series->axisX()) {
contains = true;
break;
}
}
if (!contains) {
auto &ax = m_axes1.emplace_back();
ax.axis = series->axisX();
}
}
if (series->axisY() && series->axisY() != m_graph->axisY()) {
bool contains = false;
for (auto&& ax : m_axes2) {
if (ax.axis == series->axisY()) {
contains = true;
break;
}
}
if (!contains) {
auto &ax = m_axes2.emplace_back();
ax.axis = series->axisY();
}
}
}
}
if (!m_axisGrid) {
m_axisGrid = new AxisGrid(this);
m_axisGrid->setZ(-1);
m_axisGrid->setupShaders();
m_axisGrid->setOrigo(0);
}
if (!m_axisGridShadow) {
m_axisGridShadow = new AxisGrid(this);
m_axisGridShadow->setZ(-3);
m_axisGridShadow->setupShaders();
m_axisGridShadow->setOrigo(0);
}
for (int i = 1; i < m_axes1.size(); i++) {
auto& ax = m_axes1[i];
bool used = false;
for (auto&& s : m_graph->m_seriesList) {
if (auto series = qobject_cast<QAbstractSeries *>(s)) {
if (series->axisX() && series->axisX() == ax.axis) {
used = true;
break;
}
}
}
if (!used) {
if (ax.title)
ax.title->deleteLater();
if (ax.line)
ax.line->deleteLater();
if (ax.ticker)
ax.ticker->deleteLater();
if (ax.lineShadow)
ax.lineShadow->deleteLater();
if (ax.tickerShadow)
ax.tickerShadow->deleteLater();
for (auto&& item : ax.textItems)
item->deleteLater();
m_axes1.removeAt(i);
i--;
continue;
}
}
for (int i = 1; i < m_axes2.size(); i++) {
auto& ax = m_axes2[i];
bool used = false;
for (auto&& s : m_graph->m_seriesList) {
if (auto series = qobject_cast<QAbstractSeries *>(s)) {
if (series->axisY() && series->axisY() == ax.axis) {
used = true;
break;
}
}
}
if (!used) {
if (ax.title)
ax.title->deleteLater();
if (ax.line)
ax.line->deleteLater();
if (ax.ticker)
ax.ticker->deleteLater();
if (ax.lineShadow)
ax.lineShadow->deleteLater();
if (ax.tickerShadow)
ax.tickerShadow->deleteLater();
for (auto&& item : ax.textItems)
item->deleteLater();
m_axes2.removeAt(i);
i--;
continue;
}
}
for (int i = 0; i < m_vertAxes->size(); i++) {
auto& ax = (*m_vertAxes)[i];
if (!ax.line) {
ax.line = new AxisLine(this);
ax.line->setZ(-1);
ax.line->setupShaders();
}
if (!ax.ticker) {
ax.ticker = new AxisTicker(this);
ax.ticker->setZ(-2);
ax.ticker->setOrigo(0);
// TODO: Configurable in theme or axis?
ax.ticker->setSubTickLength(0.5);
ax.ticker->setupShaders();
}
if (!ax.lineShadow) {
ax.lineShadow = new AxisLine(this);
ax.lineShadow->setZ(-3);
ax.lineShadow->setupShaders();
}
if (!ax.tickerShadow) {
ax.tickerShadow = new AxisTicker(this);
ax.tickerShadow->setZ(-3);
ax.tickerShadow->setOrigo(0);
// TODO: Configurable in theme or axis?
ax.tickerShadow->setSubTickLength(ax.ticker->subTickLength());
ax.tickerShadow->setupShaders();
}
}
for (int i = 0; i < m_horzAxes->size(); i++) {
auto& ax = (*m_horzAxes)[i];
if (!ax.line) {
ax.line = new AxisLine(this);
ax.line->setZ(-1);
ax.line->setIsHorizontal(true);
ax.line->setupShaders();
}
if (!ax.ticker) {
ax.ticker = new AxisTicker(this);
ax.ticker->setZ(-2);
ax.ticker->setIsHorizontal(true);
ax.ticker->setOrigo(0);
// TODO: Configurable in theme or axis?
ax.ticker->setSubTickLength(0.2);
ax.ticker->setupShaders();
}
if (!ax.lineShadow) {
ax.lineShadow = new AxisLine(this);
ax.lineShadow->setZ(-3);
ax.lineShadow->setupShaders();
}
if (!ax.tickerShadow) {
ax.tickerShadow = new AxisTicker(this);
ax.tickerShadow->setZ(-3);
ax.tickerShadow->setIsHorizontal(true);
ax.tickerShadow->setOrigo(0);
// TODO: Configurable in theme or axis?
ax.tickerShadow->setSubTickLength(ax.ticker->subTickLength());
ax.tickerShadow->setupShaders();
}
}
}
void AxisRenderer::updateAxis()
{
if (!theme())
return;
const qreal axisWidth = m_y1AxisWidth + m_y2AxisWidth;
const qreal axisHeight = m_x1AxisHeight + m_x2AxisHeight;
const qreal plotHeight = height() - m_graph->m_marginTop - m_graph->m_marginBottom - axisHeight;
const qreal plotWidth = width() - m_graph->m_marginLeft - m_graph->m_marginRight - axisWidth;
const bool gridVisible = theme()->isGridVisible();
if ((*m_vertAxes)[0].axis) {
m_gridVerticalLinesVisible = gridVisible && (*m_vertAxes)[0].axis->isGridVisible();
m_gridVerticalSubLinesVisible = gridVisible && (*m_vertAxes)[0].axis->isSubGridVisible();
}
if ((*m_horzAxes)[0].axis) {
m_gridHorizontalLinesVisible = gridVisible && (*m_horzAxes)[0].axis->isGridVisible();
m_gridHorizontalSubLinesVisible = gridVisible && (*m_horzAxes)[0].axis->isSubGridVisible();
}
Q_TRACE_SCOPE(QGraphs2DAxisRendererUpdateAxis);
const qreal yMargin = m_graph->m_defaultAxisYLabelsMargin;
const qreal xMargin = m_graph->m_defaultAxisXLabelsMargin;
const qreal yTicker = m_graph->m_defaultAxisTickersWidth;
const qreal xTicker = m_graph->m_defaultAxisTickersHeight;
const QRectF &topSide = m_graph->m_x2AxisArea;
const QRectF &bottomSide = m_graph->m_x1AxisArea;
qreal topRemaining = m_x2AxisHeight;
qreal bottomMargin = 0;
qreal prevBottomGap = 0;
for (auto &ax : *m_horzAxes) {
if (!ax.axis)
continue;
if (isAxisBottomOrRight(ax)) {
bottomMargin += prevBottomGap;
const qreal sizeY = bottomSide.y() + bottomMargin;
const qreal labelSize = qMax(0.0, ax.size - xMargin - xTicker);
ax.tickersRect = QRectF(bottomSide.x(), sizeY, bottomSide.width(), xTicker);
ax.labelsRect = QRectF(bottomSide.x(), sizeY + xTicker + xMargin,
bottomSide.width(), labelSize);
bottomMargin += ax.size;
prevBottomGap = titleGap(ax);
} else {
const qreal sizeY = topSide.y() + topRemaining - ax.size;
const qreal labelSize = qMax(0.0, ax.size - xMargin - xTicker);
ax.labelsRect = QRectF(topSide.x(), sizeY, topSide.width(), labelSize);
ax.tickersRect = QRectF(topSide.x(), sizeY + labelSize + xMargin,
topSide.width(), xTicker);
topRemaining -= ax.size;
topRemaining -= titleGap(ax);
}
if (qobject_cast<QValueAxis *>(ax.axis)) {
ax.stepPx = plotWidth / (ax.valueRange / ax.valueStep);
double axisHorizontalValueDiff = ax.minLabel - ax.minValue;
ax.displacement = -(axisHorizontalValueDiff / ax.valueStep) * ax.stepPx;
updateValueXAxisLabels(ax, ax.labelsRect);
} else if (qobject_cast<QDateTimeAxis *>(ax.axis)) {
ax.stepPx = plotWidth
/ (qFuzzyIsNull(ax.valueStep) ? ax.tickCount
: (ax.valueRange / ax.valueStep));
double axisHorizontalValueDiff = fmod(ax.minValue, ax.valueStep) / ax.valueStep;
ax.displacement = axisHorizontalValueDiff * ax.stepPx;
updateDateTimeXAxisLabels(ax, ax.labelsRect);
} else if (qobject_cast<QLogValueAxis *>(ax.axis)) {
ax.stepPx = plotWidth / (ax.valueRange / ax.valueStep);
double axisHorizontalValueDiff = ax.minLabel - ax.minValue;
ax.displacement = -(axisHorizontalValueDiff / ax.valueStep) * ax.stepPx;
updateLogValueXAxisLabels(ax, ax.labelsRect);
}
#if QT_CONFIG(graphs_2d_bar)
else if (qobject_cast<QBarCategoryAxis *>(ax.axis)) {
updateBarXAxisLabels(ax, ax.labelsRect);
}
#endif
}
const QRectF &leftSide = m_graph->m_y1AxisArea;
const QRectF &rightSide = m_graph->m_y2AxisArea;
qreal leftRemaining = m_y1AxisWidth;
qreal rightMargin = 0;
qreal prevRightGap = 0;
for (auto &ax : *m_vertAxes) {
if (!ax.axis)
continue;
if (isAxisBottomOrRight(ax)) {
rightMargin += prevRightGap;
const qreal sizeX = rightSide.x() + rightMargin;
const qreal labelSize = qMax<qreal>(0, ax.size - yMargin - yTicker);
ax.tickersRect = QRectF(sizeX, rightSide.y(), yTicker, rightSide.height());
ax.labelsRect = QRectF(sizeX + yTicker + yMargin, rightSide.y(),
labelSize, rightSide.height());
rightMargin += ax.size;
prevRightGap = titleGap(ax);
} else {
const qreal sizeX = leftSide.x() + leftRemaining - ax.size;
const qreal labelSize = qMax<qreal>(0, ax.size - yMargin - yTicker);
ax.labelsRect = QRectF(sizeX, leftSide.y(), labelSize, leftSide.height());
ax.tickersRect = QRectF(sizeX + labelSize + yMargin, leftSide.y(),
yTicker, leftSide.height());
leftRemaining -= ax.size;
leftRemaining -= titleGap(ax);
}
if (qobject_cast<QValueAxis *>(ax.axis)) {
ax.stepPx = plotHeight / (ax.valueRange / ax.valueStep);
double axisVerticalValueDiff = ax.minLabel - ax.minValue;
ax.displacement = -(axisVerticalValueDiff / ax.valueStep) * ax.stepPx;
updateValueYAxisLabels(ax, ax.labelsRect);
} else if (qobject_cast<QDateTimeAxis *>(ax.axis)) {
ax.stepPx = plotHeight
/ (qFuzzyIsNull(ax.valueStep) ? ax.tickCount
: (ax.valueRange / ax.valueStep));
double axisVerticalValueDiff = fmod(ax.minValue, ax.valueStep) / ax.valueStep;
ax.displacement = axisVerticalValueDiff * ax.stepPx;
updateDateTimeYAxisLabels(ax, ax.labelsRect);
} else if (qobject_cast<QLogValueAxis *>(ax.axis)) {
ax.stepPx = plotHeight / (ax.valueRange / ax.valueStep);
double axisVerticalValueDiff = ax.minLabel - ax.minValue;
ax.displacement = -(axisVerticalValueDiff / ax.valueStep) * ax.stepPx;
updateLogValueYAxisLabels(ax, ax.labelsRect);
}
#if QT_CONFIG(graphs_2d_bar)
else if (qobject_cast<QBarCategoryAxis *>(ax.axis)) {
updateBarYAxisLabels(ax, ax.labelsRect);
}
#endif
}
updateAxisTickers();
updateAxisTickersShadow();
updateAxisGrid();
updateAxisGridShadow();
updateAxisTitles();
}
bool AxisRenderer::hasAxisTitle(const AxisProperties &ax) const
{
return ax.axis && ax.axis->isTitleVisible() && !ax.axis->titleText().isEmpty();
}
bool AxisRenderer::isAxisBottomOrRight(const AxisProperties &ax) const
{
return ax.axis->alignment() == Qt::AlignBottom || ax.axis->alignment() == Qt::AlignRight;
}
// Space reserved between a titled axis and whatever comes next (another axis, or the outer
// view margin). Grows past the default margin only when the title itself needs more room.
qreal AxisRenderer::titleGap(const AxisProperties &ax) const
{
if (!hasAxisTitle(ax))
return 0;
return qMax(m_graph->m_defaultAxisTitleMargin, ax.titleSize);
}
// How far the title extends past the outer edge of the axis' labelsRect, i.e. beyond where a
// default-sized title would end.
qreal AxisRenderer::titleOutwardExtent(const AxisProperties &ax) const
{
if (!hasAxisTitle(ax))
return 0;
const qreal margin = m_graph->m_defaultAxisTitleMargin;
return ax.titleSize <= margin ? ax.titleSize * 0.5 : ax.titleSize - margin * 0.5;
}
// Builds a printf-style spec combining decimals with the axis label format so it can be
// passed to AxisRenderer::formatValueLabel(), which itself no longer takes a decimals argument.
// A format longer than a single conversion char is a user-supplied full spec and is used as-is.
static QString decimalFormatSpec(const QString &format, int decimals, char defaultConversion)
{
if (format.length() <= 1) {
const QChar conversion = format.isEmpty() ? QLatin1Char(defaultConversion)
: format.front();
return QStringLiteral("%.%1%2").arg(decimals).arg(conversion);
}
return format;
}
void AxisRenderer::updateAxisMeasurements()
{
populateAxisItems();
if (!theme())
return;
const QFontMetricsF yFontMetrics(theme()->axisYLabelFont());
for (auto &ax : *m_vertAxes) {
ax.labelSize = 0;
ax.titleSize = hasAxisTitle(ax) ? QFontMetricsF(ax.axis->titleFont()).height() : 0;
}
for (auto &ax : *m_vertAxes) {
if (auto vaxis = qobject_cast<QValueAxis *>(ax.axis)) {
double step = vaxis->tickInterval();
qreal diff = vaxis->max() - vaxis->min();
qreal center = diff / 2.0f + vaxis->min() + vaxis->pan();
diff /= vaxis->zoom();
ax.maxValue = center + diff / 2.0f;
ax.minValue = center - diff / 2.0f;
ax.valueRange = ax.maxValue - ax.minValue;
ax.valueRangeZoomless = vaxis->max() - vaxis->min();
// If step is not manually defined (or it is invalid), calculate autostep
if (step <= 0)
step = getValueStepsFromRange(vaxis->max() - vaxis->min());
// Get smallest tick label value
double minLabel = vaxis->tickAnchor();
while (minLabel < ax.minValue)
minLabel += step;
while (minLabel >= (ax.minValue + step))
minLabel -= step;
ax.minLabel = minLabel;
ax.valueStep = step;
int axisVerticalSubTickCount = vaxis->subTickCount();
ax.subGridScale = axisVerticalSubTickCount > 0 ? 1.0 / (axisVerticalSubTickCount + 1)
: 1.0;
int decimals = vaxis->labelDecimals();
if (decimals < 0)
decimals = getValueDecimalsFromRange(ax.valueRange);
const QString format = vaxis->labelFormat();
const QString spec = decimalFormatSpec(format, decimals, 'f');
ax.labelSize = qMax(ax.labelSize,
yFontMetrics.horizontalAdvance(
formatValueLabel(vaxis->min(), spec, QLatin1StringView("f"))));
ax.labelSize = qMax(ax.labelSize,
yFontMetrics.horizontalAdvance(
formatValueLabel(vaxis->max(), spec, QLatin1StringView("f"))));
} else if (auto vaxis = qobject_cast<QDateTimeAxis *>(ax.axis)) {
// Todo: make constant for all axis, or clamp in class? (QTBUG-124736)
const double MAX_DIVS = 100.0;
double tickCount = std::clamp<double>(vaxis->tickCount(), 0.0, MAX_DIVS);
qreal diff = vaxis->max().toMSecsSinceEpoch() - vaxis->min().toMSecsSinceEpoch();
qreal center = diff / 2.0f + vaxis->min().toMSecsSinceEpoch() + vaxis->pan();
diff /= vaxis->zoom();
ax.maxValue = center + diff / 2.0f;
ax.minValue = center - diff / 2.0f;
ax.valueRange = std::abs(ax.maxValue - ax.minValue);
ax.valueRangeZoomless = vaxis->max().toMSecsSinceEpoch()
- vaxis->min().toMSecsSinceEpoch();
// in ms
double segment;
if (tickCount <= 0) {
segment = getValueStepsFromRange(ax.valueRange);
tickCount = ax.valueRange / segment;
} else {
segment = ax.valueRange / tickCount;
}
ax.minLabel = std::clamp(tickCount, 1.0, MAX_DIVS);
ax.valueStep = segment;
int axisVerticalSubTickCount = vaxis->subTickCount();
ax.subGridScale = axisVerticalSubTickCount > 0 ? 1.0 / (axisVerticalSubTickCount + 1)
: 1.0;
ax.tickCount = tickCount;
const QString format = vaxis->labelFormat();
ax.labelSize = qMax(ax.labelSize,
yFontMetrics.horizontalAdvance(
vaxis->min().toString(format)));
ax.labelSize = qMax(ax.labelSize,
yFontMetrics.horizontalAdvance(
vaxis->max().toString(format)));
} else if (auto vaxis = qobject_cast<QLogValueAxis *>(ax.axis)) {
ax.isLogarithmic = true;
ax.logBase = vaxis->base();
qreal logBase = log(vaxis->base());
qreal logMin = log(vaxis->min()) / logBase;
qreal logMax = log(vaxis->max()) / logBase;
qreal diff = logMax - logMin;
qreal center = diff / 2.0f + logMin + vaxis->pan();
diff /= vaxis->zoom();
ax.maxValue = center + diff / 2.0f;
ax.minValue = center - diff / 2.0f;
//use log scale to create value range
ax.valueRange = ax.maxValue - ax.minValue;
ax.valueRangeZoomless = logMax - logMin;
// Get smallest tick label value
ax.minLabel = qRound(ax.minValue);
ax.valueStep = 1;
int axisVerticalSubTickCount = vaxis->subTickCount();
if (axisVerticalSubTickCount == -1)
axisVerticalSubTickCount = int(qRound(vaxis->base()));
ax.subGridScale = axisVerticalSubTickCount > 0 ? 1.0 / (axisVerticalSubTickCount + 1)
: 1.0;
const QString format = vaxis->labelFormat();
int precision = vaxis->labelPrecision();
const QString spec = decimalFormatSpec(format, precision, 'g');
ax.labelSize = qMax(ax.labelSize,
yFontMetrics.horizontalAdvance(
formatValueLabel(vaxis->min(), spec, QLatin1StringView("g"))));
ax.labelSize = qMax(ax.labelSize,
yFontMetrics.horizontalAdvance(
formatValueLabel(vaxis->max(), spec, QLatin1StringView("g"))));
}
#if QT_CONFIG(graphs_2d_bar)
else if (auto vaxis = qobject_cast<QBarCategoryAxis *>(ax.axis)) {
ax.maxValue = vaxis->categories().size();
ax.minValue = 0;
ax.valueRange = ax.maxValue - ax.minValue;
for (const auto &category : vaxis->categories()) {
ax.labelSize = qMax(ax.labelSize,
yFontMetrics.horizontalAdvance(category));
}
}
#endif
}
for (auto &ax : *m_horzAxes)
ax.titleSize = hasAxisTitle(ax) ? QFontMetricsF(ax.axis->titleFont()).height() : 0;
for (auto&& ax : *m_horzAxes) {
if (auto haxis = qobject_cast<QValueAxis *>(ax.axis)) {
double step = haxis->tickInterval();
qreal diff = haxis->max() - haxis->min();
qreal center = diff / 2.0f + haxis->min() + haxis->pan();
diff /= haxis->zoom();
ax.maxValue = center + diff / 2.0f;
ax.minValue = center - diff / 2.0f;
ax.valueRange = ax.maxValue - ax.minValue;
ax.valueRangeZoomless = haxis->max() - haxis->min();
// If step is not manually defined (or it is invalid), calculate autostep
if (step <= 0)
step = getValueStepsFromRange(haxis->max() - haxis->min());
// Get smallest tick label value
double minLabel = haxis->tickAnchor();
while (minLabel < ax.minValue)
minLabel += step;
while (minLabel >= (ax.minValue + step))
minLabel -= step;
ax.minLabel = minLabel;
ax.valueStep = step;
int axisHorizontalSubTickCount = haxis->subTickCount();
ax.subGridScale = axisHorizontalSubTickCount > 0
? 1.0 / (axisHorizontalSubTickCount + 1)
: 1.0;
} else if (auto haxis = qobject_cast<QDateTimeAxis *>(ax.axis)) {
const double MAX_DIVS = 100.0;
double tickCount = std::clamp<double>(haxis->tickCount(), 0.0, MAX_DIVS);
double diff = haxis->max().toMSecsSinceEpoch() - haxis->min().toMSecsSinceEpoch();
double center = diff / 2.0f + haxis->min().toMSecsSinceEpoch()
+ haxis->pan();
diff /= haxis->zoom();
ax.maxValue = center + diff / 2.0f;
ax.minValue = center - diff / 2.0f;
ax.valueRange = std::abs(ax.maxValue - ax.minValue);
ax.valueRangeZoomless = haxis->max().toMSecsSinceEpoch()
- haxis->min().toMSecsSinceEpoch();
// in ms
double segment;
if (tickCount <= 0) {
segment = getValueStepsFromRange(ax.valueRange);
tickCount = ax.valueRange / segment;
} else {
segment = ax.valueRange / tickCount;
}
ax.minLabel = std::clamp(tickCount, 1.0, MAX_DIVS);
ax.valueStep = segment;
int axisHorizontalSubTickCount = haxis->subTickCount();
ax.subGridScale = axisHorizontalSubTickCount > 0
? 1.0 / (axisHorizontalSubTickCount + 1)
: 1.0;
ax.tickCount = tickCount;
} else if (auto haxis = qobject_cast<QLogValueAxis *>(ax.axis)) {
ax.isLogarithmic = true;
ax.logBase = haxis->base();
qreal logBase = log(haxis->base());
qreal logMin = log(haxis->min()) / logBase;
qreal logMax = log(haxis->max()) / logBase;
qreal diff = logMax - logMin;
qreal center = diff / 2.0f + logMin + haxis->pan();
diff /= haxis->zoom();
ax.maxValue = center + diff / 2.0f;
ax.minValue = center - diff / 2.0f;
//use log scale to create value range
ax.valueRange = ax.maxValue - ax.minValue;
ax.valueRangeZoomless = logMax - logMin;
ax.minLabel = qRound(ax.minValue);
ax.valueStep = 1;
int axisHorizontalSubTickCount = haxis->subTickCount();
if (axisHorizontalSubTickCount == -1)
axisHorizontalSubTickCount = int(qRound(haxis->base()));
ax.subGridScale = axisHorizontalSubTickCount > 0 ? 1.0 / (axisHorizontalSubTickCount + 1)
: 1.0;
}
#if QT_CONFIG(graphs_2d_bar)
else if (auto haxis = qobject_cast<QBarCategoryAxis *>(ax.axis)) {
ax.maxValue = haxis->categories().size();
ax.minValue = 0;
ax.valueRange = ax.maxValue - ax.minValue;
}
#endif
}
// Add some arbitrary margin so that labels don't touch the title
for (auto &ax : *m_vertAxes) {
if (ax.labelSize > 0)
ax.labelSize += 8;
}
// Calculate space needed for each axis
const bool isDynamic = m_graph->dynamicLabelMargins();
const qreal yLabelDefault = m_graph->m_defaultAxisLabelsWidth;
const qreal xLabelDefault = m_graph->m_defaultAxisLabelsHeight;
const qreal yMargin = m_graph->m_defaultAxisYLabelsMargin;
const qreal xMargin = m_graph->m_defaultAxisXLabelsMargin;
const qreal yTicker = m_graph->m_defaultAxisTickersWidth;
const qreal xTicker = m_graph->m_defaultAxisTickersHeight;
m_y1AxisWidth = 0;
m_y2AxisWidth = 0;
m_x1AxisHeight = 0;
m_x2AxisHeight = 0;
qreal leftGap = 0;
qreal rightGap = 0;
qreal topGap = 0;
qreal bottomGap = 0;
// Outward extent of the outermost titled axis on each side, updated on every iteration so
// that after the loop it reflects the actual outermost axis (0 if that axis has no title).
qreal leftExtent = 0;
qreal rightExtent = 0;
qreal topExtent = 0;
qreal bottomExtent = 0;
for (auto &ax : *m_vertAxes) {
if (!ax.axis || !ax.axis->isVisible()) {
ax.size = 0;
continue;
}
ax.size = yMargin + yTicker;
if (isDynamic)
ax.size += qMax(ax.labelSize, yLabelDefault);
else
ax.size += yLabelDefault;
if (isAxisBottomOrRight(ax)) {
m_y2AxisWidth += rightGap;
m_y2AxisWidth += ax.size;
rightGap = titleGap(ax);
rightExtent = titleOutwardExtent(ax);
} else {
m_y1AxisWidth += leftGap;
m_y1AxisWidth += ax.size;
leftGap = titleGap(ax);
leftExtent = titleOutwardExtent(ax);
}
}
m_y2AxisWidth += qMax(0.0, rightExtent - m_graph->m_marginRight);
m_y1AxisWidth += qMax(0.0, leftExtent - m_graph->m_marginLeft);
for (auto &ax : *m_horzAxes) {
if (!ax.axis || !ax.axis->isVisible()) {
ax.size = 0;
continue;
}
ax.size = xMargin + xTicker;
if (isDynamic)
ax.size += qMax(ax.labelSize, xLabelDefault);
else
ax.size += xLabelDefault;
if (isAxisBottomOrRight(ax)) {
m_x1AxisHeight += bottomGap;
m_x1AxisHeight += ax.size;
bottomGap = titleGap(ax);
bottomExtent = titleOutwardExtent(ax);
} else {
m_x2AxisHeight += topGap;
m_x2AxisHeight += ax.size;
topGap = titleGap(ax);
topExtent = titleOutwardExtent(ax);
}
}
m_x1AxisHeight += qMax(0.0, bottomExtent - m_graph->m_marginBottom);
m_x2AxisHeight += qMax(0.0, topExtent - m_graph->m_marginTop);
}
void AxisRenderer::updateAxisTickers()
{
for (auto&& ax : *m_vertAxes) {
if (ax.axis) {
QRectF yAxisRect = ax.tickersRect;
// Note: Fix before enabling, see QTBUG-121207 and QTBUG-121211
//if (theme()->themeDirty()) {
if (ax.axis->subColor().isValid())
ax.ticker->setSubTickColor(ax.axis->subColor());
else
ax.ticker->setSubTickColor(theme()->axisY().subColor());
if (ax.axis->color().isValid())
ax.ticker->setTickColor(ax.axis->color());
else
ax.ticker->setTickColor(theme()->axisY().mainColor());
ax.ticker->setTickLineWidth(theme()->axisY().mainWidth());
ax.ticker->setSubTickLineWidth(theme()->axisY().subWidth());
ax.ticker->setSmoothing(m_graph->axisYSmoothing());
//}
float topPadding = m_axisGrid->gridLineWidth() * 0.5;
float bottomPadding = topPadding;
// TODO Only when changed
ax.ticker->setDisplacement(ax.displacement);
QRectF &rect = yAxisRect;
ax.ticker->setX(rect.x());
ax.ticker->setY(rect.y());
ax.ticker->setWidth(rect.width());
ax.ticker->setHeight(rect.height());
ax.ticker->setFlipped(ax.axis->alignment() == Qt::AlignRight || ax.axis->alignment() == Qt::AlignBottom);
ax.ticker->setSpacing((ax.ticker->height() - topPadding - bottomPadding)
/ (ax.valueRange / ax.valueStep));
ax.ticker->setSubTicksVisible(!qFuzzyCompare(ax.subGridScale, 1.0));
ax.ticker->setSubTickScale(ax.subGridScale);
ax.ticker->setLogarithmic(ax.isLogarithmic);
ax.ticker->setBase(ax.logBase);
ax.ticker->setVisible(ax.axis->isVisible());
// Axis line
if (ax.axis->color().isValid())
ax.line->setColor(ax.axis->color());
else
ax.line->setColor(theme()->axisY().mainColor());
ax.line->setLineWidth(theme()->axisY().mainWidth());
ax.line->setSmoothing(m_graph->axisYSmoothing());
float xMovement = 0.5 * (ax.line->lineWidth() + ax.line->smoothing());
if (ax.axis->alignment() == Qt::AlignRight || ax.axis->alignment() == Qt::AlignBottom)
ax.line->setX(ax.ticker->x() - xMovement);
else
ax.line->setX(ax.ticker->x() + ax.ticker->width() - xMovement);
ax.line->setY(ax.ticker->y());
ax.line->setWidth(ax.line->lineWidth() + ax.line->smoothing());
ax.line->setHeight(ax.ticker->height());
ax.line->setVisible(ax.axis->isLineVisible());
} else {
// Hide all parts of vertical axis
ax.ticker->setVisible(false);
ax.line->setVisible(false);
for (auto &textItem : ax.textItems)
textItem->setVisible(false);
}
}
for (auto&& ax : *m_horzAxes) {
if (ax.axis) {
QRectF xAxisRect = ax.tickersRect;
//if (theme()->themeDirty()) {
if (ax.axis->subColor().isValid())
ax.ticker->setSubTickColor(ax.axis->subColor());
else
ax.ticker->setSubTickColor(theme()->axisX().subColor());
if (ax.axis->color().isValid())
ax.ticker->setTickColor(ax.axis->color());
else
ax.ticker->setTickColor(theme()->axisX().mainColor());
ax.ticker->setTickLineWidth(theme()->axisX().mainWidth());
ax.ticker->setSubTickLineWidth(theme()->axisX().subWidth());
ax.ticker->setSmoothing(m_graph->axisXSmoothing());
//}
float leftPadding = m_axisGrid->gridLineWidth() * 0.5;
float rightPadding = leftPadding;
// TODO Only when changed
ax.ticker->setDisplacement(ax.displacement);
QRectF &rect = xAxisRect;
ax.ticker->setX(rect.x());
ax.ticker->setY(rect.y());
ax.ticker->setWidth(rect.width());
ax.ticker->setHeight(rect.height());
ax.ticker->setFlipped(ax.axis->alignment() == Qt::AlignTop || ax.axis->alignment() == Qt::AlignLeft);
ax.ticker->setSpacing((ax.ticker->width() - leftPadding - rightPadding)
/ (ax.valueRange / ax.valueStep));
ax.ticker->setSubTicksVisible(!qFuzzyCompare(ax.subGridScale, 1.0));
ax.ticker->setSubTickScale(ax.subGridScale);
ax.ticker->setLogarithmic(ax.isLogarithmic);
ax.ticker->setBase(ax.logBase);
ax.ticker->setVisible(ax.axis->isVisible());
// Axis line
if (ax.axis->color().isValid())
ax.line->setColor(ax.axis->color());
else
ax.line->setColor(theme()->axisX().mainColor());
ax.line->setLineWidth(theme()->axisX().mainWidth());
ax.line->setSmoothing(m_graph->axisXSmoothing());
ax.line->setX(ax.ticker->x());
float yMovement = 0.5 * (ax.line->lineWidth() + ax.line->smoothing());
if (ax.axis->alignment() == Qt::AlignTop || ax.axis->alignment() == Qt::AlignLeft)
ax.line->setY(ax.ticker->y() + ax.ticker->height() - yMovement);
else
ax.line->setY(ax.ticker->y() - yMovement);
ax.line->setWidth(ax.ticker->width());
ax.line->setHeight(ax.line->lineWidth() + ax.line->smoothing());
ax.line->setVisible(ax.axis->isLineVisible());
} else {
// Hide all parts of horizontal axis
ax.ticker->setVisible(false);
ax.line->setVisible(false);
for (auto &textItem : ax.textItems)
textItem->setVisible(false);
}
}
}
void AxisRenderer::updateAxisTickersShadow()
{
for (auto&& ax : *m_vertAxes) {
if (ax.axis && m_graph->isShadowVisible()) {
ax.tickerShadow->setSubTickColor(m_graph->shadowColor());
ax.tickerShadow->setTickColor(m_graph->shadowColor());
ax.tickerShadow->setSubTickLineWidth(ax.ticker->subTickLineWidth()
+ m_graph->shadowBarWidth());
ax.tickerShadow->setTickLineWidth(ax.ticker->tickLineWidth()
+ m_graph->shadowBarWidth());
ax.tickerShadow->setSmoothing(ax.ticker->smoothing() + m_graph->shadowSmoothing());
// TODO Only when changed
ax.tickerShadow->setDisplacement(ax.ticker->displacement());
ax.tickerShadow->setX(ax.ticker->x() + m_graph->shadowXOffset());
ax.tickerShadow->setY(ax.ticker->y() + m_graph->shadowYOffset()
+ m_graph->shadowBarWidth() * 0.5);
ax.tickerShadow->setWidth(ax.ticker->width());
ax.tickerShadow->setHeight(ax.ticker->height());
ax.tickerShadow->setFlipped(ax.ticker->isFlipped());
ax.tickerShadow->setSpacing(ax.ticker->spacing());
ax.tickerShadow->setSubTicksVisible(ax.ticker->subTicksVisible());
ax.tickerShadow->setSubTickScale(ax.ticker->subTickScale());
ax.tickerShadow->setLogarithmic(ax.ticker->isLogarithmic());
ax.tickerShadow->setBase(ax.ticker->base());
ax.tickerShadow->setVisible(ax.ticker->isVisible());
// Axis line
ax.lineShadow->setColor(m_graph->shadowColor());
ax.lineShadow->setLineWidth(ax.line->lineWidth() + m_graph->shadowBarWidth());
ax.lineShadow->setSmoothing(ax.line->smoothing() + m_graph->shadowSmoothing());
ax.lineShadow->setX(ax.line->x() + m_graph->shadowXOffset());
ax.lineShadow->setY(ax.line->y() + m_graph->shadowYOffset()
+ m_graph->shadowBarWidth() * 0.5);
ax.lineShadow->setWidth(ax.line->width());
ax.lineShadow->setHeight(ax.line->height());
ax.lineShadow->setVisible(ax.line->isVisible());
} else {
// Hide all parts of vertical axis
ax.tickerShadow->setVisible(false);
ax.lineShadow->setVisible(false);
}
}
for (auto&& ax : *m_horzAxes) {
if (ax.axis && m_graph->isShadowVisible()) {
ax.tickerShadow->setSubTickColor(m_graph->shadowColor());
ax.tickerShadow->setTickColor(m_graph->shadowColor());
ax.tickerShadow->setSubTickLineWidth(ax.ticker->subTickLineWidth()
+ m_graph->shadowBarWidth());
ax.tickerShadow->setTickLineWidth(ax.ticker->tickLineWidth()
+ m_graph->shadowBarWidth());
ax.tickerShadow->setSmoothing(ax.ticker->smoothing() + m_graph->shadowSmoothing());
// TODO Only when changed
ax.tickerShadow->setDisplacement(ax.ticker->displacement());
ax.tickerShadow->setX(ax.ticker->x() + m_graph->shadowXOffset()
- m_graph->shadowBarWidth() * 0.5);
ax.tickerShadow->setY(ax.ticker->y() + m_graph->shadowYOffset());
ax.tickerShadow->setWidth(ax.ticker->width());
ax.tickerShadow->setHeight(ax.ticker->height());
ax.tickerShadow->setFlipped(ax.ticker->isFlipped());
ax.tickerShadow->setSpacing(ax.ticker->spacing());
ax.tickerShadow->setSubTicksVisible(ax.ticker->subTicksVisible());
ax.tickerShadow->setSubTickScale(ax.ticker->subTickScale());
ax.tickerShadow->setVisible(ax.ticker->isVisible());
// Axis line
ax.lineShadow->setColor(m_graph->shadowColor());
ax.lineShadow->setLineWidth(ax.line->width() + m_graph->shadowBarWidth());
ax.lineShadow->setSmoothing(ax.line->smoothing() + m_graph->shadowSmoothing());
ax.lineShadow->setX(ax.line->x() + m_graph->shadowXOffset()
- m_graph->shadowBarWidth() * 0.5);
ax.lineShadow->setY(ax.line->y() + m_graph->shadowYOffset());
ax.lineShadow->setWidth(ax.line->width());
ax.lineShadow->setHeight(ax.line->height());
ax.lineShadow->setVisible(ax.line->isVisible());
} else {
// Hide all parts of horizontal axis
ax.tickerShadow->setVisible(false);
ax.lineShadow->setVisible(false);
}
}
}
void AxisRenderer::updateAxisGrid()
{
auto &hax = (*m_horzAxes)[0];
auto &vax = (*m_vertAxes)[0];
m_axisGrid->setGridColor(theme()->grid().mainColor());
m_axisGrid->setSubGridColor(theme()->grid().subColor());
m_axisGrid->setSubGridLineWidth(theme()->grid().subWidth());
m_axisGrid->setGridLineWidth(theme()->grid().mainWidth());
const double minimumSmoothing = 0.05;
m_axisGrid->setSmoothing(m_graph->gridSmoothing() + minimumSmoothing);
if (theme()->isPlotAreaBackgroundVisible())
m_axisGrid->setPlotAreaBackgroundColor(theme()->plotAreaBackgroundColor());
else
m_axisGrid->setPlotAreaBackgroundColor(QColorConstants::Transparent);
float topPadding = m_axisGrid->gridLineWidth() * 0.5;
float bottomPadding = topPadding;
float leftPadding = topPadding;
float rightPadding = topPadding;
// TODO Only when changed
m_axisGrid->setGridMovement(QPointF(hax.displacement, vax.displacement));
QRectF rect = m_graph->m_plotArea;
m_axisGrid->setX(rect.x());
m_axisGrid->setY(rect.y());
m_axisGrid->setWidth(rect.width());
m_axisGrid->setHeight(rect.height());
m_axisGrid->setGridWidth((m_axisGrid->width() - leftPadding - rightPadding)
/ (hax.valueRange / hax.valueStep));
m_axisGrid->setGridHeight((m_axisGrid->height() - topPadding - bottomPadding)
/ (vax.valueRange / vax.valueStep));
m_axisGrid->setGridVisibility(QVector4D(m_gridHorizontalLinesVisible,
m_gridVerticalLinesVisible,
m_gridHorizontalSubLinesVisible,
m_gridVerticalSubLinesVisible));
m_axisGrid->setVerticalSubGridScale(vax.subGridScale);
m_axisGrid->setHorizontalSubGridScale(hax.subGridScale);
m_axisGrid->setVerticalLogarithmic(vax.isLogarithmic);
m_axisGrid->setHorizontalLogarithmic(hax.isLogarithmic);
m_axisGrid->setVerticalBase(vax.logBase);
m_axisGrid->setHorizontalBase(hax.logBase);
}
void AxisRenderer::updateAxisGridShadow()
{
if (m_graph->isShadowVisible()) {
m_axisGridShadow->setGridColor(m_graph->shadowColor());
m_axisGridShadow->setSubGridColor(m_graph->shadowColor());
m_axisGridShadow->setSubGridLineWidth(m_axisGrid->subGridLineWidth() + m_graph->shadowBarWidth());
m_axisGridShadow->setGridLineWidth(m_axisGrid->gridLineWidth() + m_graph->shadowBarWidth());
m_axisGridShadow->setSmoothing(m_axisGrid->smoothing() + m_graph->shadowSmoothing());
// TODO Only when changed
m_axisGridShadow->setGridMovement(m_axisGrid->gridMovement());
m_axisGridShadow->setX(m_axisGrid->x() + m_graph->shadowXOffset() - m_graph->shadowBarWidth() * 0.5);
m_axisGridShadow->setY(m_axisGrid->y() + m_graph->shadowYOffset() + m_graph->shadowBarWidth() * 0.5);
m_axisGridShadow->setWidth(m_axisGrid->width());
m_axisGridShadow->setHeight(m_axisGrid->height());
m_axisGridShadow->setGridWidth(m_axisGrid->gridWidth());
m_axisGridShadow->setGridHeight(m_axisGrid->gridHeight());
m_axisGridShadow->setGridVisibility(m_axisGrid->gridVisibility());
m_axisGridShadow->setVerticalSubGridScale(m_axisGrid->verticalSubGridScale());
m_axisGridShadow->setHorizontalSubGridScale(m_axisGrid->horizontalSubGridScale());
m_axisGridShadow->setVisible(true);
m_axisGridShadow->setVerticalLogarithmic(m_axisGrid->isVerticalLogarithmic());
m_axisGridShadow->setHorizontalLogarithmic(m_axisGrid->isHorizontalLogarithmic());
m_axisGridShadow->setVerticalBase(m_axisGrid->verticalBase());
m_axisGridShadow->setHorizontalBase(m_axisGrid->horizontalBase());
} else {
m_axisGridShadow->setVisible(false);
}
}
void AxisRenderer::updateAxisTitles()
{
for (auto &&ax : *m_horzAxes) {
if (!ax.title)
ax.title = new QQuickText(this);
if (ax.axis && ax.axis->isTitleVisible()) {
ax.title->setVAlign(QQuickText::AlignVCenter);
ax.title->setHAlign(QQuickText::AlignHCenter);
ax.title->setText(ax.axis->titleText());
if (ax.axis->titleColor().isValid())
ax.title->setColor(ax.axis->titleColor());
else
ax.title->setColor(theme()->labelTextColor());
ax.title->setFont(ax.axis->titleFont());
// setFont()/setText() above must run before width()/height() are read below, so
// the position is computed from the title's up-to-date size, not last frame's.
const QRectF &xAxisRect = ax.labelsRect;
const qreal offset = qMax(0.0, ax.title->height() - m_graph->m_defaultAxisTitleMargin)
* 0.5;
if (ax.axis->alignment() == Qt::AlignTop || ax.axis->alignment() == Qt::AlignLeft) {
ax.title->setY(xAxisRect.y() - ax.title->height() * 0.5 - offset);
}
else {
ax.title->setY(xAxisRect.y() + xAxisRect.height() - ax.title->height() * 0.5
+ offset);
}
ax.title->setX((2 * xAxisRect.x() - ax.title->width() + xAxisRect.width()) * 0.5);
ax.title->setVisible(true);
} else {
ax.title->setVisible(false);
}
}
for (auto &&ax : *m_vertAxes) {
if (!ax.title)
ax.title = new QQuickText(this);
if (ax.axis && ax.axis->isTitleVisible()) {
ax.title->setVAlign(QQuickText::AlignVCenter);
ax.title->setHAlign(QQuickText::AlignHCenter);
ax.title->setText(ax.axis->titleText());
if (ax.axis->titleColor().isValid())
ax.title->setColor(ax.axis->titleColor());
else
ax.title->setColor(theme()->labelTextColor());
ax.title->setFont(ax.axis->titleFont());
// setFont()/setText() above must run before width()/height() are read below, so
// the position is computed from the title's up-to-date size, not last frame's.
const QRectF &yAxisRect = ax.labelsRect;
// The title is rotated -90 degrees around its center, so its footprint along X is
// its (pre-rotation) height, not its width.
const qreal offset = qMax(0.0, ax.title->height() - m_graph->m_defaultAxisTitleMargin)
* 0.5;
if (ax.axis->alignment() == Qt::AlignRight || ax.axis->alignment() == Qt::AlignBottom)
ax.title->setX(yAxisRect.x() + yAxisRect.width() - ax.title->width() * 0.5 + offset);
else
ax.title->setX(yAxisRect.x() - ax.title->width() * 0.5 - offset);
ax.title->setY((2 * yAxisRect.y() - ax.title->height() + yAxisRect.height()) * 0.5);
ax.title->setRotation(-90);
ax.title->setVisible(true);
} else {
ax.title->setVisible(false);
}
}
}
void AxisRenderer::updateAxisLabelItems(QList<QQuickItem *> &textItems,
qsizetype neededSize, QQmlComponent *component)
{
Q_TRACE_SCOPE(QGraphs2DAxisRendererUpdateAxisLabelItems, textItems.count(),
static_cast<int>(neededSize));
qsizetype currentTextItemsSize = textItems.size();
if (currentTextItemsSize < neededSize) {
for (qsizetype i = currentTextItemsSize; i <= neededSize; i++) {
QQuickItem *item = nullptr;
if (component) {
item = qobject_cast<QQuickItem *>(
component->create(component->creationContext()));
}
if (!item)
item = new QQuickText();
item->setParent(this);
item->setParentItem(this);
textItems << item;
}
} else if (neededSize < currentTextItemsSize) {
// Hide unused text items
for (qsizetype i = neededSize; i < currentTextItemsSize; i++) {
auto textItem = textItems[i];
textItem->setVisible(false);
}
}
}
void AxisRenderer::setLabelTextProperties(QQuickItem *item, const QString &text, bool xAxis,
QQuickText::HAlignment hAlign, QQuickText::VAlignment vAlign,
Qt::TextElideMode elide)
{
if (auto textItem = qobject_cast<QQuickText *>(item)) {
// If the component is a Text item (default), then text
// properties can be set directly.
textItem->setText(text);
textItem->setHeight(textItem->contentHeight()); // Default height
textItem->setHAlign(hAlign);
textItem->setVAlign(vAlign);
if (xAxis) {
textItem->setFont(theme()->axisXLabelFont());
textItem->setColor(theme()->axisX().labelTextColor());
} else {
textItem->setFont(theme()->axisYLabelFont());
textItem->setColor(theme()->axisY().labelTextColor());
}
QQuickText::TextElideMode e;
switch (elide) {
case Qt::ElideLeft:
e = QQuickText::ElideLeft;
break;
case Qt::ElideRight:
e = QQuickText::ElideRight;
break;
case Qt::ElideMiddle:
e = QQuickText::ElideMiddle;
break;
default:
e = QQuickText::ElideNone;
}
textItem->setElideMode(e);
} else {
// Check for specific dynamic properties
if (item->property("text").isValid())
item->setProperty("text", text);
}
}
#if QT_CONFIG(graphs_2d_bar)
void AxisRenderer::updateBarXAxisLabels(AxisProperties &ax, const QRectF rect)
{
auto axis = qobject_cast<QBarCategoryAxis *>(ax.axis);
if (!axis)
return;
qsizetype categoriesCount = axis->categories().size();
// See if we need more text items
updateAxisLabelItems(ax.textItems, categoriesCount, axis->labelDelegate());
Q_TRACE_SCOPE(QGraphs2DAxisRendererUpdateBarXAxisLabels);
int textIndex = 0;
auto categories = axis->categories();
for (const auto &category : std::as_const(categories)) {
auto &textItem = ax.textItems[textIndex];
if (axis->isVisible() && axis->labelsVisible()) {
float posX = rect.x() + ((float)textIndex / categoriesCount) * rect.width();
if (axis->labelPosition() == QBarCategoryAxis::LabelPosition::OnValue)
posX += (1.0 / categoriesCount * rect.width() * 0.5);
textItem->setX(posX);
float posY = rect.y();
textItem->setY(posY);
textItem->setWidth(rect.width() / categoriesCount);
textItem->setRotation(axis->labelsAngle());
if (ax.axis->alignment() == Qt::AlignTop || ax.axis->alignment() == Qt::AlignLeft) {
setLabelTextProperties(textItem, category, true,
QQuickText::HAlignment::AlignHCenter,
QQuickText::VAlignment::AlignBottom,
axis->textElideMode());
} else {
setLabelTextProperties(textItem, category, true,
QQuickText::HAlignment::AlignHCenter,
QQuickText::VAlignment::AlignTop,
axis->textElideMode());
}
textItem->setHeight(rect.height());
textItem->setVisible(true);
theme()->dirtyBits()->axisXDirty = false;
} else {
textItem->setVisible(false);
}
textIndex++;
}
}
void AxisRenderer::updateBarYAxisLabels(AxisProperties &ax, const QRectF rect)
{
auto axis = qobject_cast<QBarCategoryAxis *>(ax.axis);
if (!axis)
return;
qsizetype categoriesCount = axis->categories().size();
// See if we need more text items
updateAxisLabelItems(ax.textItems, categoriesCount, axis->labelDelegate());
Q_TRACE_SCOPE(QGraphs2DAxisRendererUpdateBarYAxisLabels);
int textIndex = 0;
auto categories = axis->categories();
for (const auto &category : std::as_const(categories)) {
auto &textItem = ax.textItems[textIndex];
if (axis->isVisible() && axis->labelsVisible()) {
float posX = rect.x();
textItem->setX(posX);
float posY = rect.y() + ((float)textIndex / categoriesCount) * rect.height();
if (axis->labelPosition() == QBarCategoryAxis::LabelPosition::OnValue)
posY -= (1.0 / categoriesCount * rect.height() * 0.5);
textItem->setY(posY);
textItem->setWidth(rect.width());
textItem->setRotation(axis->labelsAngle());
if (ax.axis->alignment() == Qt::AlignRight || ax.axis->alignment() == Qt::AlignBottom) {
setLabelTextProperties(textItem, category, false,
QQuickText::HAlignment::AlignLeft,
QQuickText::VAlignment::AlignVCenter,
axis->textElideMode());
} else {
setLabelTextProperties(textItem, category, false,
QQuickText::HAlignment::AlignRight,
QQuickText::VAlignment::AlignVCenter,
axis->textElideMode());
}
textItem->setHeight(rect.height() / categoriesCount);
textItem->setVisible(true);
theme()->dirtyBits()->axisYDirty = false;
} else {
textItem->setVisible(false);
}
textIndex++;
}
}
#endif
void AxisRenderer::updateValueYAxisLabels(AxisProperties &ax, const QRectF rect)
{
auto axis = qobject_cast<QValueAxis *>(ax.axis);
if (!axis)
return;
// Create label values in the range
QList<double> yAxisLabelValues;
const int MAX_LABELS_COUNT = 100;
if (m_graph->orientation() == Qt::Vertical) {
for (double i = ax.minLabel; i <= ax.maxValue; i += ax.valueStep) {
yAxisLabelValues << i;
if (yAxisLabelValues.size() >= MAX_LABELS_COUNT)
break;
}
} else {
for (double i = ax.maxValue; i >= ax.minLabel; i -= ax.valueStep) {
yAxisLabelValues << i;
if (yAxisLabelValues.size() >= MAX_LABELS_COUNT)
break;
}
}
qsizetype categoriesCount = yAxisLabelValues.size();
// See if we need more text items
updateAxisLabelItems(ax.textItems, categoriesCount, axis->labelDelegate());
Q_TRACE_SCOPE(QGraphs2DAxisRendererUpdateValueYAxisLabels);
for (int i = 0; i < categoriesCount; i++) {
auto &textItem = ax.textItems[i];
if (axis->isVisible() && axis->labelsVisible()) {
float posX = rect.x();
textItem->setX(posX);
float posY = rect.y() + rect.height() - (((float)i) * ax.stepPx) + ax.displacement;
const double titleMargin = 0.01;
if ((posY - titleMargin) > (rect.height() + rect.y()) || (posY + titleMargin) < rect.y()) {
// Hide text item which are outside the axis area
textItem->setVisible(false);
continue;
}
textItem->setY(posY);
textItem->setWidth(rect.width());
textItem->setRotation(axis->labelsAngle());
double number = yAxisLabelValues.at(i);
// Format the number
int decimals = axis->labelDecimals();
if (decimals < 0)
decimals = getValueDecimalsFromRange(ax.valueRange);
const QString f = axis->labelFormat();
QString label = formatValueLabel(
number, decimalFormatSpec(f, decimals, 'f'), QLatin1StringView("f"));
label = axis->labelPostFormat().arg(label);
if (ax.axis->alignment() == Qt::AlignRight || ax.axis->alignment() == Qt::AlignBottom) {
setLabelTextProperties(textItem, label, false,
QQuickText::HAlignment::AlignLeft,
QQuickText::VAlignment::AlignVCenter,
axis->textElideMode());
} else {
setLabelTextProperties(textItem, label, false,
QQuickText::HAlignment::AlignRight,
QQuickText::VAlignment::AlignVCenter,
axis->textElideMode());
}
textItem->setHeight(0);
textItem->setVisible(true);
theme()->dirtyBits()->axisYDirty = false;
} else {
textItem->setVisible(false);
}
}
}
void AxisRenderer::updateValueXAxisLabels(AxisProperties &ax, const QRectF rect)
{
auto axis = qobject_cast<QValueAxis *>(ax.axis);
if (!axis)
return;
// Create label values in the range
QList<double> axisLabelValues;
const int MAX_LABELS_COUNT = 100;
for (double i = ax.minLabel; i <= ax.maxValue; i += ax.valueStep) {
axisLabelValues << i;
if (axisLabelValues.size() >= MAX_LABELS_COUNT)
break;
}
qsizetype categoriesCount = axisLabelValues.size();
// See if we need more text items
updateAxisLabelItems(ax.textItems, categoriesCount, axis->labelDelegate());
Q_TRACE_SCOPE(QGraphs2DAxisRendererUpdateValueXAxisLabels);
for (int i = 0; i < categoriesCount; i++) {
auto &textItem = ax.textItems[i];
if (axis->isVisible() && axis->labelsVisible()) {
float posY = rect.y();
textItem->setY(posY);
float textItemWidth = 20;
float posX = rect.x() + (((float)i) * ax.stepPx) - ax.displacement;
const double titleMargin = 0.01;
if ((posX - titleMargin) > (rect.width() + rect.x()) || (posX + titleMargin) < rect.x()) {
// Hide text item which are outside the axis area
textItem->setVisible(false);
continue;
}
// Take text size into account only after hiding
posX -= 0.5 * textItemWidth;
textItem->setX(posX);
textItem->setWidth(textItemWidth);
textItem->setRotation(axis->labelsAngle());
double number = axisLabelValues.at(i);
// Format the number
int decimals = axis->labelDecimals();
if (decimals < 0)
decimals = getValueDecimalsFromRange(ax.valueRange);
const QString f = axis->labelFormat();
QString label = formatValueLabel(
number, decimalFormatSpec(f, decimals, 'f'), QLatin1StringView("f"));
label = axis->labelPostFormat().arg(label);
if (ax.axis->alignment() == Qt::AlignTop || ax.axis->alignment() == Qt::AlignLeft) {
setLabelTextProperties(textItem, label, true,
QQuickText::HAlignment::AlignHCenter,
QQuickText::VAlignment::AlignBottom,
axis->textElideMode());
} else {
setLabelTextProperties(textItem, label, true,
QQuickText::HAlignment::AlignHCenter,
QQuickText::VAlignment::AlignTop,
axis->textElideMode());
}
textItem->setHeight(rect.height());
textItem->setVisible(true);
theme()->dirtyBits()->axisXDirty = false;
} else {
textItem->setVisible(false);
}
}
}
void AxisRenderer::updateDateTimeYAxisLabels(AxisProperties &ax, const QRectF rect)
{
auto axis = qobject_cast<QDateTimeAxis *>(ax.axis);
if (!axis)
return;
qint64 maxDate = ax.maxValue;
qint64 minDate = ax.minValue;
int dateTimeSize = ax.minLabel + 1;
qint64 segment = (maxDate - minDate)
/ ax.minLabel;
qint64 anchor = (minDate / segment) * segment;
// See if we need more text items
updateAxisLabelItems(ax.textItems, dateTimeSize, axis->labelDelegate());
Q_TRACE_SCOPE(QGraphs2DAxisRendererUpdateDateTimeYAxisLabels);
for (auto i = 0; i < dateTimeSize; ++i) {
auto &textItem = ax.textItems[i];
if (axis->isVisible() && axis->labelsVisible()) {
float posX = rect.x();
textItem->setX(posX);
float posY = rect.y() + rect.height() - (((float) i) * ax.stepPx) + ax.displacement;
const double titleMargin = 0.01;
if ((posY - titleMargin) > (rect.height() + rect.y())
|| (posY + titleMargin) < rect.y()) {
// Hide text item which are outside the axis area
textItem->setVisible(false);
continue;
}
textItem->setY(posY);
textItem->setWidth(rect.width());
textItem->setRotation(axis->labelsAngle());
auto date = QDateTime::fromMSecsSinceEpoch(anchor + (segment * i));
QString label = date.toString(axis->labelFormat());
if (ax.axis->alignment() == Qt::AlignRight || ax.axis->alignment() == Qt::AlignBottom) {
setLabelTextProperties(textItem, label, false,
QQuickText::HAlignment::AlignLeft,
QQuickText::VAlignment::AlignVCenter,
axis->textElideMode());
} else {
setLabelTextProperties(textItem, label, false,
QQuickText::HAlignment::AlignRight,
QQuickText::VAlignment::AlignVCenter,
axis->textElideMode());
}
textItem->setHeight(0);
textItem->setVisible(true);
} else {
textItem->setVisible(false);
}
}
}
void AxisRenderer::updateDateTimeXAxisLabels(AxisProperties &ax, const QRectF rect)
{
auto axis = qobject_cast<QDateTimeAxis *>(ax.axis);
if (!axis)
return;
qint64 maxDate = ax.maxValue;
qint64 minDate = ax.minValue;
int dateTimeSize = ax.minLabel + 1;
qint64 segment = (maxDate - minDate)
/ ax.minLabel;
//Avoid division through zero
if (segment == 0)
segment = 1;
qint64 anchor = (minDate / segment) * segment;
// See if we need more text items
updateAxisLabelItems(ax.textItems, dateTimeSize, axis->labelDelegate());
Q_TRACE_SCOPE(QGraphs2DAxisRendererUpdateDateTimeXAxisLabels);
for (auto i = 0; i < dateTimeSize; ++i) {
auto &textItem = ax.textItems[i];
if (axis->isVisible() && axis->labelsVisible()) {
float posY = rect.y();
textItem->setY(posY);
float textItemWidth = 20;
float posX = rect.x() + (((float) i) * ax.stepPx) - ax.displacement;
const double titleMargin = 0.01;
if ((posX - titleMargin) > (rect.width() + rect.x())
|| (posX + titleMargin) < rect.x()) {
// Hide text item which are outside the axis area
textItem->setVisible(false);
continue;
}
// Take text size into account only after hiding
posX += - 0.5 * textItemWidth;
textItem->setX(posX);
textItem->setWidth(textItemWidth);
textItem->setRotation(axis->labelsAngle());
auto date = QDateTime::fromMSecsSinceEpoch(anchor + (segment * i));
QString label = date.toString(axis->labelFormat());
if (ax.axis->alignment() == Qt::AlignTop || ax.axis->alignment() == Qt::AlignLeft) {
setLabelTextProperties(textItem, label, true,
QQuickText::HAlignment::AlignHCenter,
QQuickText::VAlignment::AlignBottom,
axis->textElideMode());
} else {
setLabelTextProperties(textItem, label, true,
QQuickText::HAlignment::AlignHCenter,
QQuickText::VAlignment::AlignTop,
axis->textElideMode());
}
textItem->setHeight(rect.height());
textItem->setVisible(true);
} else {
textItem->setVisible(false);
}
}
}
void AxisRenderer::updateLogValueXAxisLabels(AxisProperties &ax, const QRectF rect)
{
auto axis = qobject_cast<QLogValueAxis *>(ax.axis);
if (!axis)
return;
QList<double> axisLabelValues;
const int MAX_LABEL_COUNT = 100;
for (double i = ax.minLabel; i <= ax.maxValue; i += ax.valueStep) {
float value = pow(axis->base(), i);
axisLabelValues << value;
if (axisLabelValues.size() >= MAX_LABEL_COUNT)
break;
}
qsizetype categoriesCount = axisLabelValues.size();
updateAxisLabelItems(ax.textItems, categoriesCount, axis->labelDelegate());
Q_TRACE_SCOPE(QGraphs2DAxisRendererUpdateLogValueXAxisLabels);
for (int i = 0; i < categoriesCount; i++) {
auto &textItem = ax.textItems[i];
if (axis->isVisible() && axis->labelsVisible()) {
float posY = rect.y();
textItem->setY(posY);
float textItemWidth = 20;
float posX = rect.x() + (((float)i) * ax.stepPx) - ax.displacement;
const double titleMargin = 0.01;
if ((posX - titleMargin) > (rect.width() + rect.x()) || (posX + titleMargin) < rect.x()) {
// Hide text item which are outside the axis area
textItem->setVisible(false);
continue;
}
// Take text size into account only after hiding
posX -= 0.5 * textItemWidth;
textItem->setX(posX);
textItem->setWidth(textItemWidth);
textItem->setRotation(axis->labelsAngle());
double number = axisLabelValues.at(i);
// Format the number
QString label = formatValueLabel(
number,
decimalFormatSpec(axis->labelFormat(), axis->labelPrecision(), 'g'),
QLatin1StringView("g"));
label = axis->labelPostFormat().arg(label);
if (ax.axis->alignment() == Qt::AlignTop || ax.axis->alignment() == Qt::AlignLeft) {
setLabelTextProperties(textItem, label, true,
QQuickText::HAlignment::AlignHCenter,
QQuickText::VAlignment::AlignBottom,
axis->textElideMode());
} else {
setLabelTextProperties(textItem, label, true,
QQuickText::HAlignment::AlignHCenter,
QQuickText::VAlignment::AlignTop,
axis->textElideMode());
}
textItem->setHeight(rect.height());
textItem->setVisible(true);
theme()->dirtyBits()->axisXDirty = false;
} else {
textItem->setVisible(false);
}
}
}
void AxisRenderer::updateLogValueYAxisLabels(AxisProperties &ax, const QRectF rect)
{
auto axis = qobject_cast<QLogValueAxis *>(ax.axis);
if (!axis)
return;
// Create label values in the range
QList<double> yAxisLabelValues;
const int MAX_LABELS_COUNT = 100;
if (m_graph->orientation() == Qt::Vertical) {
for (double i = ax.minLabel; i <= ax.maxValue; i += ax.valueStep) {
float value = pow(axis->base(), i);
yAxisLabelValues << value;
if (yAxisLabelValues.size() >= MAX_LABELS_COUNT)
break;
}
} else {
for (double i = ax.maxValue; i >= ax.minLabel; i -= ax.valueStep) {
float value = pow(axis->base(), i);
yAxisLabelValues << value;
if (yAxisLabelValues.size() >= MAX_LABELS_COUNT)
break;
}
}
qsizetype categoriesCount = yAxisLabelValues.size();
// See if we need more text items
updateAxisLabelItems(ax.textItems, categoriesCount, axis->labelDelegate());
Q_TRACE_SCOPE(QGraphs2DAxisRendererUpdateLogValueYAxisLabels);
for (int i = 0; i < categoriesCount; i++) {
auto &textItem = ax.textItems[i];
if (axis->isVisible() && axis->labelsVisible()) {
float posX = rect.x();
textItem->setX(posX);
float posY = rect.y() + rect.height() - (((float)i) * ax.stepPx) + ax.displacement;
const double titleMargin = 0.01;
if ((posY - titleMargin) > (rect.height() + rect.y()) || (posY + titleMargin) < rect.y()) {
// Hide text item which are outside the axis area
textItem->setVisible(false);
continue;
}
textItem->setY(posY);
textItem->setWidth(rect.width());
textItem->setRotation(axis->labelsAngle());
double number = yAxisLabelValues.at(i);
// Format the number
QString label = formatValueLabel(
number,
decimalFormatSpec(axis->labelFormat(), axis->labelPrecision(), 'g'),
QLatin1StringView("g"));
label = axis->labelPostFormat().arg(label);
if (ax.axis->alignment() == Qt::AlignRight || ax.axis->alignment() == Qt::AlignBottom) {
setLabelTextProperties(textItem, label, false,
QQuickText::HAlignment::AlignLeft,
QQuickText::VAlignment::AlignVCenter,
axis->textElideMode());
} else {
setLabelTextProperties(textItem, label, false,
QQuickText::HAlignment::AlignRight,
QQuickText::VAlignment::AlignVCenter,
axis->textElideMode());
}
textItem->setHeight(0);
textItem->setVisible(true);
theme()->dirtyBits()->axisYDirty = false;
} else {
textItem->setVisible(false);
}
}
}
void AxisRenderer::createDragHandler()
{
m_dragHandler = new QQuickDragHandler(this);
m_dragHandler->setDragThreshold(10);
m_dragHandler->setTarget(nullptr);
connect(m_dragHandler,
&QQuickDragHandler::translationChanged,
this,
&AxisRenderer::onTranslationChanged);
connect(m_dragHandler, &QQuickDragHandler::grabChanged, this, &AxisRenderer::onGrabChanged);
}
void AxisRenderer::deleteDragHandler()
{
disconnect(m_dragHandler,
&QQuickDragHandler::translationChanged,
this,
&AxisRenderer::onTranslationChanged);
disconnect(m_dragHandler, &QQuickDragHandler::grabChanged, this, &AxisRenderer::onGrabChanged);
m_dragHandler->deleteLater();
m_dragHandler = nullptr;
}
QString AxisRenderer::formatValueLabel(double number,
const QString &format,
QLatin1StringView defaultFormat) const
{
return CommonUtils::formatNumber(number, format.isEmpty() ? defaultFormat : format);
}
// Calculate suitable major step based on range
double AxisRenderer::getValueStepsFromRange(double range) const
{
int digits = std::ceil(std::log10(range));
double r = std::pow(10.0, -digits);
r *= 10.0;
double v = std::ceil(range * r) / r;
double step = v * 0.1;
// Step must always be bigger than 0
step = qMax(0.0001, step);
return step;
}
// Calculate suitable decimals amount based on range
int AxisRenderer::getValueDecimalsFromRange(double range) const
{
if (range <= 0)
return 0;
int decimals = std::ceil(std::log10(10.0 / range));
// Decimals must always be at least 0
decimals = qMax(0, decimals);
return decimals;
}
QT_END_NAMESPACE
#include "moc_axisrenderer_p.cpp"