|
|
/****************************************************************************
|
|
|
**
|
|
|
** Copyright (C) 2012 Digia Plc
|
|
|
** All rights reserved.
|
|
|
** For any questions to Digia, please use contact form at http://qt.digia.com
|
|
|
**
|
|
|
** This file is part of the Qt Commercial Charts Add-on.
|
|
|
**
|
|
|
** $QT_BEGIN_LICENSE$
|
|
|
** Licensees holding valid Qt Commercial licenses may use this file in
|
|
|
** accordance with the Qt Commercial License Agreement provided with the
|
|
|
** Software or, alternatively, in accordance with the terms contained in
|
|
|
** a written agreement between you and Digia.
|
|
|
**
|
|
|
** If you have questions regarding the use of this file, please use
|
|
|
** contact form at http://qt.digia.com
|
|
|
** $QT_END_LICENSE$
|
|
|
**
|
|
|
****************************************************************************/
|
|
|
|
|
|
#include "chartaxis_p.h"
|
|
|
#include "qabstractaxis.h"
|
|
|
#include "qabstractaxis_p.h"
|
|
|
#include "chartpresenter_p.h"
|
|
|
#include "chartlayout_p.h"
|
|
|
#include "abstractdomain_p.h"
|
|
|
#include <qmath.h>
|
|
|
#include <QDateTime>
|
|
|
#include <QValueAxis>
|
|
|
#include <QLogValueAxis>
|
|
|
#include <QGraphicsLayout>
|
|
|
#include <QFontMetrics>
|
|
|
|
|
|
QTCOMMERCIALCHART_BEGIN_NAMESPACE
|
|
|
|
|
|
ChartAxis::ChartAxis(QAbstractAxis *axis, QGraphicsItem* item , bool intervalAxis)
|
|
|
: ChartElement(item),
|
|
|
m_axis(axis),
|
|
|
m_labelsAngle(axis->labelsAngle()),
|
|
|
m_grid(new QGraphicsItemGroup(item)),
|
|
|
m_arrow(new QGraphicsItemGroup(item)),
|
|
|
m_shades(new QGraphicsItemGroup(item)),
|
|
|
m_labels(new QGraphicsItemGroup(item)),
|
|
|
m_title(new QGraphicsSimpleTextItem(item)),
|
|
|
m_animation(0),
|
|
|
m_labelPadding(5),
|
|
|
m_intervalAxis(intervalAxis),
|
|
|
m_titlePadding(3)
|
|
|
{
|
|
|
Q_ASSERT(item);
|
|
|
//initial initialization
|
|
|
m_arrow->setHandlesChildEvents(false);
|
|
|
m_arrow->setZValue(ChartPresenter::AxisZValue);
|
|
|
m_labels->setZValue(ChartPresenter::AxisZValue);
|
|
|
m_shades->setZValue(ChartPresenter::ShadesZValue);
|
|
|
m_grid->setZValue(ChartPresenter::GridZValue);
|
|
|
m_title->setZValue(ChartPresenter::GridZValue);
|
|
|
handleVisibleChanged(m_axis->isVisible());
|
|
|
connectSlots();
|
|
|
|
|
|
setFlag(QGraphicsItem::ItemHasNoContents,true);
|
|
|
}
|
|
|
|
|
|
void ChartAxis::connectSlots()
|
|
|
{
|
|
|
QObject::connect(m_axis,SIGNAL(visibleChanged(bool)),this,SLOT(handleVisibleChanged(bool)));
|
|
|
QObject::connect(m_axis,SIGNAL(lineVisibleChanged(bool)),this,SLOT(handleArrowVisibleChanged(bool)));
|
|
|
QObject::connect(m_axis,SIGNAL(gridVisibleChanged(bool)),this,SLOT(handleGridVisibleChanged(bool)));
|
|
|
QObject::connect(m_axis,SIGNAL(labelsVisibleChanged(bool)),this,SLOT(handleLabelsVisibleChanged(bool)));
|
|
|
QObject::connect(m_axis,SIGNAL(shadesVisibleChanged(bool)),this,SLOT(handleShadesVisibleChanged(bool)));
|
|
|
QObject::connect(m_axis,SIGNAL(labelsAngleChanged(int)),this,SLOT(handleLabelsAngleChanged(int)));
|
|
|
QObject::connect(m_axis,SIGNAL(linePenChanged(const QPen&)),this,SLOT(handleArrowPenChanged(const QPen&)));
|
|
|
QObject::connect(m_axis,SIGNAL(labelsPenChanged(const QPen&)),this,SLOT(handleLabelsPenChanged(const QPen&)));
|
|
|
QObject::connect(m_axis,SIGNAL(labelsBrushChanged(const QBrush&)),this,SLOT(handleLabelsBrushChanged(const QBrush&)));
|
|
|
QObject::connect(m_axis,SIGNAL(labelsFontChanged(const QFont&)),this,SLOT(handleLabelsFontChanged(const QFont&)));
|
|
|
QObject::connect(m_axis,SIGNAL(gridLinePenChanged(const QPen&)),this,SLOT(handleGridPenChanged(const QPen&)));
|
|
|
QObject::connect(m_axis,SIGNAL(shadesPenChanged(const QPen&)),this,SLOT(handleShadesPenChanged(const QPen&)));
|
|
|
QObject::connect(m_axis,SIGNAL(shadesBrushChanged(const QBrush&)),this,SLOT(handleShadesBrushChanged(const QBrush&)));
|
|
|
QObject::connect(m_axis,SIGNAL(titleTextChanged(const QString&)),this,SLOT(handleTitleTextChanged(const QString&)));
|
|
|
QObject::connect(m_axis,SIGNAL(titleFontChanged(const QFont&)),this,SLOT(handleTitleFontChanged(const QFont&)));
|
|
|
QObject::connect(m_axis,SIGNAL(titlePenChanged(const QPen&)),this,SLOT(handleTitlePenChanged(const QPen&)));
|
|
|
QObject::connect(m_axis,SIGNAL(titleBrushChanged(const QBrush&)),this,SLOT(handleTitleBrushChanged(const QBrush&)));
|
|
|
QObject::connect(m_axis,SIGNAL(titleVisibleChanged(bool)),this,SLOT(handleTitleVisibleChanged(bool)));
|
|
|
QObject::connect(m_axis->d_ptr.data(),SIGNAL(rangeChanged(qreal,qreal)),this,SLOT(handleRangeChanged(qreal,qreal)));
|
|
|
}
|
|
|
|
|
|
ChartAxis::~ChartAxis()
|
|
|
{
|
|
|
}
|
|
|
|
|
|
void ChartAxis::setAnimation(AxisAnimation *animation)
|
|
|
{
|
|
|
m_animation = animation;
|
|
|
}
|
|
|
|
|
|
void ChartAxis::setLayout(QVector<qreal> &layout)
|
|
|
{
|
|
|
m_layoutVector = layout;
|
|
|
}
|
|
|
|
|
|
void ChartAxis::createItems(int count)
|
|
|
{
|
|
|
if (m_arrow->childItems().size() == 0){
|
|
|
QGraphicsLineItem* arrow = new ArrowItem(this, this);
|
|
|
arrow->setPen(m_axis->linePen());
|
|
|
m_arrow->addToGroup(arrow);
|
|
|
}
|
|
|
|
|
|
if (m_intervalAxis && m_grid->childItems().size() == 0) {
|
|
|
for (int i = 0 ; i < 2 ; i ++){
|
|
|
QGraphicsLineItem* item = new QGraphicsLineItem(this);
|
|
|
item->setPen(m_axis->gridLinePen());
|
|
|
m_grid->addToGroup(item);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
for (int i = 0; i < count; ++i) {
|
|
|
QGraphicsLineItem* arrow = new QGraphicsLineItem(this);
|
|
|
arrow->setPen(m_axis->linePen());
|
|
|
QGraphicsLineItem* grid = new QGraphicsLineItem(this);
|
|
|
grid->setPen(m_axis->gridLinePen());
|
|
|
QGraphicsSimpleTextItem* label = new QGraphicsSimpleTextItem(this);
|
|
|
label->setFont(m_axis->labelsFont());
|
|
|
label->setPen(m_axis->labelsPen());
|
|
|
label->setBrush(m_axis->labelsBrush());
|
|
|
label->setRotation(m_labelsAngle);
|
|
|
m_arrow->addToGroup(arrow);
|
|
|
m_grid->addToGroup(grid);
|
|
|
m_labels->addToGroup(label);
|
|
|
|
|
|
if ((m_grid->childItems().size()) % 2 && m_grid->childItems().size() > 2){
|
|
|
QGraphicsRectItem* shades = new QGraphicsRectItem(this);
|
|
|
shades->setPen(m_axis->shadesPen());
|
|
|
shades->setBrush(m_axis->shadesBrush());
|
|
|
m_shades->addToGroup(shades);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
void ChartAxis::deleteItems(int count)
|
|
|
{
|
|
|
QList<QGraphicsItem *> lines = m_grid->childItems();
|
|
|
QList<QGraphicsItem *> labels = m_labels->childItems();
|
|
|
QList<QGraphicsItem *> shades = m_shades->childItems();
|
|
|
QList<QGraphicsItem *> axis = m_arrow->childItems();
|
|
|
|
|
|
for (int i = 0; i < count; ++i) {
|
|
|
if (lines.size() % 2 && lines.size() > 1)
|
|
|
delete(shades.takeLast());
|
|
|
delete(lines.takeLast());
|
|
|
delete(labels.takeLast());
|
|
|
delete(axis.takeLast());
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void ChartAxis::updateLayout(QVector<qreal> &layout)
|
|
|
{
|
|
|
int diff = m_layoutVector.size() - layout.size();
|
|
|
|
|
|
if (diff > 0)
|
|
|
deleteItems(diff);
|
|
|
else if (diff < 0)
|
|
|
createItems(-diff);
|
|
|
|
|
|
if (m_animation) {
|
|
|
switch (presenter()->state()) {
|
|
|
case ChartPresenter::ZoomInState:
|
|
|
m_animation->setAnimationType(AxisAnimation::ZoomInAnimation);
|
|
|
m_animation->setAnimationPoint(presenter()->statePoint());
|
|
|
break;
|
|
|
case ChartPresenter::ZoomOutState:
|
|
|
m_animation->setAnimationType(AxisAnimation::ZoomOutAnimation);
|
|
|
m_animation->setAnimationPoint(presenter()->statePoint());
|
|
|
break;
|
|
|
case ChartPresenter::ScrollUpState:
|
|
|
case ChartPresenter::ScrollLeftState:
|
|
|
m_animation->setAnimationType(AxisAnimation::MoveBackwordAnimation);
|
|
|
break;
|
|
|
case ChartPresenter::ScrollDownState:
|
|
|
case ChartPresenter::ScrollRightState:
|
|
|
m_animation->setAnimationType(AxisAnimation::MoveForwardAnimation);
|
|
|
break;
|
|
|
case ChartPresenter::ShowState:
|
|
|
m_animation->setAnimationType(AxisAnimation::DefaultAnimation);
|
|
|
break;
|
|
|
}
|
|
|
m_animation->setValues(m_layoutVector, layout);
|
|
|
presenter()->startAnimation(m_animation);
|
|
|
} else {
|
|
|
setLayout(layout);
|
|
|
updateGeometry();
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void ChartAxis::setLabelPadding(int padding)
|
|
|
{
|
|
|
m_labelPadding = padding;
|
|
|
}
|
|
|
|
|
|
void ChartAxis::setTitlePadding(int padding)
|
|
|
{
|
|
|
m_titlePadding = padding;
|
|
|
}
|
|
|
|
|
|
bool ChartAxis::isEmpty()
|
|
|
{
|
|
|
return m_axisRect.isEmpty() || m_gridRect.isEmpty() || qFuzzyCompare(min(),max());
|
|
|
}
|
|
|
|
|
|
void ChartAxis::setGeometry(const QRectF &axis, const QRectF &grid)
|
|
|
{
|
|
|
m_gridRect = grid;
|
|
|
m_axisRect = axis;
|
|
|
|
|
|
if (isEmpty())
|
|
|
return;
|
|
|
|
|
|
QVector<qreal> layout = calculateLayout();
|
|
|
updateLayout(layout);
|
|
|
}
|
|
|
|
|
|
qreal ChartAxis::min() const
|
|
|
{
|
|
|
return m_axis->d_ptr->min();
|
|
|
}
|
|
|
|
|
|
qreal ChartAxis::max() const
|
|
|
{
|
|
|
return m_axis->d_ptr->max();
|
|
|
}
|
|
|
|
|
|
QFont ChartAxis::font() const
|
|
|
{
|
|
|
return m_axis->labelsFont();
|
|
|
}
|
|
|
|
|
|
QFont ChartAxis::titleFont() const
|
|
|
{
|
|
|
return m_axis->titleFont();
|
|
|
}
|
|
|
|
|
|
QString ChartAxis::titleText() const
|
|
|
{
|
|
|
return m_axis->titleText();
|
|
|
}
|
|
|
|
|
|
void ChartAxis::axisSelected()
|
|
|
{
|
|
|
emit clicked();
|
|
|
}
|
|
|
|
|
|
Qt::Orientation ChartAxis::orientation() const
|
|
|
{
|
|
|
return m_axis->orientation();
|
|
|
}
|
|
|
|
|
|
Qt::Alignment ChartAxis::alignment() const
|
|
|
{
|
|
|
return m_axis->alignment();
|
|
|
}
|
|
|
|
|
|
void ChartAxis::setLabels(const QStringList &labels)
|
|
|
{
|
|
|
m_labelsList = labels;
|
|
|
}
|
|
|
|
|
|
QSizeF ChartAxis::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const
|
|
|
{
|
|
|
Q_UNUSED(which);
|
|
|
Q_UNUSED(constraint);
|
|
|
return QSizeF();
|
|
|
}
|
|
|
|
|
|
//handlers
|
|
|
|
|
|
void ChartAxis::handleArrowVisibleChanged(bool visible)
|
|
|
{
|
|
|
m_arrow->setVisible(visible);
|
|
|
}
|
|
|
|
|
|
void ChartAxis::handleGridVisibleChanged(bool visible)
|
|
|
{
|
|
|
m_grid->setVisible(visible);
|
|
|
}
|
|
|
|
|
|
void ChartAxis::handleLabelsVisibleChanged(bool visible)
|
|
|
{
|
|
|
m_labels->setVisible(visible);
|
|
|
}
|
|
|
|
|
|
void ChartAxis::handleShadesVisibleChanged(bool visible)
|
|
|
{
|
|
|
m_shades->setVisible(visible);
|
|
|
}
|
|
|
|
|
|
void ChartAxis::handleTitleVisibleChanged(bool visible)
|
|
|
{
|
|
|
m_title->setVisible(visible);
|
|
|
presenter()->layout()->invalidate();
|
|
|
}
|
|
|
|
|
|
void ChartAxis::handleLabelsAngleChanged(int angle)
|
|
|
{
|
|
|
foreach (QGraphicsItem *item, m_labels->childItems())
|
|
|
item->setRotation(angle);
|
|
|
|
|
|
m_labelsAngle = angle;
|
|
|
}
|
|
|
|
|
|
void ChartAxis::handleLabelsPenChanged(const QPen &pen)
|
|
|
{
|
|
|
foreach (QGraphicsItem *item , m_labels->childItems())
|
|
|
static_cast<QGraphicsSimpleTextItem *>(item)->setPen(pen);
|
|
|
}
|
|
|
|
|
|
void ChartAxis::handleLabelsBrushChanged(const QBrush &brush)
|
|
|
{
|
|
|
foreach (QGraphicsItem *item , m_labels->childItems())
|
|
|
static_cast<QGraphicsSimpleTextItem *>(item)->setBrush(brush);
|
|
|
}
|
|
|
|
|
|
void ChartAxis::handleLabelsFontChanged(const QFont &font)
|
|
|
{
|
|
|
foreach (QGraphicsItem *item , m_labels->childItems())
|
|
|
static_cast<QGraphicsSimpleTextItem *>(item)->setFont(font);
|
|
|
QGraphicsLayoutItem::updateGeometry();
|
|
|
presenter()->layout()->invalidate();
|
|
|
}
|
|
|
|
|
|
void ChartAxis::handleShadesBrushChanged(const QBrush &brush)
|
|
|
{
|
|
|
foreach (QGraphicsItem *item , m_shades->childItems())
|
|
|
static_cast<QGraphicsRectItem *>(item)->setBrush(brush);
|
|
|
}
|
|
|
|
|
|
void ChartAxis::handleShadesPenChanged(const QPen &pen)
|
|
|
{
|
|
|
foreach (QGraphicsItem *item , m_shades->childItems())
|
|
|
static_cast<QGraphicsRectItem *>(item)->setPen(pen);
|
|
|
}
|
|
|
|
|
|
void ChartAxis::handleArrowPenChanged(const QPen &pen)
|
|
|
{
|
|
|
foreach (QGraphicsItem *item , m_arrow->childItems())
|
|
|
static_cast<QGraphicsLineItem *>(item)->setPen(pen);
|
|
|
}
|
|
|
|
|
|
void ChartAxis::handleGridPenChanged(const QPen &pen)
|
|
|
{
|
|
|
foreach (QGraphicsItem *item , m_grid->childItems())
|
|
|
static_cast<QGraphicsLineItem *>(item)->setPen(pen);
|
|
|
}
|
|
|
|
|
|
void ChartAxis::handleTitleTextChanged(const QString &title)
|
|
|
{
|
|
|
Q_UNUSED(title)
|
|
|
QGraphicsLayoutItem::updateGeometry();
|
|
|
presenter()->layout()->invalidate();
|
|
|
}
|
|
|
|
|
|
|
|
|
void ChartAxis::handleTitlePenChanged(const QPen &pen)
|
|
|
{
|
|
|
m_title->setPen(pen);
|
|
|
}
|
|
|
|
|
|
void ChartAxis::handleTitleBrushChanged(const QBrush &brush)
|
|
|
{
|
|
|
m_title->setBrush(brush);
|
|
|
}
|
|
|
|
|
|
void ChartAxis::handleTitleFontChanged(const QFont &font)
|
|
|
{
|
|
|
if(m_title->font() != font){
|
|
|
m_title->setFont(font);
|
|
|
QGraphicsLayoutItem::updateGeometry();
|
|
|
presenter()->layout()->invalidate();
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void ChartAxis::handleVisibleChanged(bool visible)
|
|
|
{
|
|
|
setVisible(visible);
|
|
|
if(!visible) {
|
|
|
m_grid->setVisible(visible);
|
|
|
m_arrow->setVisible(visible);
|
|
|
m_shades->setVisible(visible);
|
|
|
m_labels->setVisible(visible);
|
|
|
m_title->setVisible(visible);
|
|
|
}else {
|
|
|
m_grid->setVisible(m_axis->isGridLineVisible());
|
|
|
m_arrow->setVisible(m_axis->isLineVisible());
|
|
|
m_shades->setVisible(m_axis->shadesVisible());
|
|
|
m_labels->setVisible(m_axis->labelsVisible());
|
|
|
m_title->setVisible(m_axis->isTitleVisible());
|
|
|
}
|
|
|
|
|
|
if(presenter()) presenter()->layout()->invalidate();
|
|
|
}
|
|
|
|
|
|
void ChartAxis::handleRangeChanged(qreal min, qreal max)
|
|
|
{
|
|
|
Q_UNUSED(min);
|
|
|
Q_UNUSED(max);
|
|
|
|
|
|
if (!isEmpty()) {
|
|
|
|
|
|
QVector<qreal> layout = calculateLayout();
|
|
|
updateLayout(layout);
|
|
|
QSizeF before = effectiveSizeHint(Qt::PreferredSize);
|
|
|
QSizeF after = sizeHint(Qt::PreferredSize);
|
|
|
|
|
|
if (before != after) {
|
|
|
QGraphicsLayoutItem::updateGeometry();
|
|
|
//we don't want to call invalidate on layout, since it will change minimum size of component,
|
|
|
//which we would like to avoid since it causes nasty flips when scrolling or zooming,
|
|
|
//instead recalculate layout and use plotArea for extra space.
|
|
|
presenter()->layout()->setGeometry(presenter()->layout()->geometry());
|
|
|
}
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
//helpers
|
|
|
|
|
|
QStringList ChartAxis::createValueLabels(qreal min, qreal max, int ticks,const QString& format)
|
|
|
{
|
|
|
//TODO: Q_ASSERT(m_max > m_min);
|
|
|
//TODO: Q_ASSERT(ticks > 1);
|
|
|
|
|
|
QStringList labels;
|
|
|
|
|
|
if(max <= min || ticks < 1){
|
|
|
return labels;
|
|
|
}
|
|
|
|
|
|
int n = qMax(int(-qFloor(log10((max - min) / (ticks - 1)))), 0);
|
|
|
n++;
|
|
|
|
|
|
if (format.isNull()) {
|
|
|
for (int i = 0; i < ticks; i++) {
|
|
|
qreal value = min + (i * (max - min) / (ticks - 1));
|
|
|
labels << QString::number(value, 'f', n);
|
|
|
}
|
|
|
} else {
|
|
|
QByteArray array = format.toLatin1();
|
|
|
for (int i = 0; i < ticks; i++) {
|
|
|
qreal value = min + (i * (max - min) / (ticks - 1));
|
|
|
if (format.contains("d")
|
|
|
|| format.contains("i")
|
|
|
|| format.contains("c"))
|
|
|
labels << QString().sprintf(array, (qint64)value);
|
|
|
else if (format.contains("u")
|
|
|
|| format.contains("o")
|
|
|
|| format.contains("x", Qt::CaseInsensitive))
|
|
|
labels << QString().sprintf(array, (quint64)value);
|
|
|
else if (format.contains("f", Qt::CaseInsensitive)
|
|
|
|| format.contains("e", Qt::CaseInsensitive)
|
|
|
|| format.contains("g", Qt::CaseInsensitive))
|
|
|
labels << QString().sprintf(array, value);
|
|
|
else
|
|
|
labels << QString();
|
|
|
}
|
|
|
}
|
|
|
|
|
|
return labels;
|
|
|
}
|
|
|
|
|
|
QStringList ChartAxis::createLogValueLabels(qreal min, qreal max, qreal base, int ticks, const QString& format)
|
|
|
{
|
|
|
// Q_ASSERT(m_max > m_min);
|
|
|
// Q_ASSERT(ticks > 1);
|
|
|
|
|
|
QStringList labels;
|
|
|
|
|
|
int n = 0;
|
|
|
if (ticks > 1)
|
|
|
n = qMax(int(-qFloor(log10((max - min) / (ticks - 1)))), 0);
|
|
|
n++;
|
|
|
|
|
|
int firstTick;
|
|
|
if (base > 1)
|
|
|
firstTick = ceil(log10(min) / log10(base));
|
|
|
else
|
|
|
firstTick = ceil(log10(max) / log10(base));
|
|
|
|
|
|
if (format.isNull()) {
|
|
|
for (int i = firstTick; i < ticks + firstTick; i++) {
|
|
|
qreal value = qPow(base, i);
|
|
|
labels << QString::number(value, 'f', n);
|
|
|
}
|
|
|
} else {
|
|
|
QByteArray array = format.toLatin1();
|
|
|
for (int i = firstTick; i < ticks + firstTick; i++) {
|
|
|
qreal value = qPow(base, i);
|
|
|
if (format.contains("d")
|
|
|
|| format.contains("i")
|
|
|
|| format.contains("c"))
|
|
|
labels << QString().sprintf(array, (qint64)value);
|
|
|
else if (format.contains("u")
|
|
|
|| format.contains("o")
|
|
|
|| format.contains("x", Qt::CaseInsensitive))
|
|
|
labels << QString().sprintf(array, (quint64)value);
|
|
|
else if (format.contains("f", Qt::CaseInsensitive)
|
|
|
|| format.contains("e", Qt::CaseInsensitive)
|
|
|
|| format.contains("g", Qt::CaseInsensitive))
|
|
|
labels << QString().sprintf(array, value);
|
|
|
else
|
|
|
labels << QString();
|
|
|
}
|
|
|
}
|
|
|
|
|
|
return labels;
|
|
|
}
|
|
|
|
|
|
QStringList ChartAxis::createDateTimeLabels(qreal min, qreal max,int ticks,const QString& format)
|
|
|
{
|
|
|
//TODO: Q_ASSERT(m_max > m_min);
|
|
|
//TODO: Q_ASSERT(ticks > 1);
|
|
|
QStringList labels;
|
|
|
|
|
|
if(max <= min || ticks < 1) {
|
|
|
return labels;
|
|
|
}
|
|
|
|
|
|
int n = qMax(int(-floor(log10((max - min) / (ticks - 1)))), 0);
|
|
|
n++;
|
|
|
for (int i = 0; i < ticks; i++) {
|
|
|
qreal value = min + (i * (max - min) / (ticks - 1));
|
|
|
labels << QDateTime::fromMSecsSinceEpoch(value).toString(format);
|
|
|
}
|
|
|
return labels;
|
|
|
}
|
|
|
|
|
|
QRect ChartAxis::labelBoundingRect(const QFontMetrics &fn, const QString &label) const
|
|
|
{
|
|
|
QRect boundingRect = fn.boundingRect(label);
|
|
|
|
|
|
// Take label rotation into account
|
|
|
if (m_labelsAngle) {
|
|
|
QTransform transform;
|
|
|
transform.rotate(m_labelsAngle);
|
|
|
boundingRect = transform.mapRect(boundingRect);
|
|
|
}
|
|
|
|
|
|
return boundingRect;
|
|
|
}
|
|
|
|
|
|
#include "moc_chartaxis_p.cpp"
|
|
|
|
|
|
QTCOMMERCIALCHART_END_NAMESPACE
|
|
|
|
