HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r554:7777ba21b3a6

Adds missing ticks hadnling

Michal Klocek -

r554:7777ba21b3a6

parent child

Context file:

r554:7777ba21b3a6

Collapse all files

src/axis/axisitem.cpp +5 -11

             #include "axisitem_p.h"
             #include "qchartaxis.h"
             #include "chartpresenter_p.h"
             #include "chartanimator_p.h"
             #include <QPainter>
             #include <QDebug>
             static int label_padding = 5;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             AxisItem::AxisItem(QChartAxis* axis,ChartPresenter* presenter,AxisType type,QGraphicsItem* parent) :
             ChartItem(parent),
             m_presenter(presenter),
             m_chartAxis(axis),
             m_type(type),
             m_labelsAngle(0),
             m_grid(parent),
             m_shades(parent),
             m_labels(parent),
             m_axis(parent),
             m_min(0),
             m_max(0),
             m_ticksCount(0)
             {
                 //initial initialization
                 m_axis.setZValue(ChartPresenter::AxisZValue);
                 m_shades.setZValue(ChartPresenter::ShadesZValue);
                 m_grid.setZValue(ChartPresenter::GridZValue);
                 setFlags(QGraphicsItem::ItemHasNoContents);
                 QObject::connect(m_chartAxis,SIGNAL(updated()),this,SLOT(handleAxisUpdated()));
                 QObject::connect(m_chartAxis->categories(),SIGNAL(updated()),this,SLOT(handleAxisCategoriesUpdated()));
                 handleAxisUpdated();
             }
             AxisItem::~AxisItem()
             {
             }
             QRectF AxisItem::boundingRect() const
             {
                 return QRectF();
             }
             void AxisItem::createItems(int count)
             {
                 if(m_axis.children().size()==0)
                        m_axis.addToGroup(new QGraphicsLineItem());
                 for (int i = 0; i < count; ++i) {
                        m_grid.addToGroup(new QGraphicsLineItem());
                        m_labels.addToGroup(new QGraphicsSimpleTextItem());
                        m_axis.addToGroup(new QGraphicsLineItem());
                       if((m_grid.childItems().size())%2 && m_grid.childItems().size()>2) m_shades.addToGroup(new QGraphicsRectItem());
                    }
             }
             void AxisItem::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_axis.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 AxisItem::updateLayout(QVector<qreal>& layout)
             {
                 if(m_animator){
                    m_animator->applyLayout(this,layout);
                 }
                 else setLayout(layout);
             }
             QStringList AxisItem::createLabels(int ticks, qreal min, qreal max) const
             {
                 Q_ASSERT(max>=min);
                 Q_ASSERT(ticks>0);
                 QStringList labels;
                 QChartAxisCategories* categories = m_chartAxis->categories();
                 for(int i=0; i< ticks; i++) {
                     qreal value = min + (i * (max - min)/ (ticks-1));
                     if(categories->count()==0) {
                         labels << QString::number(value);
                     }
                     else {
                         QString label = categories->label(value);
                         labels << label;
                     }
                 }
                 return labels;
             }
             void AxisItem::setAxisOpacity(qreal opacity)
             {
                 m_axis.setOpacity(opacity);
             }
             qreal AxisItem::axisOpacity() const
             {
                 return m_axis.opacity();
             }
             void AxisItem::setGridOpacity(qreal opacity)
             {
                 m_grid.setOpacity(opacity);
             }
             qreal AxisItem::gridOpacity() const
             {
                 return m_grid.opacity();
             }
             void AxisItem::setLabelsOpacity(qreal opacity)
             {
                 m_labels.setOpacity(opacity);
             }
             qreal AxisItem::labelsOpacity() const
             {
                 return m_labels.opacity();
             }
             void AxisItem::setShadesOpacity(qreal opacity)
             {
                 m_shades.setOpacity(opacity);
             }
             qreal AxisItem::shadesOpacity() const
             {
                 return m_shades.opacity();
             }
             void AxisItem::setLabelsAngle(int angle)
             {
                 foreach(QGraphicsItem* item , m_labels.childItems()) {
                       QPointF center = item->boundingRect().center();
                       item->setRotation(angle);
                 }
                 m_labelsAngle=angle;
             }
             void AxisItem::setLabelsPen(const QPen& pen)
             {
                 foreach(QGraphicsItem* item , m_labels.childItems()) {
                     static_cast<QGraphicsSimpleTextItem*>(item)->setPen(pen);
                 }
             }
             void AxisItem::setLabelsBrush(const QBrush& brush)
             {
                 foreach(QGraphicsItem* item , m_labels.childItems()) {
                     static_cast<QGraphicsSimpleTextItem*>(item)->setBrush(brush);
                 }
             }
             void AxisItem::setLabelsFont(const QFont& font)
             {
                 foreach(QGraphicsItem* item , m_labels.childItems()) {
                     static_cast<QGraphicsSimpleTextItem*>(item)->setFont(font);
                 }
             }
             void AxisItem::setShadesBrush(const QBrush& brush)
             {
                 foreach(QGraphicsItem* item , m_shades.childItems()) {
                     static_cast<QGraphicsRectItem*>(item)->setBrush(brush);
                 }
             }
             void AxisItem::setShadesPen(const QPen& pen)
             {
                 foreach(QGraphicsItem* item , m_shades.childItems()) {
                     static_cast<QGraphicsRectItem*>(item)->setPen(pen);
                 }
             }
             void AxisItem::setAxisPen(const QPen& pen)
             {
                 foreach(QGraphicsItem* item , m_axis.childItems()) {
                        static_cast<QGraphicsLineItem*>(item)->setPen(pen);
                 }
             }
             void AxisItem::setGridPen(const QPen& pen)
             {
                 foreach(QGraphicsItem* item , m_grid.childItems()) {
                     static_cast<QGraphicsLineItem*>(item)->setPen(pen);
                 }
             }
             QVector<qreal> AxisItem::calculateLayout() const
             {
                 Q_ASSERT(m_ticksCount>=2);
                 QVector<qreal> points;
                 points.resize(m_ticksCount);
                 switch (m_type)
                 {
                     case X_AXIS:
                     {
                         const qreal deltaX = m_rect.width()/(m_ticksCount-1);
                         for (int i = 0; i < m_ticksCount; ++i) {
                              int x = i * deltaX + m_rect.left();
                              points[i] = x;
                         }
                     }
                     break;
                     case Y_AXIS:
                     {
                         const qreal deltaY = m_rect.height()/(m_ticksCount-1);
                         for (int i = 0; i < m_ticksCount; ++i) {
                              int y = i * -deltaY + m_rect.bottom();
                              points[i] = y;
                         }
                     }
                     break;
                 }
                 return points;
             }
             void AxisItem::setLayout(QVector<qreal>& layout)
             {
             	int diff = m_layoutVector.size() - layout.size();
             	if(diff>0) {
             		deleteItems(diff);
             	}
             	else if(diff<0) {
             		createItems(-diff);
             	}
             	if(diff!=0) handleAxisUpdated();
                 QStringList ticksList = createLabels(layout.size(),m_min,m_max);
             	QList<QGraphicsItem *> lines = m_grid.childItems();
             	QList<QGraphicsItem *> labels = m_labels.childItems();
             	QList<QGraphicsItem *> shades = m_shades.childItems();
             	QList<QGraphicsItem *> axis = m_axis.childItems();
             	Q_ASSERT(labels.size() == ticksList.size());
             	Q_ASSERT(layout.size() == ticksList.size());
             	switch (m_type)
             	{
             		case X_AXIS:
             		{
             			QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(axis.at(0));
             			lineItem->setLine(m_rect.left(), m_rect.bottom(), m_rect.right(), m_rect.bottom());
             			for (int i = 0; i < layout.size(); ++i) {
             				QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(lines.at(i));
             				lineItem->setLine(layout[i], m_rect.top(), layout[i], m_rect.bottom());
             				QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem*>(labels.at(i));
             				labelItem->setText(ticksList.at(i));
             				QPointF center = labelItem->boundingRect().center();
             				labelItem->setTransformOriginPoint(center.x(), center.y());
             				labelItem->setPos(layout[i] - center.x(), m_rect.bottom() + label_padding);
             				if((i+1)%2 && i>1) {
             					QGraphicsRectItem *rectItem = static_cast<QGraphicsRectItem*>(shades.at(i/2-1));
             					rectItem->setRect(layout[i-1],m_rect.top(),layout[i]-layout[i-1],m_rect.height());
             				}
             				lineItem = static_cast<QGraphicsLineItem*>(axis.at(i+1));
             				lineItem->setLine(layout[i],m_rect.bottom(),layout[i],m_rect.bottom()+5);
             			}
             		}
             		break;
             		case Y_AXIS:
             		{
             			QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(axis.at(0));
             			lineItem->setLine(m_rect.left() , m_rect.top(), m_rect.left(), m_rect.bottom());
             			for (int i = 0; i < layout.size(); ++i) {
             				QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(lines.at(i));
             				lineItem->setLine(m_rect.left() , layout[i], m_rect.right(), layout[i]);
             				QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem*>(labels.at(i));
             				labelItem->setText(ticksList.at(i));
             				QPointF center = labelItem->boundingRect().center();
             				labelItem->setTransformOriginPoint(center.x(), center.y());
             				labelItem->setPos(m_rect.left() - labelItem->boundingRect().width() - label_padding , layout[i]-center.y());
             				if((i+1)%2 && i>1) {
             					QGraphicsRectItem *rectItem = static_cast<QGraphicsRectItem*>(shades.at(i/2-1));
             					rectItem->setRect(m_rect.left(),layout[i-1],m_rect.width(),layout[i-1]-layout[i]);
             				}
             				lineItem = static_cast<QGraphicsLineItem*>(axis.at(i+1));
             				lineItem->setLine(m_rect.left()-5,layout[i],m_rect.left(),layout[i]);
             			}
             		}
             		break;
             		default:
             		qDebug()<<"Unknown axis type";
             		break;
             	}
             	m_layoutVector=layout;
             }
             bool AxisItem::isEmpty()
             {
                 return m_rect.isEmpty() || m_min==m_max || m_ticksCount==0;
             }
             //handlers
             void AxisItem::handleAxisCategoriesUpdated()
             {
             	if(isEmpty()) return;
             	updateLayout(m_layoutVector);
             }
             void AxisItem::handleAxisUpdated()
             {
                 if(isEmpty()) return;
                 if(m_chartAxis->isAxisVisible()) {
                     setAxisOpacity(100);
                 }
                 else {
                     setAxisOpacity(0);
                 }
                 if(m_chartAxis->isGridLineVisible()) {
                     setGridOpacity(100);
                 }
                 else {
                     setGridOpacity(0);
                 }
                 if(m_chartAxis->labelsVisible())
                 {
                     setLabelsOpacity(100);
                 }
                 else {
                     setLabelsOpacity(0);
                 }
                 if(m_chartAxis->shadesVisible()) {
                     setShadesOpacity(m_chartAxis->shadesOpacity());
                 }
                 else {
                     setShadesOpacity(0);
                 }
                 setLabelsAngle(m_chartAxis->labelsAngle());
                 setAxisPen(m_chartAxis->axisPen());
                 setLabelsPen(m_chartAxis->labelsPen());
                 setLabelsBrush(m_chartAxis->labelsBrush());
                 setLabelsFont(m_chartAxis->labelsFont());
                 setGridPen(m_chartAxis->gridLinePen());
                 setShadesPen(m_chartAxis->shadesPen());
                 setShadesBrush(m_chartAxis->shadesBrush());
             }
             void AxisItem::handleRangeChanged(qreal min, qreal max,int tickCount)
             {
+                qDebug()<<min<<max<<tickCount;
+                if(min==max || tickCount<2) return;
                 m_min = min;
                 m_max = max;
-                m_ticksCount = tickCount;
+                m_ticksCount= tickCount;
-                /*= qrand()%10;
-                while(m_ticksCount<2){
-                    m_ticksCount = qrand()%10;
-                qDebug()<<"Warning : This is testing . Simulating new random ticks "<<  m_ticksCount;
-                //m_chartAxis->setTicksCount(m_ticksCount);
-            */
                 if(isEmpty()) return;
                 QVector<qreal> layout = calculateLayout();
                 updateLayout(layout);
             }
             void AxisItem::handleGeometryChanged(const QRectF& rect)
             {
                 m_rect = rect;
                 if(isEmpty()) return;
                 QVector<qreal> layout = calculateLayout();
                 updateLayout(layout);
             }
             //painter
             void AxisItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 Q_UNUSED(painter);
                 Q_UNUSED(option);
                 Q_UNUSED(widget);
             }
             //TODO "nice numbers algorithm"
             #include "moc_axisitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/qchartaxis.cpp +13 -7

             #include "qchartaxis.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QChartAxis
                 \brief The QChartAxis class is used for manipulating chart's axis
                 and for adding optional axes to the chart.
                 \mainclass
                 There is only one x Axis, however there can be multiple y axes.
                 Each chart series can be bound to exactly one Y axis and the share common X axis.
                 Axis can be setup to show axis line with ticks, gird lines and shades.
             */
             /*!
                \fn bool QChartAxis::isAxisVisible() const
                \brief Returns if axis is visible
                \sa setAxisVisible()
             */
             /*!
                \fn QPen QChartAxis::axisPen() const
                \brief  Returns pen used to draw axis and ticks.
                 \sa setAxisPen()
             */
             /*!
                \fn bool QChartAxis::isGridLineVisible() const
                \brief Returns if grid is visible
                \sa setGridLineVisible()
             */
             /*!
                \fn QPen QChartAxis::gridLinePen() const
                \brief  Returns pen used to draw grid.
                 \sa setGridLinePen()
             */
             /*!
                \fn  bool QChartAxis::labelsVisible() const
                \brief Returns if grid is visible
                \sa setLabelsVisible()
             */
             /*!
                \fn QPen QChartAxis::labelsPen() const
                \brief Returns the pen used to labels.
                 \sa setLabelsPen()
             */
             /*!
                \fn QBrush QChartAxis::labelsBrush() const
                \brief Returns brush used to draw labels.
                 \sa setLabelsBrush()
             */
             /*!
                \fn QFont QChartAxis::labelsFont() const
                \brief Returns font used to draw labels.
                 \sa setLabelsFont()
             */
             /*!
                \fn QFont QChartAxis::labelsAngle() const
                \brief Returns angle used to draw labels.
                 \sa setLabelsAngle()
             */
             /*!
                \fn bool QChartAxis::shadesVisible() const
                \brief Returns if shades are visible.
                \sa setShadesVisible()
             */
             /*!
               \fn  qreal QChartAxis::shadesOpacity() const
               \brief Returns opacity of shades.
              */
             /*!
                \fn QPen QChartAxis::shadesPen() const
                \brief Returns pen used to draw shades.
                 \sa setShadesPen()
             */
             /*!
                \fn QBrush QChartAxis::shadesBrush() const
                \brief Returns brush used to draw shades.
                 \sa setShadesBrush()
             */
             /*!
                \fn qreal QChartAxis::min() const
                \brief Returns minimum value on the axis.
                \sa setMin()
             */
             /*!
                \fn qreal QChartAxis::max() const
                \brief Returns maximim value on the axis.
                \sa setMax()
             */
             /*!
                \fn void QChartAxis::minChanged(qreal min)
                \brief Axis emits signal when \a min of axis has changed.
             */
             /*!
                \fn void QChartAxis::maxChanged(qreal max)
                \brief Axis emits signal when \a max of axis has changed.
             */
             /*!
                \fn void QChartAxis::rangeChanged(qreal min, qreal max)
                \brief Axis emits signal when \a min or \a max of axis has changed.
             */
             /*!
                \fn int QChartAxis::ticksCount() const
                \brief Return number of ticks on the axis
                \sa setTicksCount()
             */
             /*!
                 \fn void QChartAxis::updated()
                 \brief \internal
             */
             /*!
                 \fn void QChartAxis::handleAxisRangeChanged(qreal min, qreal max)
                 \brief \internal \a min \a max
             */
             /*!
                 Constructs new axis object which is a child of \a parent. Ownership is taken by
                 QChatView or QChart when axis added.
             */
             QChartAxis::QChartAxis(QObject* parent):QObject(parent),
             m_axisVisible(true),
             m_gridLineVisible(true),
             m_labelsVisible(true),
             m_labelsAngle(0),
             m_shadesVisible(false),
             m_shadesOpacity(1.0),
             m_min(0),
             m_max(0),
             m_ticksCount(5)
             {
             }
             /*!
                 Destructor of the axis object. When axis is added to chart, chart object takes ownership.
             */
             QChartAxis::~QChartAxis()
             {
             }
             /*!
               Sets \a pen used to draw axis line and ticks.
              */
             void QChartAxis::setAxisPen(const QPen& pen)
             {
             	if (pen != m_axisPen) {
                 m_axisPen=pen;
                 emit updated();
             	}
             }
             /*!
               Sets if axis and ticks are \a visible.
              */
             void QChartAxis::setAxisVisible(bool visible)
             {
             	if (m_axisVisible!=visible) {
                 m_axisVisible=visible;
                 emit updated();
             	}
             }
             /*!
               Sets if grid line is \a visible.
              */
             void QChartAxis::setGridLineVisible(bool visible)
             {
             	if (m_gridLineVisible!=visible) {
                 m_gridLineVisible=visible;
                 emit updated();
             	}
             }
             /*!
               Sets \a pen used to draw grid line.
              */
             void QChartAxis::setGridLinePen(const QPen& pen)
             {
             	if (m_gridLinePen!=pen) {
                 m_gridLinePen=pen;
                 emit updated();
             	}
             }
             /*!
               Sets if axis' labels are \a visible.
              */
             void QChartAxis::setLabelsVisible(bool visible)
             {
             	if(m_labelsVisible!=visible) {
                 m_labelsVisible=visible;
                 emit updated();
             	}
             }
             /*!
               Sets \a pen used to draw labels.
              */
             void QChartAxis::setLabelsPen(const QPen& pen)
             {
             	if(m_labelsPen!=pen) {
                 m_labelsPen=pen;
                 emit updated();
             	}
             }
             /*!
               Sets \a brush used to draw labels.
              */
             void QChartAxis::setLabelsBrush(const QBrush& brush)
             {
             	if(m_labelsBrush!=brush) {
                 m_labelsBrush=brush;
                 emit updated();
             	}
             }
             /*!
               Sets \a font used to draw labels.
              */
             void QChartAxis::setLabelsFont(const QFont& font)
             {
             	if(m_labelsFont!=font) {
                 m_labelsFont=font;
                 emit updated();
             	}
             }
             /*!
               Sets \a angle for all the labels on given axis.
              */
             void QChartAxis::setLabelsAngle(int angle)
             {
             	if(m_labelsAngle!=angle) {
             	m_labelsAngle=angle;
             	emit updated();
             	}
             }
             /*!
               Sets if shades are \a visible.
              */
             void QChartAxis::setShadesVisible(bool visible)
             {
             	if(m_shadesVisible!=visible) {
                 m_shadesVisible=visible;
                 emit updated();
             	}
             }
             /*!
               Sets \a pen used to draw shades.
              */
             void QChartAxis::setShadesPen(const QPen& pen)
             {
             	if(m_shadesPen!=pen) {
             	m_shadesPen=pen;
             	emit updated();
             	}
             }
             /*!
               Sets \a brush used to draw shades.
              */
             void QChartAxis::setShadesBrush(const QBrush& brush)
             {
             	if(m_shadesBrush!=brush) {
                 m_shadesBrush=brush;
                 emit updated();
             	}
             }
             /*!
               Sets \a opacity of the shades.
              */
             void QChartAxis::setShadesOpacity(qreal opacity)
             {
             	if(m_shadesOpacity!=opacity) {
                 m_shadesOpacity=opacity;
                 emit updated();
             	}
             }
             /*!
              Sets \a min value on the axis.
              */
             void QChartAxis::setMin(qreal min)
             {
             	setRange(min,m_max);
             }
             /*!
              Sets \a max value on the axis.
              */
             void QChartAxis::setMax(qreal max)
             {
                 setRange(m_min,max);
             }
             /*!
               Sets range from \a min to \a max on the axis.
              */
             void QChartAxis::setRange(qreal min, qreal max)
             {
             	bool changed = false;
                 if(m_min!=min) {
                     m_min=min;
                     changed=true;
                     emit minChanged(min);
                 }
                 if(m_max!=max) {
                     m_max=max;
                     changed=true;
                     emit maxChanged(max);
                 }
                 if(changed) {
-                    emit rangeChanged(m_min,m_max,m_ticksCount);
+                    emit rangeChanged(m_min,m_max);
                 }
             }
-            void QChartAxis::handleAxisRangeChanged(qreal min, qreal max)
-               setRange(min,max);
             /*!
               Sets \a count for ticks on the axis.
              */
             void QChartAxis::setTicksCount(int count)
             {
             	if(m_ticksCount!=count) {
             		m_ticksCount=count;
-            		emit rangeChanged(m_min,m_max,m_ticksCount);
+            		emit ticksCountChanged(count);
             	}
             }
             /*!
               Sets axis, shades, labels and grid lines to be visible.
              */
             void QChartAxis::show()
             {
                m_axisVisible=true;
                m_gridLineVisible=true;
                m_labelsVisible=true;
                m_shadesVisible=true;
                emit updated();
             }
             /*!
               Sets axis, shades, labels and grid lines to not be visible.
              */
             void QChartAxis::hide()
             {
                 m_axisVisible=false;
                 m_gridLineVisible=false;
                 m_labelsVisible=false;
                 m_shadesVisible=false;
                 emit updated();
             }
+            void QChartAxis::handleAxisRangeChanged(qreal min, qreal max)
+            {
+                qDebug()<<__FUNCTION__<<min<<max;
+               setRange(min,max);
+            }
+            void QChartAxis::handleAxisTicksChanged(int count)
+            {
+                setTicksCount(count);
+            }
             #include "moc_qchartaxis.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/qchartaxis.h +3 -1

             #ifndef QCHARTAXIS_H_
             #define QCHARTAXIS_H_
             #include <qchartaxiscategories.h>
             #include <QPen>
             #include <QFont>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QTCOMMERCIALCHART_EXPORT QChartAxis : public QObject
             {
             	Q_OBJECT
             public:
                 QChartAxis(QObject* parent =0);
                 ~QChartAxis();
                 //axis handling
                 bool isAxisVisible() const { return m_axisVisible;};
                 void setAxisVisible(bool visible);
                 void setAxisPen(const QPen& pen);
                 QPen axisPen() const { return m_axisPen;};
                 //grid handling
                 bool isGridLineVisible() const { return m_gridLineVisible;};
                 void setGridLineVisible(bool visible);
                 void setGridLinePen(const QPen& pen);
                 QPen gridLinePen() const {return m_gridLinePen;}
                 //labels handling
                 bool labelsVisible() const { return m_labelsVisible;};
                 void setLabelsVisible(bool visible);
                 void setLabelsPen(const QPen& pen);
                 QPen labelsPen() const { return m_labelsPen;}
                 void setLabelsBrush(const QBrush& brush);
                 QBrush labelsBrush() const { return m_labelsBrush;}
                 void setLabelsFont(const QFont& font);
                 QFont labelsFont() const { return m_labelsFont;}
                 void setLabelsAngle(int angle);
                 int labelsAngle() const { return m_labelsAngle;};
                 //shades handling
                 bool shadesVisible() const { return m_shadesVisible;};
                 void setShadesVisible(bool visible);
                 void setShadesPen(const QPen& pen);
                 QPen shadesPen() const { return m_shadesPen;}
                 void setShadesBrush(const QBrush& brush);
                 QBrush shadesBrush() const { return m_shadesBrush;}
                 void setShadesOpacity(qreal opacity);
                 qreal shadesOpacity() const { return m_shadesOpacity;}
                 //range handling
                 void setMin(qreal min);
                 qreal min() const { return m_min;};
                 void setMax(qreal max);
                 qreal max() const { return m_max;};
                 void setRange(qreal min, qreal max);
                 //ticks handling
                 void setTicksCount(int count);
                 int ticksCount() const { return m_ticksCount;}
                 QChartAxisCategories* categories() { return &m_category; }
                 void show();
                 void hide();
             signals:
             	void minChanged(qreal min);
             	void maxChanged(qreal max);
-            	void rangeChanged(qreal min, qreal max,int ticksCount);
+            	void rangeChanged(qreal min, qreal max);
+            	void ticksCountChanged(int count);
             //interal signal
             	void updated();
             //internal slot
             public slots:
             	void handleAxisRangeChanged(qreal min, qreal max);
+                void handleAxisTicksChanged(int count);
             private:
                 bool m_axisVisible;
                 QPen m_axisPen;
                 QBrush m_axisBrush;
                 bool m_gridLineVisible;
                 QPen m_gridLinePen;
                 bool m_labelsVisible;
                 QPen m_labelsPen;
                 QBrush m_labelsBrush;
                 QFont m_labelsFont;
                 int m_labelsAngle;
                 bool m_shadesVisible;
                 QPen m_shadesPen;
                 QBrush m_shadesBrush;
                 qreal m_shadesOpacity;
                 qreal m_min;
                 qreal m_max;
                 int m_ticksCount;
                 QChartAxisCategories m_category;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif /* QCHARTAXIS_H_ */

src/chartdataset.cpp +6 -2

             #include "chartdataset_p.h"
             #include "qchartaxis.h"
             //series
             #include "qlineseries.h"
             #include "qareaseries.h"
             #include "qbarseries.h"
             #include "qstackedbarseries.h"
             #include "qpercentbarseries.h"
             #include "qpieseries.h"
             #include "qscatterseries.h"
             #include "qsplineseries.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartDataSet::ChartDataSet(QObject *parent):QObject(parent),
                 m_axisX(new QChartAxis(this)),
                 m_axisY(new QChartAxis(this)),
                 m_domainIndex(0),
                 m_axisXInitialized(false)
             {
             }
             ChartDataSet::~ChartDataSet()
             {
             }
             void ChartDataSet::addSeries(QSeries* series, QChartAxis *axisY)
             {
                 if(axisY==0) axisY = m_axisY;
                 QChartAxis* axis = m_seriesAxisMap.value(series);
                 if(axis) {
                     qWarning() << "Can not add series. Series already on the chart";
                     return;
                 }
                 if(!series->parent()){
                    series->setParent(this); // take ownership
                 };
                 if(!axisY->parent()){
                    axisY->setParent(this); // take ownership
                 }
                 Domain* domain = m_axisDomainMap.value(axisY);
                 if(!domain) {
                     domain = new Domain();
-                    QObject::connect(axisY,SIGNAL(rangeChanged(qreal,qreal,int)),domain,SLOT(handleAxisRangeYChanged(qreal,qreal,int)));
+                    QObject::connect(axisY,SIGNAL(rangeChanged(qreal,qreal)),domain,SLOT(handleAxisRangeYChanged(qreal,qreal)));
-                    QObject::connect(axisX(),SIGNAL(rangeChanged(qreal,qreal,int)),domain,SLOT(handleAxisRangeXChanged(qreal,qreal,int)));
+                    QObject::connect(axisX(),SIGNAL(rangeChanged(qreal,qreal)),domain,SLOT(handleAxisRangeXChanged(qreal,qreal)));
+                    QObject::connect(axisY,SIGNAL(ticksCountChanged(int)),domain,SLOT(handleAxisYTicksCountChanged(int)));
+                    QObject::connect(axisX(),SIGNAL(ticksCountChanged(int)),domain,SLOT(handleAxisXTicksCountChanged(int)));
+                    QObject::connect(domain,SIGNAL(rangeYChanged(qreal,qreal,int)),axisY,SLOT(handleAxisRangeChanged(qreal,qreal)));
+                    QObject::connect(domain,SIGNAL(rangeXChanged(qreal,qreal,int)),axisX(),SLOT(handleAxisRangeChanged(qreal,qreal)));
                     //initialize
                     m_axisDomainMap.insert(axisY,domain);
                     emit axisAdded(axisY,domain);
                 }
                 if(!m_axisXInitialized){
                    emit axisAdded(axisX(),domain);
                    m_axisXInitialized=true;
                 }
                 calculateDomain(series,domain);
                 m_seriesAxisMap.insert(series,axisY);
                 emit seriesAdded(series,domain);
             }
             void ChartDataSet::removeSeries(QSeries* series)
             {
                 QChartAxis* axis = m_seriesAxisMap.value(series);
                 if(!axis){
                     qWarning()<<"Can not remove series. Series not found on the chart.";
                     return;
                 }
                 emit seriesRemoved(series);
                 m_seriesAxisMap.remove(series);
                 if(series->parent()==this){
                     delete series;
                     series=0;
                 }
                 QList<QChartAxis*> axes =  m_seriesAxisMap.values();
                 int i = axes.indexOf(axis);
                 if(i==-1){
                     Domain* domain = m_axisDomainMap.take(axis);
                     emit axisRemoved(axis);
                     if(axis!=axisY()){
                         if(axis->parent()==this){
                             delete axis;
                             axis=0;
                         }
                     }
                     delete domain;
                 }
                 if(m_seriesAxisMap.values().size()==0)
                 {
                     m_axisXInitialized=false;
                     emit axisRemoved(axisX());
                 }
             }
             void ChartDataSet::removeAllSeries()
             {
                 QList<QSeries*> series =  m_seriesAxisMap.keys();
                 foreach(QSeries* s , series) {
                     removeSeries(s);
                 }
                 Q_ASSERT(m_seriesAxisMap.count()==0);
                 Q_ASSERT(m_axisDomainMap.count()==0);
             }
             //to be removed with PIMPL
             void ChartDataSet::calculateDomain(QSeries* series,Domain* domain) const
             {
                 switch(series->type())
                 {
                     case QSeries::SeriesTypeLine:
                     case QSeries::SeriesTypeSpline:
                     case QSeries::SeriesTypeScatter:
                     {
                         QXYSeries* xySeries = static_cast<QXYSeries*>(series);
                         qreal minX(domain->minX());
                         qreal minY(domain->minY());
                         qreal maxX(domain->maxX());
                         qreal maxY(domain->maxY());
                         for (int i = 0; i < xySeries->count(); i++)
                         {
                             qreal x = xySeries->x(i);
                             qreal y = xySeries->y(i);
                             minX = qMin(minX, x);
                             minY = qMin(minY, y);
                             maxX = qMax(maxX, x);
                             maxY = qMax(maxY, y);
                         }
                         domain->setRange(minX, maxX,  minY,  maxY);
                         break;
                     }
                     case QSeries::SeriesTypeArea: {
                         QAreaSeries* areaSeries = static_cast<QAreaSeries*>(series);
                         QLineSeries* upperSeries = areaSeries->upperSeries();
                         QLineSeries* lowerSeries = areaSeries->lowerSeries();
                         for (int i = 0; i < upperSeries->count(); i++)
                         {
                             qreal x = upperSeries->x(i);
                             qreal y = upperSeries->y(i);
                             domain->setMinX(qMin(domain->minX(),x));
                             domain->setMinY(qMin(domain->minY(),y));
                             domain->setMaxX(qMax(domain->maxX(),x));
                             domain->setMaxY(qMax(domain->maxY(),y));
                         }
                         if(lowerSeries) {
                             for (int i = 0; i < lowerSeries->count(); i++)
                             {
                                 qreal x = lowerSeries->x(i);
                                 qreal y = lowerSeries->y(i);
                                 domain->setMinX(qMin(domain->minX(),x));
                                 domain->setMinY(qMin(domain->minY(),y));
                                 domain->setMaxX(qMax(domain->maxX(),x));
                                 domain->setMaxY(qMax(domain->maxY(),y));
                             }}
                         break;
                     }
                     case QSeries::SeriesTypeBar: {
                         qDebug() << "QChartSeries::SeriesTypeBar";
                         QBarSeries* barSeries = static_cast<QBarSeries*>(series);
                         qreal x = barSeries->categoryCount();
                         qreal y = barSeries->max();
                         domain->setMinX(qMin(domain->minX(),x));
                         domain->setMinY(qMin(domain->minY(),y));
                         domain->setMaxX(qMax(domain->maxX(),x));
                         domain->setMaxY(qMax(domain->maxY(),y));
                         break;
                     }
                     case QSeries::SeriesTypeStackedBar: {
                         qDebug() << "QChartSeries::SeriesTypeStackedBar";
                         QStackedBarSeries* stackedBarSeries = static_cast<QStackedBarSeries*>(series);
                         qreal x = stackedBarSeries->categoryCount();
                         qreal y = stackedBarSeries->maxCategorySum();
                         domain->setMinX(qMin(domain->minX(),x));
                         domain->setMinY(qMin(domain->minY(),y));
                         domain->setMaxX(qMax(domain->maxX(),x));
                         domain->setMaxY(qMax(domain->maxY(),y));
                         break;
                     }
                     case QSeries::SeriesTypePercentBar: {
                         qDebug() << "QChartSeries::SeriesTypePercentBar";
                         QPercentBarSeries* percentBarSeries = static_cast<QPercentBarSeries*>(series);
                         qreal x = percentBarSeries->categoryCount();
                         domain->setMinX(qMin(domain->minX(),x));
                         domain->setMinY(0);
                         domain->setMaxX(qMax(domain->maxX(),x));
                         domain->setMaxY(100);
                         break;
                     }
                     case QSeries::SeriesTypePie: {
                         QPieSeries *pieSeries = static_cast<QPieSeries *>(series);
                         // TODO: domain stuff
                         break;
                     }
                     default: {
                         qDebug()<<__FUNCTION__<<"type" << series->type()<<"not supported";
                         return;
                         break;
                     }
                 }
             }
             void ChartDataSet::zoomInDomain(const QRectF& rect, const QSizeF& size)
             {
                 QMapIterator<QChartAxis*, Domain*> i( m_axisDomainMap);
                 while (i.hasNext()) {
                     i.next();
                     i.value()->zoomIn(rect,size);
                 }
             }
             void ChartDataSet::zoomOutDomain(const QRectF& rect, const QSizeF& size)
             {
                 QMapIterator<QChartAxis*, Domain*> i( m_axisDomainMap);
                 while (i.hasNext()) {
                     i.next();
                     i.value()->zoomOut(rect,size);
                 }
             }
             int ChartDataSet::seriesCount(QSeries::QSeriesType type)
             {
                 int count=0;
                 QMapIterator<QSeries*, QChartAxis*> i( m_seriesAxisMap);
                 while (i.hasNext()) {
                        i.next();
                        if(i.key()->type()==type) count++;
                 }
                 return count;
             }
             int ChartDataSet::seriesIndex(QSeries *series)
             {
                 int count(-1);
                 QMapIterator<QSeries*, QChartAxis*> i(m_seriesAxisMap);
                 while (i.hasNext()) {
                     i.next();
                     count++;
                     if (i.key() == series)
                         return count;
                 }
                 return count;
             }
             QChartAxis* ChartDataSet::axisY(QSeries* series) const
             {
                 if(series == 0) return m_axisY;
                 return m_seriesAxisMap.value(series);
             }
             Domain* ChartDataSet::domain(QSeries* series) const
             {
             	QChartAxis* axis = m_seriesAxisMap.value(series);
             	if(axis){
             		return m_axisDomainMap.value(axis);
             	}else
             		return 0;
             }
             Domain* ChartDataSet::domain(QChartAxis* axis) const
             {
                 if(axis==axisX()) {
                     return  m_axisDomainMap.value(axisY());
                 }
                 else {
                     return m_axisDomainMap.value(axis);
                 }
             }
             QChartAxis* ChartDataSet::axis(QSeries* series) const
             {
             	return m_seriesAxisMap.value(series);
             }
             void ChartDataSet::scrollDomain(int dx,int dy,const QSizeF& size)
             {
             	 QMapIterator<QChartAxis*, Domain*> i( m_axisDomainMap);
             	 	while (i.hasNext()) {
             	        i.next();
             	        i.value()->move(dx,dy,size);
             	    }
             }
             #include "moc_chartdataset_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/domain.cpp +22 -13

             #include "domain_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             Domain::Domain(QObject* parent):QObject(parent),
             m_minX(0),
             m_maxX(0),
             m_minY(0),
             m_maxY(0),
             m_tickXCount(5),
             m_tickYCount(5)
             {
             }
             Domain::~Domain()
             {
             }
             void Domain::setRange(qreal minX, qreal maxX, qreal minY, qreal maxY)
             {
-            	setRange(minX, maxX, minY, maxY, m_tickXCount, m_tickYCount);
-            void Domain::setRange(qreal minX, qreal maxX, qreal minY, qreal maxY, int tickXCount,int tickYCount)
             	bool changed = false;
-            	if(m_minX!=minX || m_maxX!=maxX || m_tickXCount!=tickXCount)
+            	if(m_minX!=minX || m_maxX!=maxX)
             	{
             		 m_minX=minX;
             		 m_maxX=maxX;
-            		 m_tickXCount=tickXCount;
             		 changed=true;
             		 emit rangeXChanged(minX,maxX, m_tickXCount);
             	}
-            	if(m_minY!=minY || m_maxY!=maxY || m_tickYCount!=tickYCount){
+            	if(m_minY!=minY || m_maxY!=maxY){
             		 m_minY=minY;
             		 m_maxY=maxY;
-            		 m_tickYCount=tickYCount;
             		 changed=true;
             		 emit rangeYChanged(minY,maxY, m_tickYCount);
             	}
               if(changed){
                 emit domainChanged(m_minX, m_maxX, m_minY, m_maxY);
               }
             }
             void Domain::setRangeX(qreal min, qreal max)
             {
                 setRange(min,max,m_minY, m_maxY);
             }
             void Domain::setRangeY(qreal min, qreal max)
             {
             	setRange(m_minX, m_maxX, min, max);
             }
             void Domain::setMinX(qreal min)
             {
             	setRange(min, m_maxX, m_minY, m_maxY);
             }
             void Domain::setMaxX(qreal max)
             {
             	setRange(m_minX, max, m_minY, m_maxY);
             }
             void Domain::setMinY(qreal min)
             {
             	setRange(m_minX, m_maxX, min, m_maxY);
             }
             void Domain::setMaxY(qreal max)
             {
                 setRange(m_minX, m_maxX, m_minY, max);
             }
             qreal Domain::spanX() const
             {
                 Q_ASSERT(m_maxX >= m_minX);
                 return m_maxX - m_minX;
             }
             qreal Domain::spanY() const
             {
                 Q_ASSERT(m_maxY >= m_minY);
                 return m_maxY - m_minY;
             }
             bool Domain::isEmpty() const
             {
                 return spanX()==0 || spanY()==0;
             }
             void Domain::zoomIn(const QRectF& rect, const QSizeF& size)
             {
                 qreal dx = spanX() / size.width();
                 qreal dy = spanY() / size.height();
                 m_maxX = m_minX + dx * rect.right();
                 m_minX = m_minX + dx * rect.left();
                 m_minY = m_maxY - dy * rect.bottom();
                 m_maxY = m_maxY - dy * rect.top();
                 emit domainChanged(m_minX, m_maxX, m_minY, m_maxY);
                 emit rangeXChanged(m_minX, m_maxX, m_tickXCount);
                 emit rangeYChanged(m_minY, m_maxY, m_tickYCount);
             }
             void Domain::zoomOut(const QRectF& rect, const QSizeF& size)
             {
                 qreal dx = spanX() / rect.width();
                 qreal dy = spanY() / rect.height();
                 m_minX = m_maxX - dx * rect.right();
                 m_maxX = m_minX + dx * size.width();
                 m_maxY = m_minY + dy * rect.bottom();
                 m_minY = m_maxY - dy * size.height();
                 emit domainChanged(m_minX, m_maxX, m_minY, m_maxY);
                 emit rangeXChanged(m_minX, m_maxX, m_tickXCount);
                 emit rangeYChanged(m_minY, m_maxY, m_tickYCount);
             }
             void Domain::move(int dx,int dy,const QSizeF& size)
             {
                 qreal x = spanX() / size.width();
                 qreal y = spanY() / size.height();
                 if(dx!=0){
                 m_minX = m_minX + x * dx;
                 m_maxX = m_maxX + x * dx;
                 emit rangeXChanged(m_minX, m_maxX, m_tickXCount);
                 }
                 if(dy!=0){
                 m_minY = m_minY + y * dy;
                 m_maxY = m_maxY + y * dy;
                 emit rangeYChanged(m_minY, m_maxY, m_tickYCount);
                 }
                 emit domainChanged(m_minX, m_maxX, m_minY, m_maxY);
             }
-            void Domain::handleAxisRangeXChanged(qreal min,qreal max,int tickCount)
+            void Domain::handleAxisRangeXChanged(qreal min,qreal max)
+            {
+            	 setRange(min,max,m_minY, m_maxY);
+            }
+            void Domain::handleAxisRangeYChanged(qreal min,qreal max)
             {
-            	 setRange(min,max,m_minY, m_maxY,tickCount,m_tickYCount);
+            	 setRange(m_minX, m_maxX, min, max);
             }
-            void Domain::handleAxisRangeYChanged(qreal min,qreal max,int tickCount)
+            void Domain::handleAxisXTicksCountChanged(int tickCount)
             {
-            	 setRange(m_minX, m_maxX, min, max,m_tickXCount, tickCount);
+                if(m_tickXCount!=tickCount){
+                    m_tickXCount=tickCount;
+                    emit rangeXChanged(m_minX,m_maxX, m_tickXCount);
+                }
+            }
+            void Domain::handleAxisYTicksCountChanged(int tickCount)
+            {
+                if(m_tickYCount!=tickCount){
+                    m_tickYCount=tickCount;
+                    emit rangeYChanged(m_minY,m_maxY, m_tickYCount);
+                }
             }
             bool operator== (const Domain &domain1, const Domain &domain2)
             {
                 return (domain1.m_maxX == domain2.m_maxX &&
                     domain1.m_maxY == domain2.m_maxY &&
                     domain1.m_minX == domain2.m_minX &&
                     domain1.m_minY == domain2.m_minY);
             }
             bool operator!= (const Domain &domain1, const Domain &domain2)
             {
                 return !(domain1 == domain2);
             }
             QDebug operator<<(QDebug dbg, const Domain &domain)
             {
                 dbg.nospace() << "Domain("<<domain.m_minX<<','<<domain.m_maxX<<','<<domain.m_minY<<','<<domain.m_maxY<<')';
                 return dbg.maybeSpace();
             }
             #include "moc_domain_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/domain_p.h +4 -3

             #ifndef DOMAIN_H_
             #define DOMAIN_H_
             #include "qchartglobal.h"
             #include <QRectF>
             #include <QSizeF>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class Domain: public QObject {
                 Q_OBJECT
             public:
                 explicit Domain(QObject* object=0);
                 virtual ~Domain();
                 void setRange(qreal minX, qreal maxX, qreal minY, qreal maxY);
-                void setRange(qreal minX, qreal maxX, qreal minY, qreal maxY,int tickXCount,int tickYCount);
                 void setRangeX(qreal min, qreal max);
                 void setRangeY(qreal min, qreal max);
                 void setMinX(qreal min);
                 void setMaxX(qreal max);
                 void setMinY(qreal min);
                 void setMaxY(qreal max);
                 qreal minX() const {return m_minX;};
                 qreal maxX() const {return m_maxX;};
                 qreal minY() const {return m_minY;};
                 qreal maxY() const {return m_maxY;};
                 qreal spanX() const;
                 qreal spanY() const;
                 bool isEmpty() const;
                 int tickXCount() const {return m_tickXCount;}
                 int tickYCount() const {return m_tickYCount;}
                 friend bool operator== (const Domain &domain1, const Domain &domain2);
                 friend bool operator!= (const Domain &domain1, const Domain &domain2);
                 friend QDebug operator<<(QDebug dbg, const Domain &domain);
                 void zoomIn(const QRectF& rect, const QSizeF& size);
                 void zoomOut(const QRectF& rect, const QSizeF& size);
                 void move(int dx,int dy,const QSizeF& size);
             signals:
                 void domainChanged(qreal minX, qreal maxX, qreal minY, qreal maxY);
                 void rangeXChanged(qreal min, qreal max, int tickXCount);
                 void rangeYChanged(qreal min, qreal max, int tickYCount);
             public slots:
-            	void handleAxisRangeXChanged(qreal min,qreal max,int tickCount);
+                void handleAxisRangeXChanged(qreal min,qreal max);
-            	void handleAxisRangeYChanged(qreal min,qreal max,int tickCount);
+                void handleAxisRangeYChanged(qreal min,qreal max);
+                void handleAxisXTicksCountChanged(int tickCount);
+                void handleAxisYTicksCountChanged(int tickCount);
             private:
                 qreal m_minX;
                 qreal m_maxX;
                 qreal m_minY;
                 qreal m_maxY;
                 int m_tickXCount;
                 int m_tickYCount;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

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