HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r2293:f2379b79baf8

Log domains update when axis base changes. LogAxis fix for labelFormat

Marek Rosa -

r2293:f2379b79baf8

parent child

Context file:

r2293:f2379b79baf8

Collapse all files

src/axis/chartaxis.cpp +12 -1

             /****************************************************************************
             **
             ** 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(0),
                   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)
             {
                 Q_ASSERT(item);
                 //initial initialization
                 m_arrow->setHandlesChildEvents(false);
                 m_arrow->setZValue(ChartPresenter::AxisZValue);
                 m_arrow->setVisible(m_axis->isLineVisible());
                 m_labels->setZValue(ChartPresenter::AxisZValue);
                 m_labels->setVisible(m_axis->labelsVisible());
                 m_shades->setZValue(ChartPresenter::ShadesZValue);
                 m_shades->setVisible(m_axis->shadesVisible());
                 m_grid->setZValue(ChartPresenter::GridZValue);
                 m_grid->setVisible(m_axis->isGridLineVisible());
                 m_title->setZValue(ChartPresenter::GridZValue);
                 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->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());
                     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;
             }
             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::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);
             }
             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);
                     }
                 }
                 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);
-                        labels << QString().sprintf(array, value);
+                        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);
                     }
                 }
                 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;
             }
             #include "moc_chartaxis_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/domain/logxlogydomain.cpp +4 0

             /****************************************************************************
             **
             ** 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 "logxlogydomain_p.h"
             #include "qabstractaxis_p.h"
             #include "qlogvalueaxis.h"
             #include <qmath.h>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             LogXLogYDomain::LogXLogYDomain(QObject *parent)
                 : AbstractDomain(parent),
                   m_logMinX(0),
                   m_logMaxX(1),
                   m_logBaseX(10),
                   m_logMinY(0),
                   m_logMaxY(1),
                   m_logBaseY(10)
             {
             }
             LogXLogYDomain::~LogXLogYDomain()
             {
             }
             void LogXLogYDomain::setRange(qreal minX, qreal maxX, qreal minY, qreal maxY)
             {
                 bool axisXChanged = false;
                 bool axisYChanged = false;
                 if (!qFuzzyIsNull(m_minX - minX) || !qFuzzyIsNull(m_maxX - maxX)) {
                     m_minX = minX;
                     m_maxX = maxX;
                     axisXChanged = true;
                     m_logMinX = log10(m_minX) / log10(m_logBaseX);
                     m_logMaxX = log10(m_maxX) / log10(m_logBaseX);
                     if(!m_signalsBlocked)
                     emit rangeHorizontalChanged(m_minX, m_maxX);
                 }
                 if (!qFuzzyIsNull(m_minY - minY) || !qFuzzyIsNull(m_maxY - maxY)) {
                     m_minY = minY;
                     m_maxY = maxY;
                     axisYChanged = true;
                     m_logMinY = log10(m_minY) / log10(m_logBaseY);
                     m_logMaxY = log10(m_maxY) / log10(m_logBaseY);
                     if(!m_signalsBlocked)
                     emit rangeVerticalChanged(m_minY, m_maxY);
                 }
                 if (axisXChanged || axisYChanged)
                     emit updated();
             }
             void LogXLogYDomain::zoomIn(const QRectF &rect)
             {
                 qreal newLogMinX = rect.left() * (m_logMaxX - m_logMinX) / m_size.width() + m_logMinX;
                 qreal newLogMaxX = rect.right() * (m_logMaxX - m_logMinX) / m_size.width() + m_logMinX;
                 qreal minX = qPow(m_logBaseX, newLogMinX);
                 qreal maxX = qPow(m_logBaseX, newLogMaxX);
                 qreal newLogMinY = m_logMaxY - rect.bottom() * (m_logMaxY - m_logMinY) / m_size.height();
                 qreal newLogMaxY = m_logMaxY - rect.top() * (m_logMaxY - m_logMinY) / m_size.height();
                 qreal minY = qPow(m_logBaseY, newLogMinY);
                 qreal maxY = qPow(m_logBaseY, newLogMaxY);
                 setRange(minX, maxX, minY, maxY);
             }
             void LogXLogYDomain::zoomOut(const QRectF &rect)
             {
                 qreal ratioX = m_size.width()/rect.width();
                 qreal newLogMinX = m_logMinX - (m_logMaxX - m_logMinX) / ratioX;
                 qreal newLogMaxX = m_logMaxX + (m_logMaxX - m_logMinX) / ratioX;
                 qreal minX = qPow(m_logBaseX, newLogMinX);
                 qreal maxX = qPow(m_logBaseX, newLogMaxX);
                 qreal ratioY = m_size.height()/rect.height();
                 qreal newLogMinY = m_logMaxY - (m_logMaxY - m_logMinY) / ratioY;
                 qreal newLogMaxY = m_logMaxY + (m_logMaxY - m_logMinY) / ratioY;
                 qreal minY = qPow(m_logBaseY, newLogMinY);
                 qreal maxY = qPow(m_logBaseY, newLogMaxY);
                 setRange(minX, maxX, minY, maxY);
             }
             void LogXLogYDomain::move(qreal dx, qreal dy)
             {
                 qreal stepX = dx * qAbs(m_logMaxX - m_logMinX) / m_size.width();
                 qreal minX = qPow(m_logBaseX, m_logMinX + stepX);
                 qreal maxX = qPow(m_logBaseX, m_logMaxX + stepX);
                 qreal stepY = dy * qAbs(m_logMaxY - m_logMinY) / m_size.height();
                 qreal minY = qPow(m_logBaseY, m_logMinY + stepY);
                 qreal maxY = qPow(m_logBaseY, m_logMaxY + stepY);
                 setRange(minX, maxX, minY, maxY);
             }
             QPointF LogXLogYDomain::calculateGeometryPoint(const QPointF &point) const
             {
                 const qreal leftEdgeX= m_logMinX < m_logMaxX ? m_logMinX : m_logMaxX;
                 const qreal leftEdgeY = m_logMinY < m_logMaxY ? m_logMinY : m_logMaxY;
                 const qreal deltaX = m_size.width() / qAbs(m_logMaxX - m_logMinX);
                 const qreal deltaY = m_size.height() / qAbs(m_logMaxY - m_logMinY);
                 qreal x = (log10(point.x()) / log10(m_logBaseX)) * deltaX - leftEdgeX * deltaX;
                 qreal y = (log10(point.y()) / log10(m_logBaseY)) * -deltaY - leftEdgeY * -deltaY + m_size.height();
                 return QPointF(x, y);
             }
             QVector<QPointF> LogXLogYDomain::calculateGeometryPoints(const QList<QPointF>& vector) const
             {
                 const qreal leftEdgeX= m_logMinX < m_logMaxX ? m_logMinX : m_logMaxX;
                 const qreal leftEdgeY = m_logMinY < m_logMaxY ? m_logMinY : m_logMaxY;
                 const qreal deltaX = m_size.width() / qAbs(m_logMaxX - m_logMinX);
                 const qreal deltaY = m_size.height() / qAbs(m_logMaxY - m_logMinY);
                 QVector<QPointF> result;
                 result.resize(vector.count());
                 for (int i = 0; i < vector.count(); ++i) {
                     qreal x = (log10(vector[i].x()) / log10(m_logBaseX)) * deltaX - leftEdgeX * deltaX;
                     qreal y = (log10(vector[i].y()) / log10(m_logBaseY)) * -deltaY - leftEdgeY * -deltaY + m_size.height();
                     result[i].setX(x);
                     result[i].setY(y);
                 }
                 return result;
             }
             QPointF LogXLogYDomain::calculateDomainPoint(const QPointF &point) const
             {
                 const qreal leftEdgeX= m_logMinX < m_logMaxX ? m_logMinX : m_logMaxX;
                 const qreal leftEdgeY = m_logMinY < m_logMaxY ? m_logMinY : m_logMaxY;
                 const qreal deltaX = m_size.width() / qAbs(m_logMaxX - m_logMinX);
                 const qreal deltaY = m_size.height() / qAbs(m_logMaxY - m_logMinY);
                 qreal x = qPow(m_logBaseX, leftEdgeX + point.x() / deltaX);
                 qreal y = qPow(m_logBaseY, leftEdgeY + (m_size.height() - point.y()) / deltaY);
                 return QPointF(x, y);
             }
             bool LogXLogYDomain::attachAxis(QAbstractAxis* axis)
             {
                 AbstractDomain::attachAxis(axis);
                 QLogValueAxis *logAxis = qobject_cast<QLogValueAxis *>(axis);
                 if(logAxis && logAxis->orientation()==Qt::Vertical)
                     QObject::connect(logAxis, SIGNAL(baseChanged(qreal)), this, SLOT(handleVerticalAxisBaseChanged(qreal)));
                 if(logAxis && logAxis->orientation()==Qt::Horizontal)
                     QObject::connect(logAxis, SIGNAL(baseChanged(qreal)), this, SLOT(handleHorizontalAxisBaseChanged(qreal)));
                 return true;
             }
             bool LogXLogYDomain::detachAxis(QAbstractAxis* axis)
             {
                 AbstractDomain::detachAxis(axis);
                 QLogValueAxis *logAxis = qobject_cast<QLogValueAxis *>(axis);
                 if(logAxis && logAxis->orientation()==Qt::Vertical)
                     QObject::disconnect(logAxis, SIGNAL(baseChanged(qreal)), this, SLOT(handleVerticalAxisBaseChanged(qreal)));
                 if(logAxis && logAxis->orientation()==Qt::Horizontal)
                     QObject::disconnect(logAxis, SIGNAL(baseChanged(qreal)), this, SLOT(handleHorizontalAxisBaseChanged(qreal)));
                 return true;
             }
             void LogXLogYDomain::handleVerticalAxisBaseChanged(qreal baseY)
             {
                 m_logBaseY = baseY;
+                m_logMinY = log10(m_minY) / log10(m_logBaseY);
+                m_logMaxY = log10(m_maxY) / log10(m_logBaseY);
             }
             void LogXLogYDomain::handleHorizontalAxisBaseChanged(qreal baseX)
             {
                 m_logBaseX = baseX;
+                m_logMinX = log10(m_minX) / log10(m_logBaseX);
+                m_logMaxX = log10(m_maxX) / log10(m_logBaseX);
             }
             // operators
             bool QTCOMMERCIALCHART_AUTOTEST_EXPORT operator== (const LogXLogYDomain &domain1, const LogXLogYDomain &domain2)
             {
                 return (qFuzzyIsNull(domain1.m_maxX - domain2.m_maxX) &&
                         qFuzzyIsNull(domain1.m_maxY - domain2.m_maxY) &&
                         qFuzzyIsNull(domain1.m_minX - domain2.m_minX) &&
                         qFuzzyIsNull(domain1.m_minY - domain2.m_minY));
             }
             bool QTCOMMERCIALCHART_AUTOTEST_EXPORT operator!= (const LogXLogYDomain &domain1, const LogXLogYDomain &domain2)
             {
                 return !(domain1 == domain2);
             }
             QDebug QTCOMMERCIALCHART_AUTOTEST_EXPORT operator<<(QDebug dbg, const LogXLogYDomain &domain)
             {
                 dbg.nospace() << "AbstractDomain(" << domain.m_minX << ',' << domain.m_maxX << ',' << domain.m_minY << ',' << domain.m_maxY << ')' << domain.m_size;
                 return dbg.maybeSpace();
             }
             #include "moc_logxlogydomain_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/domain/logxydomain.cpp +2 0

             /****************************************************************************
             **
             ** 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 "logxydomain_p.h"
             #include "qabstractaxis_p.h"
             #include "qlogvalueaxis.h"
             #include <qmath.h>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             LogXYDomain::LogXYDomain(QObject *parent)
                 : AbstractDomain(parent),
                   m_logMinX(0),
                   m_logMaxX(1),
                   m_logBaseX(10)
             {
             }
             LogXYDomain::~LogXYDomain()
             {
             }
             void LogXYDomain::setRange(qreal minX, qreal maxX, qreal minY, qreal maxY)
             {
                 bool axisXChanged = false;
                 bool axisYChanged = false;
                 if (!qFuzzyCompare(m_minX, minX) || !qFuzzyCompare(m_maxX, maxX)) {
                     m_minX = minX;
                     m_maxX = maxX;
                     axisXChanged = true;
                     m_logMinX = log10(m_minX) / log10(m_logBaseX);
                     m_logMaxX = log10(m_maxX) / log10(m_logBaseX);
                     if(!m_signalsBlocked)
                     emit rangeHorizontalChanged(m_minX, m_maxX);
                 }
                 if (!qFuzzyIsNull(m_minY - minY) || !qFuzzyIsNull(m_maxY - maxY)) {
                     m_minY = minY;
                     m_maxY = maxY;
                     axisYChanged = true;
                     if(!m_signalsBlocked)
                     emit rangeVerticalChanged(m_minY, m_maxY);
                 }
                 if (axisXChanged || axisYChanged)
                     emit updated();
             }
             void LogXYDomain::zoomIn(const QRectF &rect)
             {
                 qreal newLogMinX = rect.left() * (m_logMaxX - m_logMinX) / m_size.width() + m_logMinX;
                 qreal newLogMaxX = rect.right() * (m_logMaxX - m_logMinX) / m_size.width() + m_logMinX;
                 qreal minX = qPow(m_logBaseX, newLogMinX);
                 qreal maxX = qPow(m_logBaseX, newLogMaxX);
                 qreal dy = spanY() / m_size.height();
                 qreal minY = m_minY;
                 qreal maxY = m_maxY;
                 minY = maxY - dy * rect.bottom();
                 maxY = maxY - dy * rect.top();
                 setRange(minX, maxX, minY, maxY);
             }
             void LogXYDomain::zoomOut(const QRectF &rect)
             {
                 qreal ratioX = m_size.width()/rect.width();
                 qreal newLogMinX = m_logMinX - (m_logMaxX - m_logMinX) / ratioX;
                 qreal newLogMaxX = m_logMaxX + (m_logMaxX - m_logMinX) / ratioX;
                 qreal minX = qPow(m_logBaseX, newLogMinX);
                 qreal maxX = qPow(m_logBaseX, newLogMaxX);
                 qreal dy = spanY() / rect.height();
                 qreal minY = m_minY;
                 qreal maxY = m_maxY;
                 maxY = minY + dy * rect.bottom();
                 minY = maxY - dy * m_size.height();
                 setRange(minX, maxX, minY, maxY);
             }
             void LogXYDomain::move(qreal dx, qreal dy)
             {
                 qreal stepX = dx * qAbs(m_logMaxX - m_logMinX) / m_size.width();
                 qreal minX = qPow(m_logBaseX, m_logMinX + stepX);
                 qreal maxX = qPow(m_logBaseX, m_logMaxX + stepX);
                 qreal y = spanY() / m_size.height();
                 qreal minY = m_minY;
                 qreal maxY = m_maxY;
                 if (dy != 0) {
                     minY = minY + y * dy;
                     maxY = maxY + y * dy;
                 }
                 setRange(minX, maxX, minY, maxY);
             }
             QPointF LogXYDomain::calculateGeometryPoint(const QPointF &point) const
             {
                 const qreal leftEdge = m_logMinX < m_logMaxX ? m_logMinX : m_logMaxX;
                 const qreal deltaX = m_size.width() / qAbs(m_logMaxX - m_logMinX);
                 const qreal deltaY = m_size.height() / (m_maxY - m_minY);
                 qreal x = (log10(point.x()) / log10(m_logBaseX)) * deltaX - leftEdge * deltaX;
                 qreal y = (point.y() - m_minY) * -deltaY + m_size.height();
                 return QPointF(x, y);
             }
             QVector<QPointF> LogXYDomain::calculateGeometryPoints(const QList<QPointF>& vector) const
             {
                 const qreal leftEdge = m_logMinX < m_logMaxX ? m_logMinX : m_logMaxX;
                 const qreal deltaX = m_size.width() / qAbs(m_logMaxX - m_logMinX);
                 const qreal deltaY = m_size.height() / (m_maxY - m_minY);
                 QVector<QPointF> result;
                 result.resize(vector.count());
                 for (int i = 0; i < vector.count(); ++i) {
                     qreal x = (log10(vector[i].x()) / log10(m_logBaseX)) * deltaX - leftEdge * deltaX;
                     qreal y = (vector[i].y() - m_minY) * -deltaY + m_size.height();
                     result[i].setX(x);
                     result[i].setY(y);
                 }
                 return result;
             }
             QPointF LogXYDomain::calculateDomainPoint(const QPointF &point) const
             {
                 const qreal leftEdgeX= m_logMinX < m_logMaxX ? m_logMinX : m_logMaxX;
                 const qreal deltaX = m_size.width() / qAbs(m_logMaxX - m_logMinX);
                 const qreal deltaY = m_size.height() / (m_maxY - m_minY);
                 qreal x = qPow(m_logBaseX, leftEdgeX + point.x() / deltaX);
                 qreal y = (point.y() - m_size.height()) / (-deltaY) + m_minY;
                 return QPointF(x, y);
             }
             bool LogXYDomain::attachAxis(QAbstractAxis* axis)
             {
                 AbstractDomain::attachAxis(axis);
                 QLogValueAxis *logAxis = qobject_cast<QLogValueAxis *>(axis);
                 if(logAxis && logAxis->orientation()==Qt::Horizontal)
                     QObject::connect(logAxis, SIGNAL(baseChanged(qreal)), this, SLOT(handleHorizontalAxisBaseChanged(qreal)));
                 return true;
             }
             bool LogXYDomain::detachAxis(QAbstractAxis* axis)
             {
                 AbstractDomain::detachAxis(axis);
                 QLogValueAxis *logAxis = qobject_cast<QLogValueAxis *>(axis);
                 if(logAxis && logAxis->orientation()==Qt::Horizontal)
                     QObject::disconnect(logAxis, SIGNAL(baseChanged(qreal)), this, SLOT(handleHorizontalAxisBaseChanged(qreal)));
                 return true;
             }
             void LogXYDomain::handleHorizontalAxisBaseChanged(qreal baseX)
             {
                 m_logBaseX = baseX;
+                m_logMinX = log10(m_minX) / log10(m_logBaseX);
+                m_logMaxX = log10(m_maxX) / log10(m_logBaseX);
             }
             // operators
             bool QTCOMMERCIALCHART_AUTOTEST_EXPORT operator== (const LogXYDomain &domain1, const LogXYDomain &domain2)
             {
                 return (qFuzzyIsNull(domain1.m_maxX - domain2.m_maxX) &&
                         qFuzzyIsNull(domain1.m_maxY - domain2.m_maxY) &&
                         qFuzzyIsNull(domain1.m_minX - domain2.m_minX) &&
                         qFuzzyIsNull(domain1.m_minY - domain2.m_minY));
             }
             bool QTCOMMERCIALCHART_AUTOTEST_EXPORT operator!= (const LogXYDomain &domain1, const LogXYDomain &domain2)
             {
                 return !(domain1 == domain2);
             }
             QDebug QTCOMMERCIALCHART_AUTOTEST_EXPORT operator<<(QDebug dbg, const LogXYDomain &domain)
             {
                 dbg.nospace() << "AbstractDomain(" << domain.m_minX << ',' << domain.m_maxX << ',' << domain.m_minY << ',' << domain.m_maxY << ')' << domain.m_size;
                 return dbg.maybeSpace();
             }
             #include "moc_logxydomain_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/domain/xlogydomain.cpp +2 0

             /****************************************************************************
             **
             ** 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 "xlogydomain_p.h"
             #include "qabstractaxis_p.h"
             #include "qlogvalueaxis.h"
             #include <qmath.h>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             XLogYDomain::XLogYDomain(QObject *parent)
                 : AbstractDomain(parent),
                   m_logMinY(0),
                   m_logMaxY(1),
                   m_logBaseY(10)
             {
             }
             XLogYDomain::~XLogYDomain()
             {
             }
             void XLogYDomain::setRange(qreal minX, qreal maxX, qreal minY, qreal maxY)
             {
                 bool axisXChanged = false;
                 bool axisYChanged = false;
                 if (!qFuzzyIsNull(m_minX - minX) || !qFuzzyIsNull(m_maxX - maxX)) {
                     m_minX = minX;
                     m_maxX = maxX;
                     axisXChanged = true;
                     if(!m_signalsBlocked)
                     emit rangeHorizontalChanged(m_minX, m_maxX);
                 }
                 if (!qFuzzyIsNull(m_minY - minY) || !qFuzzyIsNull(m_maxY - maxY)) {
                     m_minY = minY;
                     m_maxY = maxY;
                     axisYChanged = true;
                     m_logMinY = log10(m_minY) / log10(m_logBaseY);
                     m_logMaxY = log10(m_maxY) / log10(m_logBaseY);
                     if(!m_signalsBlocked)
                     emit rangeVerticalChanged(m_minY, m_maxY);
                 }
                 if (axisXChanged || axisYChanged)
                     emit updated();
             }
             void XLogYDomain::zoomIn(const QRectF &rect)
             {
                 qreal dx = spanX() / m_size.width();
                 qreal maxX = m_maxX;
                 qreal minX = m_minX;
                 maxX = minX + dx * rect.right();
                 minX = minX + dx * rect.left();
                 qreal newLogMinY = m_logMaxY - rect.bottom() * (m_logMaxY - m_logMinY) / m_size.height();
                 qreal newLogMaxY = m_logMaxY - rect.top() * (m_logMaxY - m_logMinY) / m_size.height();
                 qreal minY = qPow(m_logBaseY, newLogMinY);
                 qreal maxY = qPow(m_logBaseY, newLogMaxY);
                 setRange(minX, maxX, minY, maxY);
             }
             void XLogYDomain::zoomOut(const QRectF &rect)
             {
                 qreal dx = spanX() / rect.width();
                 qreal maxX = m_maxX;
                 qreal minX = m_minX;
                 minX = maxX - dx * rect.right();
                 maxX = minX + dx * m_size.width();
                 qreal ratioY = m_size.height()/rect.height();
                 qreal newLogMinY = m_logMaxY - (m_logMaxY - m_logMinY) / ratioY;
                 qreal newLogMaxY = m_logMaxY + (m_logMaxY - m_logMinY) / ratioY;
                 qreal minY = qPow(m_logBaseY, newLogMinY);
                 qreal maxY = qPow(m_logBaseY, newLogMaxY);
                 setRange(minX, maxX, minY, maxY);
             }
             void XLogYDomain::move(qreal dx, qreal dy)
             {
                 qreal x = spanX() / m_size.width();
                 qreal maxX = m_maxX;
                 qreal minX = m_minX;
                 if (dx != 0) {
                     minX = minX + x * dx;
                     maxX = maxX + x * dx;
                 }
                 qreal stepY = dy * qAbs(m_logMaxY - m_logMinY) / m_size.height();
                 qreal minY = qPow(m_logBaseY, m_logMinY + stepY);
                 qreal maxY = qPow(m_logBaseY, m_logMaxY + stepY);
                 setRange(minX, maxX, minY, maxY);
             }
             QPointF XLogYDomain::calculateGeometryPoint(const QPointF &point) const
             {
                 const qreal leftEdge = m_logMinY < m_logMaxY ? m_logMinY : m_logMaxY;
                 const qreal deltaX = m_size.width() / (m_maxX - m_minX);
                 const qreal deltaY = m_size.height() / qAbs(m_logMaxY - m_logMinY);
                 qreal x = (point.x() - m_minX) * deltaX;
                 qreal y = (log10(point.y()) / log10(m_logBaseY)) * -deltaY - leftEdge * -deltaY + m_size.height();
                 return QPointF(x, y);
             }
             QVector<QPointF> XLogYDomain::calculateGeometryPoints(const QList<QPointF>& vector) const
             {
                 const qreal leftEdge = m_logMinY < m_logMaxY ? m_logMinY : m_logMaxY;
                 const qreal deltaX = m_size.width() / (m_maxX - m_minX);
                 const qreal deltaY = m_size.height() / qAbs(m_logMaxY - m_logMinY);
                 QVector<QPointF> result;
                 result.resize(vector.count());
                 for (int i = 0; i < vector.count(); ++i) {
                     qreal x = (vector[i].x() - m_minX) * deltaX;
                     qreal y = (log10(vector[i].y()) / log10(m_logBaseY)) * -deltaY - leftEdge * -deltaY + m_size.height();
                     result[i].setX(x);
                     result[i].setY(y);
                 }
                 return result;
             }
             QPointF XLogYDomain::calculateDomainPoint(const QPointF &point) const
             {
                 const qreal deltaX = m_size.width() / (m_maxX - m_minX);
                 const qreal leftEdgeY = m_logMinY < m_logMaxY ? m_logMinY : m_logMaxY;
                 const qreal deltaY = m_size.height() / qAbs(m_logMaxY - m_logMinY);
                 qreal x = point.x() / deltaX + m_minX;
                 qreal y = qPow(m_logBaseY, leftEdgeY + (m_size.height() - point.y()) / deltaY);
                 return QPointF(x, y);
             }
             bool XLogYDomain::attachAxis(QAbstractAxis* axis)
             {
                 QLogValueAxis *logAxis = qobject_cast<QLogValueAxis *>(axis);
                 if(logAxis && logAxis->orientation()==Qt::Vertical)
                     QObject::connect(logAxis, SIGNAL(baseChanged(qreal)), this, SLOT(handleVerticalAxisBaseChanged(qreal)));
                 return  AbstractDomain::attachAxis(axis);
             }
             bool XLogYDomain::detachAxis(QAbstractAxis* axis)
             {
                 QLogValueAxis *logAxis = qobject_cast<QLogValueAxis *>(axis);
                 if(logAxis && logAxis->orientation()==Qt::Vertical)
                     QObject::disconnect(logAxis, SIGNAL(baseChanged(qreal)), this, SLOT(handleVerticalAxisBaseChanged(qreal)));
                 return AbstractDomain::detachAxis(axis);
             }
             void XLogYDomain::handleVerticalAxisBaseChanged(qreal baseY)
             {
                 m_logBaseY = baseY;
+                m_logMinY = log10(m_minY) / log10(m_logBaseY);
+                m_logMaxY = log10(m_maxY) / log10(m_logBaseY);
             }
             // operators
             bool QTCOMMERCIALCHART_AUTOTEST_EXPORT operator== (const XLogYDomain &domain1, const XLogYDomain &domain2)
             {
                 return (qFuzzyIsNull(domain1.m_maxX - domain2.m_maxX) &&
                         qFuzzyIsNull(domain1.m_maxY - domain2.m_maxY) &&
                         qFuzzyIsNull(domain1.m_minX - domain2.m_minX) &&
                         qFuzzyIsNull(domain1.m_minY - domain2.m_minY));
             }
             bool QTCOMMERCIALCHART_AUTOTEST_EXPORT operator!= (const XLogYDomain &domain1, const XLogYDomain &domain2)
             {
                 return !(domain1 == domain2);
             }
             QDebug QTCOMMERCIALCHART_AUTOTEST_EXPORT operator<<(QDebug dbg, const XLogYDomain &domain)
             {
                 dbg.nospace() << "AbstractDomain(" << domain.m_minX << ',' << domain.m_maxX << ',' << domain.m_minY << ',' << domain.m_maxY << ')' << domain.m_size;
                 return dbg.maybeSpace();
             }
             #include "moc_xlogydomain_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages