HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r223:c82178b4ef05

Refactors axis handling...

Michal Klocek -

r223:c82178b4ef05

parent child

Context file:

r223:c82178b4ef05

Collapse all files

src/axisitem.cpp +41 -62

             #include "axisitem_p.h"
             #include "qchartaxis.h"
             #include <QPainter>
             #include <QDebug>
             static int label_padding = 5;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             AxisItem::AxisItem(AxisType type,QGraphicsItem* parent) :
             ChartItem(parent),
-            m_ticks(4),
             m_type(type),
             m_labelsAngle(0),
             m_shadesEnabled(true),
             m_grid(parent),
             m_shades(parent),
             m_labels(parent)
             {
                 //initial initialization
                 m_shades.setZValue(0);
                 m_grid.setZValue(2);
-                createItems();
             }
             AxisItem::~AxisItem()
             {
             }
             QRectF AxisItem::boundingRect() const
             {
                 return m_rect;
             }
-            void AxisItem::createItems()
+            void AxisItem::createItems(int count)
             {
-                for (int i = 0; i <= m_ticks; ++i) {
+                for (int i = 0; i < count; ++i) {
                        m_grid.addToGroup(new QGraphicsLineItem(this));
                        m_labels.addToGroup(new QGraphicsSimpleTextItem(this));
                        if(i%2) m_shades.addToGroup(new QGraphicsRectItem(this));
                    }
             }
             void AxisItem::clear()
             {
                 foreach(QGraphicsItem* item , m_shades.childItems()) {
                     delete item;
                 }
                 foreach(QGraphicsItem* item , m_grid.childItems()) {
                     delete item;
                 }
                 foreach(QGraphicsItem* item , m_labels.childItems()) {
                     delete item;
                 }
+                m_thicksList.clear();
             }
             void AxisItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
             }
-            void AxisItem::updateDomain()
+            void AxisItem::updateItem(int count)
             {
                 QList<QGraphicsItem *> lines = m_grid.childItems();
                 QList<QGraphicsItem *> labels = m_labels.childItems();
                 QList<QGraphicsItem *> shades = m_shades.childItems();
                 switch (m_type)
                   {
                       case X_AXIS:
                       {
-                          const qreal deltaX = m_rect.width() / m_ticks;
+                          const qreal deltaX = m_rect.width() / (count-1);
                           m_axis.setLine(m_rect.left(), m_rect.bottom(), m_rect.right(), m_rect.bottom());
-                          for (int i = 0; i <= m_ticks; ++i) {
+                          for (int i = 0; i < count; ++i) {
                               int x = i * deltaX + m_rect.left();
-                              qreal label = m_domain.m_minX + (i * m_domain.spanX()/ m_ticks);
                               QGraphicsLineItem *lineItem =  static_cast<QGraphicsLineItem*>(lines.at(i));
                               lineItem->setLine(x, m_rect.top(), x, m_rect.bottom());
                               QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem*>(labels.at(i));
-                              labelItem->setText(QString::number(label));
+                              labelItem->setText(m_thicksList.at(i));
                               QPointF center = labelItem->boundingRect().center();
                               labelItem->setTransformOriginPoint(center.x(), center.y());
                               labelItem->setPos(x - center.x(), m_rect.bottom() + label_padding);
                               if(i%2){
                                   QGraphicsRectItem *rectItem =  static_cast<QGraphicsRectItem*>(shades.at(i/2));
                                   rectItem->setRect(x,m_rect.top(),deltaX,m_rect.height());
                                   rectItem->setOpacity( 0.5 );
                               }
                           }
                       }
                       break;
                       case Y_AXIS:
                       {
-                          const qreal deltaY = m_rect.height()/ m_ticks;
+                          const qreal deltaY = m_rect.height()/ (count-1);
                           m_axis.setLine(m_rect.left() , m_rect.top(), m_rect.left(), m_rect.bottom());
-                          for (int i = 0; i <= m_ticks; ++i) {
+                          for (int i = 0; i < count; ++i) {
                               int y = i * -deltaY + m_rect.bottom();
-                              qreal label = m_domain.m_minY + (i * m_domain.spanY()/ m_ticks);
                               QGraphicsLineItem *lineItem =  static_cast<QGraphicsLineItem*>(lines.at(i));
                               lineItem->setLine(m_rect.left() , y, m_rect.right(), y);
                               QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem*>(labels.at(i));
-                              labelItem->setText(QString::number(label));
+                              labelItem->setText(m_thicksList.at(i));
                               QPointF center = labelItem->boundingRect().center();
                               labelItem->setTransformOriginPoint(center.x(), center.y());
                               labelItem->setPos(m_rect.left() -  labelItem->boundingRect().width() - label_padding , y-center.y());
                               if(i%2){
                                   QGraphicsRectItem *rectItem =  static_cast<QGraphicsRectItem*>(shades.at(i/2));
                                   rectItem->setRect(m_rect.left(),y,m_rect.width(),deltaY);
                               }
                           }
                       }
                       break;
                       default:
                       qDebug()<<"Unknown axis type";
                       break;
                   }
             }
-            void AxisItem::handleAxisChanged(const QChartAxis& axis)
+            void AxisItem::handleAxisUpdate(QChartAxis* axis)
             {
-                if(axis.isAxisVisible()) {
+                if(axis->isAxisVisible()) {
                     setAxisOpacity(100);
                 }
                 else {
                     setAxisOpacity(0);
                 }
-                if(axis.isGridVisible()) {
+                if(axis->isGridVisible()) {
                     setGridOpacity(100);
                 }
                 else {
                     setGridOpacity(0);
                 }
-                if(axis.isLabelsVisible())
+                if(axis->isLabelsVisible())
                 {
                     setLabelsOpacity(100);
                 }
                 else {
                     setLabelsOpacity(0);
                 }
-                if(axis.isShadesVisible()) {
+                if(axis->isShadesVisible()) {
-                    setShadesOpacity(axis.shadesOpacity());
+                    setShadesOpacity(axis->shadesOpacity());
                 }
                 else {
                     setShadesOpacity(0);
                 }
-                switch(axis.labelsOrientation())
+                setLabelsAngle(axis->labelsAngle());
+                setAxisPen(axis->axisPen());
+                setLabelsPen(axis->labelsPen());
+                setLabelsBrush(axis->labelsBrush());
+                setLabelsFont(axis->labelFont());
+                setGridPen(axis->gridPen());
+                setShadesPen(axis->shadesPen());
+                setShadesBrush(axis->shadesBrush());
+            }
+            void AxisItem::handleLabelsChanged(const QStringList& labels)
             {
-                    case QChartAxis::LabelsOrientationHorizontal:
+                m_thicksList=labels;
-                        setLabelsAngle(0);
+                QList<QGraphicsItem*> items = m_labels.childItems();
-                        break;
+                if(items.size()!=m_thicksList.size()){
-                    case QChartAxis::LabelsOrientationVertical:
+                   clear();
-                        setLabelsAngle(90);
+                   m_thicksList=labels;
-                        break;
+                   createItems(m_thicksList.size());
-                    case QChartAxis::LabelsOrientationSlide:
+                   items = m_labels.childItems();
-                        setLabelsAngle(-45);
-                        break;
-                    default:
-                        break;
                  }
-                setAxisPen(axis.axisPen());
+                Q_ASSERT(items.size()==m_thicksList.size());
-                setLabelsPen(axis.labelsPen());
-                setLabelsBrush(axis.labelsBrush());
-                setLabelsFont(axis.labelFont());
-                setGridPen(axis.gridPen());
-                setShadesPen(axis.shadesPen());
-                setShadesBrush(axis.shadesBrush());
+                int i=0;
+                foreach(QGraphicsItem* item, items){
+                    static_cast<QGraphicsSimpleTextItem*>(item)->setText(m_thicksList.at(i));
+                    i++;
                 }
-            void AxisItem::handleDomainChanged(const Domain& domain)
-                m_domain = domain;
-                updateDomain();
                 update();
             }
             void AxisItem::handleGeometryChanged(const QRectF& rect)
             {
                 m_rect = rect;
-                updateDomain();
+                updateItem(m_thicksList.size());
                 update();
             }
             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)
             {
                 m_axis.setPen(pen);
             }
             void AxisItem::setGridPen(const QPen& pen)
             {
                 foreach(QGraphicsItem* item , m_grid.childItems()) {
                     static_cast<QGraphicsLineItem*>(item)->setPen(pen);
                 }
             }
-            void AxisItem::setTicks(int count)
-                if(count!=m_ticks){
-                clear();
-                m_ticks=count;
-                createItems();
             //TODO "nice numbers algorithm"
             #include "moc_axisitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/axisitem_p.h +5 -9

             #ifndef AXISITEM_H_
             #define AXISITEM_H_
             #include "domain_p.h"
             #include "chartitem_p.h"
             #include <QGraphicsItem>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QChartAxis;
             class AxisItem : public QObject, public ChartItem
             {
                 Q_OBJECT
             public:
                 enum AxisType{X_AXIS,Y_AXIS};
                 AxisItem(AxisType type = X_AXIS,QGraphicsItem* parent = 0);
                 ~AxisItem();
                 //from QGraphicsItem
                 QRectF boundingRect() const;
                 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
                 AxisType axisType() const {return m_type;};
                 void setAxisOpacity(qreal opacity);
                 qreal axisOpacity() const;
                 void setGridOpacity(qreal opacity);
                 qreal gridOpacity() const;
                 void setLabelsOpacity(qreal opacity);
                 qreal labelsOpacity() const;
                 void setShadesOpacity(qreal opacity);
                 qreal shadesOpacity() const;
                 void setLabelsAngle(int angle);
                 int labelsAngle()const { return m_labelsAngle; }
-                void setTicks(int count);
-                int ticks() const { return m_ticks;}
                 void setShadesBrush(const QBrush& brush);
                 void setShadesPen(const QPen& pen);
                 void setAxisPen(const QPen& pen);
                 void setGridPen(const QPen& pen);
                 void setLabelsPen(const QPen& pen);
                 void setLabelsBrush(const QBrush& brush);
                 void setLabelsFont(const QFont& font);
             public slots:
-                void handleAxisChanged(const QChartAxis& axis);
+                void handleAxisUpdate(QChartAxis* axis);
-                void handleDomainChanged(const Domain& domain);
+                void handleLabelsChanged(const QStringList& labels);
                 void handleGeometryChanged(const QRectF& size);
             protected:
-                void updateDomain();
+                void updateItem(int count);
             private:
                 void clear();
-                void createItems();
+                void createItems(int count);
             private:
                 AxisType m_type;
-                int m_ticks;
-                Domain m_domain;
                 QRectF m_rect;
                 int m_labelsAngle;
                 bool m_shadesEnabled;
                 QGraphicsItemGroup m_grid;
                 QGraphicsItemGroup m_shades;
                 QGraphicsItemGroup m_labels;
                 QGraphicsLineItem m_axis;
+                QStringList m_thicksList;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif /* AXISITEM_H_ */

src/chartdataset.cpp +192 -22

             #include "chartdataset_p.h"
+            #include "qchartaxis.h"
             //series
             #include "qlinechartseries.h"
             #include "qbarchartseries.h"
             #include "qstackedbarchartseries.h"
             #include "qpercentbarchartseries.h"
             #include "qpieseries.h"
             #include "qscatterseries.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            ChartDataSet::ChartDataSet(QObject *parent):QObject(parent)
+            ChartDataSet::ChartDataSet(QObject *parent):QObject(parent),
+            m_axisX(new QChartAxis(this)),
+            m_axisY(new QChartAxis(this)),
+            m_domainIndex(0),
+            m_axisXInitialized(false)
             {
-                Domain domain;
-                m_domains<<domain;
             }
             ChartDataSet::~ChartDataSet()
             {
                 // TODO Auto-generated destructor stub
             }
-            const Domain& ChartDataSet::domain() const
+            const Domain ChartDataSet::domain(QChartAxis *axisY) const
             {
-                return m_domains[m_domainIndex];
+            	int i = m_domainMap.count(axisY);
+            	if(i == 0){
+            		return Domain();
+            	}
+            	i = i - m_domainIndex -1;
+                return m_domainMap.values(axisY).at(i);
             }
-            void ChartDataSet::addSeries(QChartSeries* series)
+            void ChartDataSet::addSeries(QChartSeries* series, QChartAxis *axisY)
             {
                 // TODO: we should check the series not already added
-                m_chartSeries << series;
                 series->setParent(this); // take ownership
-                m_domainIndex = 0;
-                m_domains.resize(1);
-                Domain& domain = m_domains[m_domainIndex];
+                clearDomains();
+                if(axisY==0) axisY = m_axisY;
+                QList<QChartSeries*>  seriesList = m_seriesMap.values(axisY);
+                QList<Domain> domainList = m_domainMap.values(axisY);
+                Q_ASSERT(domainList.size()<=1);
+                Domain domain;
+                if(domainList.size()>0) domain = domainList.at(0);
                 switch(series->type())
                 {
                     case QChartSeries::SeriesTypeLine: {
                         QLineChartSeries* xyseries = static_cast<QLineChartSeries*>(series);
                         for (int i = 0; i < xyseries->count(); i++)
                         {
                             qreal x = xyseries->x(i);
                             qreal y = xyseries->y(i);
                             domain.m_minX = qMin(domain.m_minX,x);
                             domain.m_minY = qMin(domain.m_minY,y);
                             domain.m_maxX = qMax(domain.m_maxX,x);
                             domain.m_maxY = qMax(domain.m_maxY,y);
                         }
                         break;
                     }
                     case QChartSeries::SeriesTypeBar: {
                     qDebug() << "QChartSeries::SeriesTypeBar";
                         QBarChartSeries* barSeries = static_cast<QBarChartSeries*>(series);
                         qreal x = barSeries->countCategories();
                         qreal y = barSeries->max();
                         domain.m_minX = qMin(domain.m_minX,x);
                         domain.m_minY = qMin(domain.m_minY,y);
                         domain.m_maxX = qMax(domain.m_maxX,x);
                         domain.m_maxY = qMax(domain.m_maxY,y);
                         break;
                     }
                     case QChartSeries::SeriesTypeStackedBar: {
                     qDebug() << "QChartSeries::SeriesTypeStackedBar";
                         QStackedBarChartSeries* stackedBarSeries = static_cast<QStackedBarChartSeries*>(series);
                         qreal x = stackedBarSeries->countCategories();
                         qreal y = stackedBarSeries->maxCategorySum();
                         domain.m_minX = qMin(domain.m_minX,x);
                         domain.m_minY = qMin(domain.m_minY,y);
                         domain.m_maxX = qMax(domain.m_maxX,x);
                         domain.m_maxY = qMax(domain.m_maxY,y);
                         break;
                     }
                     case QChartSeries::SeriesTypePercentBar: {
                     qDebug() << "QChartSeries::SeriesTypePercentBar";
                         QPercentBarChartSeries* percentBarSeries = static_cast<QPercentBarChartSeries*>(series);
                         qreal x = percentBarSeries->countCategories();
                         domain.m_minX = qMin(domain.m_minX,x);
                         domain.m_minY = 0;
                         domain.m_maxX = qMax(domain.m_maxX,x);
                         domain.m_maxY = 100;
                         break;
                     }
                     case QChartSeries::SeriesTypePie: {
                         QPieSeries *pieSeries = static_cast<QPieSeries *>(series);
                         // TODO: domain stuff
                         break;
                     }
                     case QChartSeries::SeriesTypeScatter: {
                         QScatterSeries *scatterSeries = qobject_cast<QScatterSeries *>(series);
                         Q_ASSERT(scatterSeries);
                         foreach (QPointF point, scatterSeries->data()) {
                             domain.m_minX = qMin(domain.m_minX, point.x());
                             domain.m_maxX = qMax(domain.m_maxX, point.x());
                             domain.m_minY = qMin(domain.m_minY, point.y());
                             domain.m_maxY = qMax(domain.m_maxY, point.y());
                         }
                         break;
                     }
                     default: {
                         qDebug()<<__FUNCTION__<<"type" << series->type()<<"not supported";
                         return;
                         break;
                     }
                 }
+                if(!m_domainMap.contains(axisY))
+                {
+                    emit axisAdded(axisY);
+                    QObject::connect(axisY,SIGNAL(minChanged(qreal)),this,SLOT(handleMinChanged(qreal)));
+                    QObject::connect(axisY,SIGNAL(maxChanged(qreal)),this,SLOT(handleMaxChanged(qreal)));
+                    QObject::connect(axisY,SIGNAL(ticksChanged(QChartAxis*)),this,SLOT(handleTickChanged(QChartAxis*)));
+                }
+                m_domainMap.replace(axisY,domain);
+                m_seriesMap.insert(axisY,series);
+                if(!m_axisXInitialized)
+                {
+                    emit axisAdded(axisX());
+                    QObject::connect(axisX(),SIGNAL(minChanged(qreal)),this,SLOT(handleMinChanged(qreal)));
+                    QObject::connect(axisX(),SIGNAL(maxChanged(qreal)),this,SLOT(handleMaxChanged(qreal)));
+                    QObject::connect(axisX(),SIGNAL(ticksChanged(QChartAxis*)),this,SLOT(handleTickChanged(QChartAxis*)));
+                    m_axisXInitialized=true;
+                }
                 emit seriesAdded(series);
-                emit domainChanged(domain);
+                QStringList ylabels = createLabels(axisY,domain.m_minY,domain.m_maxY);
+                QStringList xlabels = createLabels(axisX(),domain.m_minX,domain.m_maxX);
+                emit axisLabelsChanged(axisY,ylabels);
+                emit axisLabelsChanged(axisX(),xlabels);
+                emit seriesDomainChanged(series,domain);
+            }
+            void ChartDataSet::removeSeries(QChartSeries* series)
+            {
+                QList<QChartAxis*> keys = m_seriesMap.uniqueKeys();
+                foreach(QChartAxis* axis , keys) {
+                    if(m_seriesMap.contains(axis,series)){
+                        emit seriesRemoved(series);
+                        m_seriesMap.remove(axis,series);
+                        //remove axis if no longer there
+                        if(!m_seriesMap.contains(axis) && axis != m_axisY){
+                            emit axisRemoved(axis);
+                            m_domainMap.remove(axis);
+                            delete axis;
+                        }
+                        break;
+                    }
+                }
             }
             bool ChartDataSet::nextDomain()
             {
-                if (m_domainIndex < m_domains.count() - 1) {
+                int limit = (m_domainMap.values().size()/m_domainMap.uniqueKeys().size())-1;
+                if (m_domainIndex < limit) {
                     m_domainIndex++;
-                    emit domainChanged(m_domains[m_domainIndex]);
+                    setDomain(m_domainIndex);
                     return true;
                 }
                 else {
                     return false;
                 }
             }
             bool ChartDataSet::previousDomain()
             {
                 if (m_domainIndex > 0) {
                     m_domainIndex--;
-                    emit domainChanged(m_domains[m_domainIndex]);
+                    setDomain(m_domainIndex);
                     return true;
                 }
                 else {
                     return false;
                 }
             }
-            void ChartDataSet::clearDomains()
+            void ChartDataSet::setDomain(int index)
             {
-                if (m_domainIndex > 0) {
+                QList<QChartAxis*> domainList = m_domainMap.uniqueKeys();
-                    m_domainIndex = 0;
+                foreach (QChartAxis* axis , domainList) {
-                    emit domainChanged(m_domains[m_domainIndex]);
+                    int i = m_domainMap.count(axis) - index -1;
+                    Q_ASSERT(i>=0);
+                    Domain domain = m_domainMap.values(axis).at(i);
+                    QStringList labels = createLabels(axis,domain.m_minY,domain.m_maxY);
+                    QList<QChartSeries*> seriesList = m_seriesMap.values(axis);
+                    foreach(QChartSeries* series, seriesList) {
+                        emit seriesDomainChanged(series,domain);
+                    }
+                    emit axisLabelsChanged(axis,labels);
                 }
+                Domain domain = m_domainMap.value(axisY());
+                QStringList labels = createLabels(axisX(),domain.m_minX,domain.m_maxX);
+                emit axisLabelsChanged(axisX(),labels);
             }
-            void ChartDataSet::addDomain(const Domain& domain)
+            void ChartDataSet::clearDomains(int toIndex)
+            {
+                Q_ASSERT(toIndex>=0);
+                m_domainIndex = toIndex;
+                QList<QChartAxis*> keys = m_domainMap.uniqueKeys();
+                foreach (QChartAxis* key , keys)
                 {
-                m_domains.resize(m_domainIndex + 1);
+                    QList<Domain> domains = m_domainMap.values(key);
-                m_domains << domain;
+                    m_domainMap.remove(key);
+                    int i = domains.size() - toIndex - 1;
+                    while(i--){
+                        domains.removeFirst();
+                    }
+                    for(int j=domains.size()-1; j>=0 ;j--)
+                        m_domainMap.insert(key,domains.at(j));
+                }
+            }
+            void ChartDataSet::addDomain(const QRectF& rect, const QRectF& viewport)
+            {
+                Q_ASSERT(rect.isValid());
+                Q_ASSERT(viewport.isValid());
+                clearDomains(m_domainIndex);
+                QList<QChartAxis*> domainList = m_domainMap.uniqueKeys();
+                foreach (QChartAxis* axis , domainList){
+                    Domain domain(m_domainMap.value(axis).subDomain(rect,viewport.width(),viewport.height()));
+                    QStringList labels = createLabels(axis,domain.m_minY,domain.m_maxY);
+                    QList<QChartSeries*> seriesList = m_seriesMap.values(axis);
+                    foreach(QChartSeries* series, seriesList){
+                        emit seriesDomainChanged(series,domain);
+                    }
+                    emit axisLabelsChanged(axis,labels);
+                    m_domainMap.insert(axis,domain);
+                }
+                Domain domain = m_domainMap.value(axisY());
+                QStringList labels = createLabels(axisX(),domain.m_minX,domain.m_maxX);
+                emit axisLabelsChanged(axisX(),labels);
                 m_domainIndex++;
+            }
+            QChartAxis* ChartDataSet::axisY(QChartSeries* series) const
+            {
+                if(series == 0) return m_axisY;
+                QList<QChartAxis*> keys = m_seriesMap.uniqueKeys();
+                foreach(QChartAxis* axis , keys) {
+                    if(m_seriesMap.contains(axis,series)){
+                        return axis;
+                    }
+                }
+                return 0;
+            }
+            QStringList ChartDataSet::createLabels(QChartAxis* axis,qreal min, qreal max)
+            {
+                Q_ASSERT(max>=min);
-                emit domainChanged(domain);
+                QStringList labels;
+                int ticks = axis->ticksCount();
+                for(int i=0; i<= ticks; i++){
+                    qreal value = min + (i * (max - min)/ ticks);
+                    QString label = axis->axisTickLabel(value);
+                    if(label.isEmpty()){
+                        labels << QString::number(value);
+                    }else{
+                        labels << label;
+                    }
+                }
+                return labels;
+            }
+            void ChartDataSet::handleMinChanged(qreal min)
+            {
+            }
+            void ChartDataSet::handleMaxChanged(qreal max)
+            {
+            }
+            void ChartDataSet::handleTickChanged(QChartAxis* axis)
+            {
+                Domain domain = m_domainMap.value(axisY());
+                if(axis==axisX()){
+                    QStringList labels = createLabels(axis,domain.m_minX,domain.m_maxX);
+                    emit axisLabelsChanged(axis,labels);
+                }else{
+                    QStringList labels = createLabels(axis,domain.m_minY,domain.m_maxY);
+                    emit axisLabelsChanged(axis,labels);
+                }
             }
             #include "moc_chartdataset_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/chartdataset_p.h +33 -10

-            #ifndef CHARTENGINE_P_H_
+            #ifndef CHARTDATASET_P_H_
-            #define CHARTENGINE_P_H_
+            #define CHARTDATASET_P_H_
-            #include <qchartseries.h>
+            #include "qchartseries.h"
             #include "domain_p.h"
             #include <QVector>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
+            class QChartAxis;
             class ChartDataSet : public QObject
             {
                 Q_OBJECT
             public:
                 ChartDataSet(QObject* parent=0);
                 virtual ~ChartDataSet();
-                void addSeries(QChartSeries* series);
+                void addSeries(QChartSeries* series,QChartAxis *axisY = 0);
-                void addDomain(const Domain& domain);
+                void removeSeries(QChartSeries* series);
+                void addDomain(const QRectF& rect, const QRectF& viewport);
                 bool nextDomain();
                 bool previousDomain();
-                void clearDomains();
+                void clearDomains(int toIndex =0);
-                const Domain& domain() const;
+                const Domain domain(QChartAxis *axisY) const;
+                int domainIndex() const {return m_domainIndex;}
+                QChartAxis* axisX() const { return m_axisX;};
+                QChartAxis* axisY(QChartSeries* series = 0) const;
             signals:
                 void seriesAdded(QChartSeries* series);
-                void domainChanged(const Domain& domain);
+                void seriesRemoved(QChartSeries* series);
+                void axisAdded(QChartAxis* axis);
+                void axisRemoved(QChartAxis* axis);
+                void axisLabelsChanged(QChartAxis* axis, const QStringList& labels);
+                void seriesDomainChanged(QChartSeries* series,const Domain& domain);
+            private slots:
+            	void handleMinChanged(qreal min);
+            	void handleMaxChanged(qreal max);
+            	void handleTickChanged(QChartAxis*);
+            private:
+                void setDomain(int index);
+                QStringList createLabels(QChartAxis* axis,qreal min, qreal max);
             private:
-                QList<QChartSeries*> m_chartSeries;
+                QMultiMap<QChartAxis*, Domain> m_domainMap;
-                QVector<Domain> m_domains;
+                QMultiMap<QChartAxis*, QChartSeries*> m_seriesMap;
+                QChartAxis* m_axisX;
+                QChartAxis* m_axisY;
                 int m_domainIndex;
+                bool m_axisXInitialized;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif /* CHARTENGINE_P_H_ */

src/chartitem_p.h +3 0

             #ifndef CHARTITEM_H_
             #define CHARTITEM_H_
             #include "domain_p.h"
             #include <QGraphicsItem>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class ChartAnimationManager;
             class ChartItem : public QGraphicsItem
             {
                 enum ChartItemTypes{ AXIS_ITEM = UserType+1, XYLINE_ITEM};
             public:
                 ChartItem(QGraphicsItem* parent = 0):QGraphicsItem(parent){};
+                //TODO make pure
+                virtual void handleGeometryChanged(const QRectF&){};
+                virtual void handleDomainChanged(const Domain& domain){};
                 virtual ~ChartItem(){};
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif /* CHARTITEM_H_ */

src/chartpresenter.cpp +50 -96

             #include "qchart.h"
             #include "qchartaxis.h"
             #include "chartpresenter_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             //series
             #include "qbarchartseries.h"
             #include "qstackedbarchartseries.h"
             #include "qpercentbarchartseries.h"
             #include "qlinechartseries.h"
             #include "qpieseries.h"
             #include "qscatterseries.h"
             //items
             #include "axisitem_p.h"
             #include "barpresenter.h"
             #include "stackedbarpresenter.h"
             #include "linechartitem_p.h"
             #include "percentbarpresenter.h"
             #include "linechartanimationitem_p.h"
             #include "piepresenter.h"
             #include "scatterpresenter_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartPresenter::ChartPresenter(QChart* chart,ChartDataSet* dataset):QObject(chart),
             m_chart(chart),
             m_dataset(dataset),
             m_chartTheme(0),
-            m_axisXItem(new AxisItem(AxisItem::X_AXIS,m_chart)),
-            m_axisYItem(new AxisItem(AxisItem::Y_AXIS,m_chart)),
-            m_domainIndex(0),
             m_marginSize(0),
             m_rect(QRectF(QPoint(0,0),m_chart->size()))
             {
-                setChartTheme(QChart::ChartThemeDefault);
             	createConnections();
+                setChartTheme(QChart::ChartThemeDefault);
             }
             ChartPresenter::~ChartPresenter()
             {
             }
             void ChartPresenter::createConnections()
             {
                 QObject::connect(m_chart,SIGNAL(geometryChanged()),this,SLOT(handleGeometryChanged()));
                 QObject::connect(m_dataset,SIGNAL(seriesAdded(QChartSeries*)),this,SLOT(handleSeriesAdded(QChartSeries*)));
-                QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),m_axisXItem,SLOT(handleGeometryChanged(const QRectF&)));
+                QObject::connect(m_dataset,SIGNAL(seriesRemoved(QChartSeries*)),this,SLOT(handleSeriesRemoved(QChartSeries*)));
-                QObject::connect(m_dataset,SIGNAL(domainChanged(const Domain&)),m_axisXItem,SLOT(handleDomainChanged(const Domain&)));
+                QObject::connect(m_dataset,SIGNAL(axisAdded(QChartAxis*)),this,SLOT(handleAxisAdded(QChartAxis*)));
-                QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),m_axisYItem,SLOT(handleGeometryChanged(const QRectF&)));
+                QObject::connect(m_dataset,SIGNAL(axisRemoved(QChartAxis*)),this,SLOT(handleAxisRemoved(QChartAxis*)));
-                QObject::connect(m_dataset,SIGNAL(domainChanged(const Domain&)),m_axisYItem,SLOT(handleDomainChanged(const Domain&)));
+                QObject::connect(m_dataset,SIGNAL(seriesDomainChanged(QChartSeries*,const Domain&)),this,SLOT(handleSeriesDomainChanged(QChartSeries*,const Domain&)));
+                QObject::connect(m_dataset,SIGNAL(axisLabelsChanged(QChartAxis*,const QStringList&)),this,SLOT(handleAxisLabelsChanged(QChartAxis*,const QStringList&)));
+            }
+            QRectF ChartPresenter::geometry() const
+            {
+                return m_rect;
             }
             void ChartPresenter::handleGeometryChanged()
             {
                 m_rect = QRectF(QPoint(0,0),m_chart->size());
                 m_rect.adjust(m_marginSize,m_marginSize, -m_marginSize, -m_marginSize);
                 Q_ASSERT(m_rect.isValid());
                 emit geometryChanged(m_rect);
             }
             int ChartPresenter::margin() const
             {
                 return m_marginSize;
             }
             void ChartPresenter::setMargin(int margin)
             {
                 m_marginSize = margin;
             }
+            void ChartPresenter::handleAxisAdded(QChartAxis* axis)
+            {
+                AxisItem* item ;
+                if(axis==m_dataset->axisX()){
+                item = new AxisItem(AxisItem::X_AXIS,m_chart);
+                }else{
+                item = new AxisItem(AxisItem::Y_AXIS,m_chart);
+                }
+                QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),item,SLOT(handleGeometryChanged(const QRectF&)));
+                QObject::connect(axis,SIGNAL(update(QChartAxis*)),item,SLOT(handleAxisUpdate(QChartAxis*)));
+                m_chartTheme->decorate(axis,item);
+                m_axisItems.insert(axis,item);
+            }
+            void ChartPresenter::handleAxisRemoved(QChartAxis* axis)
+            {
+                AxisItem* item = m_axisItems.take(axis);
+                Q_ASSERT(item);
+                delete item;
+            }
             void ChartPresenter::handleSeriesAdded(QChartSeries* series)
             {
-                qDebug() << " ChartPresenter::handleSeriesAdded";
                 switch(series->type())
                 {
                     case QChartSeries::SeriesTypeLine: {
                         QLineChartSeries* lineSeries = static_cast<QLineChartSeries*>(series);
                         LineChartItem* item = new LineChartAnimationItem(this,lineSeries,m_chart);
                         m_chartTheme->decorate(item,lineSeries,m_chartItems.count());
                         QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),item,SLOT(handleGeometryChanged(const QRectF&)));
-                        QObject::connect(m_dataset,SIGNAL(domainChanged(const Domain&)),item,SLOT(handleDomainChanged(const Domain&)));
                         QObject::connect(lineSeries,SIGNAL(changed(int)),item,SLOT(handleModelChanged(int)));
                         m_chartItems.insert(series,item);
                         break;
                     }
                     case QChartSeries::SeriesTypeBar: {
                         QBarChartSeries* barSeries = static_cast<QBarChartSeries*>(series);
                         BarPresenter* item = new BarPresenter(barSeries->model(),m_chart);
                         m_chartTheme->decorate(item,barSeries,m_chartItems.count());
                         QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),item,SLOT(handleGeometryChanged(const QRectF&)));
-                        QObject::connect(m_dataset,SIGNAL(domainChanged(const Domain&)),item,SLOT(handleDomainChanged(const Domain&)));
                         QObject::connect(barSeries,SIGNAL(changed(int)),item,SLOT(handleModelChanged(int)));
                         m_chartItems.insert(series,item);
                         // m_axisXItem->setVisible(false);
                         break;
                     }
                     case QChartSeries::SeriesTypeStackedBar: {
                         QStackedBarChartSeries* stackedBarSeries = static_cast<QStackedBarChartSeries*>(series);
                         StackedBarPresenter* item = new StackedBarPresenter(stackedBarSeries->model(),m_chart);
                         m_chartTheme->decorate(item,stackedBarSeries,m_chartItems.count());
                         QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),item,SLOT(handleGeometryChanged(const QRectF&)));
-                        QObject::connect(m_dataset,SIGNAL(domainChanged(const Domain&)),item,SLOT(handleDomainChanged(const Domain&)));
                         QObject::connect(stackedBarSeries,SIGNAL(changed(int)),item,SLOT(handleModelChanged(int)));
                         m_chartItems.insert(series,item);
                         break;
                     }
                     case QChartSeries::SeriesTypePercentBar: {
                         QPercentBarChartSeries* percentBarSeries = static_cast<QPercentBarChartSeries*>(series);
                         PercentBarPresenter* item = new PercentBarPresenter(percentBarSeries->model(),m_chart);
                         m_chartTheme->decorate(item,percentBarSeries ,m_chartItems.count());
                         QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),item,SLOT(handleGeometryChanged(const QRectF&)));
-                        QObject::connect(m_dataset,SIGNAL(domainChanged(const Domain&)),item,SLOT(handleDomainChanged(const Domain&)));
                         QObject::connect(percentBarSeries,SIGNAL(changed(int)),item,SLOT(handleModelChanged(int)));
                         m_chartItems.insert(series,item);
                         break;
                     }
                     case QChartSeries::SeriesTypeScatter: {
                         QScatterSeries *scatterSeries = qobject_cast<QScatterSeries *>(series);
                         ScatterPresenter *scatterPresenter = new ScatterPresenter(scatterSeries, m_chart);
                         QObject::connect(this, SIGNAL(geometryChanged(const QRectF&)),
                                          scatterPresenter, SLOT(handleGeometryChanged(const QRectF&)));
-                        QObject::connect(m_dataset, SIGNAL(domainChanged(const Domain&)),
-                                         scatterPresenter, SLOT(handleDomainChanged(const Domain&)));
                         m_chartTheme->decorate(scatterPresenter, scatterSeries, m_chartItems.count());
                         m_chartItems.insert(scatterSeries, scatterPresenter);
                         break;
                     }
                     case QChartSeries::SeriesTypePie: {
                         QPieSeries *s = qobject_cast<QPieSeries *>(series);
                         PiePresenter* pie = new PiePresenter(m_chart, s);
                         m_chartTheme->decorate(pie, s, m_chartItems.count());
                         QObject::connect(this, SIGNAL(geometryChanged(const QRectF&)), pie, SLOT(handleGeometryChanged(const QRectF&)));
-                        QObject::connect(m_dataset, SIGNAL(domainChanged(const Domain&)), pie, SLOT(handleDomainChanged(const Domain&)));
                         m_chartItems.insert(series, pie);
                         break;
                     }
                     default: {
                         qDebug()<< "Series type" << series->type() << "not implemented.";
                         break;
                     }
                 }
                 if(m_rect.isValid()) emit geometryChanged(m_rect);
             }
-            void ChartPresenter::handleSeriesChanged(QChartSeries* series)
+            void ChartPresenter::handleSeriesRemoved(QChartSeries* series)
             {
-                //TODO:
+            	ChartItem* item = m_chartItems.take(series);
+            	delete item;
             }
-            void ChartPresenter::zoomInToRect(const QRectF& rect)
+            void ChartPresenter::handleSeriesChanged(QChartSeries* series)
-                if(!rect.isValid()) return;
-                QRectF r = rect.normalized();
-                r.translate(-m_marginSize, -m_marginSize);
-                Domain domain (m_dataset->domain().subDomain(r,m_rect.width(),m_rect.height()));
-                m_dataset->addDomain(domain);
-            void ChartPresenter::zoomIn()
             {
-                if (!m_dataset->nextDomain()) {
+                //TODO:
-                    QRectF rect = m_rect;
-                    rect.setWidth(rect.width()/2);
-                    rect.setHeight(rect.height()/2);
-                    rect.moveCenter(m_rect.center());
-                    Domain domain (m_dataset->domain().subDomain(rect,m_rect.width(),m_rect.height()));
-                    m_dataset->addDomain(domain);
             }
-            void ChartPresenter::zoomOut()
+            void ChartPresenter::handleSeriesDomainChanged(QChartSeries* series, const Domain& domain)
             {
-                m_dataset->previousDomain();
+                m_chartItems.value(series)->handleDomainChanged(domain);
             }
-            void ChartPresenter::zoomReset()
+            void ChartPresenter::handleAxisLabelsChanged(QChartAxis* axis,const QStringList& labels)
             {
-                m_dataset->clearDomains();
+                m_axisItems.value(axis)->handleLabelsChanged(labels);
             }
             void ChartPresenter::setChartTheme(QChart::ChartTheme theme)
             {
                 delete m_chartTheme;
                 m_chartTheme = ChartTheme::createTheme(theme);
                 m_chartTheme->decorate(m_chart);
                 QMapIterator<QChartSeries*,ChartItem*> i(m_chartItems);
                 int index=0;
                 while (i.hasNext()) {
                     i.next();
                     index++;
                     m_chartTheme->decorate(i.value(),i.key(),index);
                 }
-                m_chartTheme->decorate(m_axisX, m_axisXItem);
+                QMapIterator<QChartAxis*,AxisItem*> j(m_axisItems);
-                m_chartTheme->decorate(m_axisY, m_axisYItem);
+                while (j.hasNext()) {
+                        j.next();
+                        m_chartTheme->decorate(j.key(),j.value());
+                }
             }
             QChart::ChartTheme ChartPresenter::chartTheme()
             {
                 return m_chartTheme->id();
             }
-            void ChartPresenter::setDefaultAxisX(const QChartAxis& axis)
-                //if(m_axisX != axis) {
-                    m_axisX = axis;
-                    m_axisXItem->handleAxisChanged(m_axisX);
-                //}
-            void ChartPresenter::setDefaultAxisY(const QChartAxis& axis)
-                // if(m_axisY != axis) {
-                    m_axisY = axis;
-                    m_axisYItem->handleAxisChanged(m_axisY);
-                //}
-            QChartAxis ChartPresenter::defaultAxisX() const
-                return m_axisX;
-            QChartAxis ChartPresenter::defaultAxisY() const
-                return m_axisY;
-            QChartAxis ChartPresenter::axisY(int id) const
-                return m_axis.value(id);
-            int ChartPresenter::addAxisY(const QChartAxis& axis)
-                int key =0 ;
-                while(m_axis.contains(key)){
-                    key++;
-                    //TODO overflow
-                m_axis.insert(key,axis);
-                m_axisItems.insert(key,new AxisItem(AxisItem::Y_AXIS,m_chart));
-                return key;
-            void ChartPresenter::removeAxisY(int id)
-                m_axis.remove(id);
-                delete m_axisItems.take(id);
             #include "moc_chartpresenter_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/chartpresenter_p.h +7 -22

             #ifndef CHARTPRESENTER_H_
             #define CHARTPRESENTER_H_
             #include "qchartglobal.h"
             #include "qchart.h" //becouse of QChart::ChartThemeId //TODO
             #include "qchartaxis.h"
             #include <QRectF>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class ChartItem;
             class QChartSeries;
             class ChartDataSet;
             //class QChart;
             class Domain;
             class AxisItem;
             class ChartTheme;
             class ChartPresenter: public QObject
             {
                 Q_OBJECT
             public:
                 ChartPresenter(QChart* chart,ChartDataSet *dataset);
                 virtual ~ChartPresenter();
                 void setMargin(int margin);
                 int margin() const;
-                void zoomInToRect(const QRectF& rectangle);
+                QRectF geometry() const;
-                void zoomIn();
-                void zoomOut();
-                void zoomReset();
                 void setChartTheme(QChart::ChartTheme theme);
                 QChart::ChartTheme chartTheme();
-                void setDefaultAxisX(const QChartAxis& axis);
-                void setDefaultAxisY(const QChartAxis& axis);
-                QChartAxis defaultAxisX() const;
-                QChartAxis defaultAxisY() const;
-                QChartAxis axisY(int id) const;
-                int addAxisY(const QChartAxis& axis);
-                void removeAxisY(int id);
             private:
                 void createConnections();
             public slots:
                 void handleSeriesAdded(QChartSeries* series);
-                void handleSeriesRemoved(QChartSeries* series){};
+                void handleSeriesRemoved(QChartSeries* series);
+                void handleAxisAdded(QChartAxis* axis);
+                void handleAxisRemoved(QChartAxis* axis);
+                void handleSeriesDomainChanged(QChartSeries* series, const Domain& domain);
+                void handleAxisLabelsChanged(QChartAxis* axis, const QStringList& labels);
                 void handleSeriesChanged(QChartSeries* series);
-                //void handleDomainChanged(Domain oldDomain,Domain newDomain);
                 void handleGeometryChanged();
             signals:
                 void geometryChanged(const QRectF& rect);
             private:
                 QMap<QChartSeries*,ChartItem*> m_chartItems;
-                QMap<int,AxisItem*> m_axisItems;
+                QMap<QChartAxis*,AxisItem*> m_axisItems;
-                QMap<int,QChartAxis> m_axis;
                 QChart* m_chart;
                 ChartDataSet* m_dataset;
-                QVector<Domain> m_domains;
                 ChartTheme *m_chartTheme;
-                QChartAxis m_axisX;
-                AxisItem* m_axisXItem;
-                QChartAxis m_axisY;
-                AxisItem* m_axisYItem;
-                int m_domainIndex;
                 int m_marginSize;
                 QRectF m_rect;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif /* CHARTPRESENTER_H_ */

src/charttheme.cpp +5 -7

             #include "charttheme_p.h"
             #include "qchart.h"
             #include "qchartaxis.h"
             //series
             #include "qbarset.h"
             #include "qbarchartseries.h"
             #include "qstackedbarchartseries.h"
             #include "qpercentbarchartseries.h"
             #include "qlinechartseries.h"
             #include "qscatterseries.h"
             #include "qpieseries.h"
             #include "qpieslice.h"
             //items
             #include "axisitem_p.h"
             #include "barpresenter.h"
             #include "stackedbarpresenter.h"
             #include "linechartitem_p.h"
             #include "percentbarpresenter.h"
             #include "scatterpresenter_p.h"
             #include "piepresenter.h"
             //themes
             #include "chartthemevanilla_p.h"
             #include "chartthemeicy_p.h"
             #include "chartthemegrayscale_p.h"
             #include "chartthemescientific_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /* TODO
                 case QChart::ChartThemeUnnamed1:
                     m_seriesThemes.append(SeriesTheme(QColor(QRgb(0xff3fa9f5)), 2));
                     m_seriesThemes.append(SeriesTheme(QColor(QRgb(0xff7AC943)), 2));
                     m_seriesThemes.append(SeriesTheme(QColor(QRgb(0xffFF931E)), 2));
                     m_seriesThemes.append(SeriesTheme(QColor(QRgb(0xffFF1D25)), 2));
                     m_seriesThemes.append(SeriesTheme(QColor(QRgb(0xffFF7BAC)), 2));
                     m_gradientStartColor = QColor(QRgb(0xfff3dc9e));
                     m_gradientEndColor = QColor(QRgb(0xffafafaf));
             */
             ChartTheme::ChartTheme(QChart::ChartTheme id)
             {
                 m_id = id;
                 m_seriesColor.append(QRgb(0xff000000));
                 m_seriesColor.append(QRgb(0xff707070));
                 m_gradientStartColor = QColor(QRgb(0xffffffff));
                 m_gradientEndColor = QColor(QRgb(0xffafafaf));
             }
             ChartTheme* ChartTheme::createTheme(QChart::ChartTheme theme)
             {
                 switch(theme) {
                     case QChart::ChartThemeDefault:
                         return new ChartTheme();
                     case QChart::ChartThemeVanilla:
                         return new ChartThemeVanilla();
                     case QChart::ChartThemeIcy:
                         return new ChartThemeIcy();
                     case QChart::ChartThemeGrayscale:
                         return new ChartThemeGrayscale();
                     case QChart::ChartThemeScientific:
                         return new ChartThemeScientific();
                 }
             }
             void ChartTheme::decorate(QChart* chart)
             {
                 QLinearGradient backgroundGradient;
                 backgroundGradient.setColorAt(0.0, m_gradientStartColor);
                 backgroundGradient.setColorAt(1.0, m_gradientEndColor);
                 backgroundGradient.setCoordinateMode(QGradient::ObjectBoundingMode);
                 chart->setChartBackgroundBrush(backgroundGradient);
             }
             //TODO helper to by removed later
             void ChartTheme::decorate(ChartItem* item, QChartSeries* series,int count)
             {
                 switch(series->type())
                 {
                     case QChartSeries::SeriesTypeLine: {
                         QLineChartSeries* s = static_cast<QLineChartSeries*>(series);
                         LineChartItem* i = static_cast<LineChartItem*>(item);
                         decorate(i,s,count);
                         break;
                     }
                     case QChartSeries::SeriesTypeBar: {
                         QBarChartSeries* b = static_cast<QBarChartSeries*>(series);
                         BarPresenter* i = static_cast<BarPresenter*>(item);
                         decorate(i,b,count);
                         break;
                     }
                     case QChartSeries::SeriesTypeStackedBar: {
                         QStackedBarChartSeries* s = static_cast<QStackedBarChartSeries*>(series);
                         StackedBarPresenter* i = static_cast<StackedBarPresenter*>(item);
                         decorate(i,s,count);
                         break;
                     }
                     case QChartSeries::SeriesTypePercentBar: {
                         QPercentBarChartSeries* s = static_cast<QPercentBarChartSeries*>(series);
                         PercentBarPresenter* i = static_cast<PercentBarPresenter*>(item);
                         decorate(i,s,count);
                         break;
                     }
                     case QChartSeries::SeriesTypeScatter: {
                         QScatterSeries* s = qobject_cast<QScatterSeries*>(series);
                         Q_ASSERT(s);
                         ScatterPresenter* i = static_cast<ScatterPresenter*>(item);
                         Q_ASSERT(i);
                         decorate(i, s, count);
                         break;
                     }
                     case QChartSeries::SeriesTypePie: {
                         QPieSeries* s = static_cast<QPieSeries*>(series);
                         PiePresenter* i = static_cast<PiePresenter*>(item);
                         decorate(i,s,count);
                         break;
                     }
                     default:
                     qDebug()<<"Wrong item to be decorated by theme";
                     break;
                 }
             }
             void ChartTheme::decorate(LineChartItem* item, QLineChartSeries* series,int count)
             {
                 QPen pen;
                 if(pen != series->pen()){
                     item->setPen(series->pen());
                     return;
                 }
                 pen.setColor(m_seriesColor.at(count%m_seriesColor.size()));
                 pen.setWidthF(2);
                 item->setPen(pen);
             }
             void ChartTheme::decorate(BarPresenter* item, QBarChartSeries* series,int count)
             {
                 for (int i=0; i<series->countSets(); i++) {
                     series->nextSet(0==i)->setBrush(QBrush(m_seriesColor.at(i%m_seriesColor.count())));
                 }
             }
             void ChartTheme::decorate(StackedBarPresenter* item, QStackedBarChartSeries* series,int count)
             {
                 for (int i=0; i<series->countSets(); i++) {
                     series->nextSet(0==i)->setBrush(QBrush(m_seriesColor.at(i%m_seriesColor.count())));
                 }
             }
             void ChartTheme::decorate(PercentBarPresenter* item, QPercentBarChartSeries* series,int count)
             {
                 for (int i=0; i<series->countSets(); i++) {
                     series->nextSet(0==i)->setBrush(QBrush(m_seriesColor.at(i%m_seriesColor.count())));
                 }
             }
             void ChartTheme::decorate(ScatterPresenter* presenter, QScatterSeries* series, int count)
             {
                 Q_ASSERT(presenter);
                 Q_ASSERT(series);
                 QColor color = m_seriesColor.at(count % m_seriesColor.size());
                 // TODO: define alpha in the theme? or in the series?
                 color.setAlpha(120);
                 QBrush brush(color, Qt::SolidPattern);
                 presenter->m_markerBrush = brush;
                 QPen pen(brush, 1);
                 pen.setColor(color);
                 presenter->m_markerPen = pen;
             }
             void ChartTheme::decorate(PiePresenter* item, QPieSeries* series, int /*count*/)
             {
                 // create a list of slice colors based on current theme
                 int i = 0;
                 QList<QColor> colors;
                 while (colors.count() < series->count()) {
                     // get base color
                     QColor c = m_seriesColor[i++];
                     i = i % m_seriesColor.count();
                     // -1 means achromatic color -> cannot manipulate lightness
                     // TODO: find a better way to randomize lightness
                     if (c.toHsv().hue() == -1)
                         qWarning() << "ChartTheme::decorate() warning: achromatic theme color";
                     // randomize lightness
                     qreal f = 50 + (qrand() % 100); // 50 is 50% darker, 100 is the same, 150 is 50% lighter
                     c = c.lighter(f);
                     // find duplicates
                     bool isUnique = true;
                     foreach (QColor color, colors) {
                         if (c == color)
                             isUnique = false;
                     }
                     // add to array if unique
                     //if (isUnique)
                         colors << c;
                 }
                 // finally update colors
                 foreach (QPieSlice* s, series->slices()) {
                     s->setPen(QPen(Qt::black)); // TODO: get from theme
                     s->setBrush(colors.takeFirst());
                 }
             }
-            void ChartTheme::decorate(QChartAxis& axis,AxisItem* item)
+            void ChartTheme::decorate(QChartAxis* axis,AxisItem* item)
             {
                 //TODO: dummy defults for now
+                axis->setLabelsBrush(Qt::black);
-                axis.setLabelsBrush(Qt::black);
+                axis->setLabelsPen(Qt::NoPen);
-                axis.setLabelsPen(Qt::NoPen);
+                axis->setShadesPen(Qt::NoPen);
-                axis.setShadesPen(Qt::NoPen);
+                axis->setShadesOpacity(0.5);
-                axis.setShadesOpacity(0.5);
-                item->handleAxisChanged(axis);
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/charttheme_p.h +1 -1

             #ifndef CHARTTHEME_H
             #define CHARTTHEME_H
             #include "qchartglobal.h"
             #include "qchart.h"
             #include <QColor>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class ChartItem;
             class QChartSeries;
             class LineChartItem;
             class QLineChartSeries;
             class BarPresenter;
             class QBarChartSeries;
             class StackedBarPresenter;
             class QStackedBarChartSeries;
             class QPercentBarChartSeries;
             class PercentBarPresenter;
             class QScatterSeries;
             class ScatterPresenter;
             class PiePresenter;
             class QPieSeries;
             class ChartTheme
             {
             protected:
                 explicit ChartTheme(QChart::ChartTheme id =  QChart::ChartThemeDefault);
             public:
                 static ChartTheme* createTheme(QChart::ChartTheme theme);
                 QChart::ChartTheme id() const {return m_id;}
                 void decorate(QChart* chart);
                 void decorate(ChartItem* item, QChartSeries* series,int count);
                 void decorate(LineChartItem* item, QLineChartSeries*, int count);
                 void decorate(BarPresenter* item, QBarChartSeries* series,int count);
                 void decorate(StackedBarPresenter* item, QStackedBarChartSeries* series,int count);
                 void decorate(PercentBarPresenter* item, QPercentBarChartSeries* series,int count);
                 void decorate(ScatterPresenter* presenter, QScatterSeries* series, int count);
                 void decorate(PiePresenter* item, QPieSeries* series, int count);
-                void decorate(QChartAxis& axis,AxisItem* item);
+                void decorate(QChartAxis* axis,AxisItem* item);
             protected:
                 QChart::ChartTheme m_id;
                 QColor m_gradientStartColor;
                 QColor m_gradientEndColor;
                 QList<QColor> m_seriesColor;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // CHARTTHEME_H

src/qchart.cpp +42 -88

             #include "qchart.h"
             #include "qchartaxis.h"
             #include "chartpresenter_p.h"
             #include "chartdataset_p.h"
+            <<<<<<< HEAD
             //series
             #include "qbarchartseries.h"
             #include "qstackedbarchartseries.h"
             #include "qpercentbarchartseries.h"
             #include "qlinechartseries.h"
             #include "qscatterseries.h"
             //#include "scatterseries_p.h"
             #include "qpieseries.h"
             #include <QGraphicsScene>
             #include <QGraphicsSceneResizeEvent>
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             QChart::QChart(QGraphicsItem *parent, Qt::WindowFlags wFlags) : QGraphicsWidget(parent,wFlags),
             m_backgroundItem(0),
             m_titleItem(0),
             m_dataset(new ChartDataSet(this)),
             m_presenter(new ChartPresenter(this,m_dataset))
             {
             }
             QChart::~QChart() {}
-            void QChart::addSeries(QChartSeries* series)
+            void QChart::addSeries(QChartSeries* series,QChartAxis* axisY)
             {
-                m_dataset->addSeries(series);
+                m_dataset->addSeries(series,axisY);
             }
-            //TODO on review, is it really needed ??
+            void QChart::removeSeries(QChartSeries* series)
-            QChartSeries* QChart::createSeries(QChartSeries::QChartSeriesType type)
             {
-                QChartSeries *series(0);
+                m_dataset->removeSeries(series);
-                switch (type) {
-                    case QChartSeries::SeriesTypeLine: {
-                        series = new QLineChartSeries(this);
-                        break;
-                    case QChartSeries::SeriesTypeBar: {
-                        //series = new BarChartSeries(this);
-                        break;
-                    case QChartSeries::SeriesTypeStackedBar: {
-                        //series = new StackedBarChartSeries(this);
-                        break;
-                    case QChartSeries::SeriesTypePercentBar: {
-                        //series = new PercentBarChartSeries(this);
-                        break;
-                    case QChartSeries::SeriesTypeScatter: {
-                        series = new QScatterSeries(this);
-                        break;
-                    case QChartSeries::SeriesTypePie: {
-                        series = new QPieSeries(this);
-                        break;
-                    default:
-                    Q_ASSERT(false);
-                    break;
-                addSeries(series);
-                return series;
             }
             void QChart::setChartBackgroundBrush(const QBrush& brush)
             {
+                createChartBackgroundItem();
-                if(!m_backgroundItem) {
-                    m_backgroundItem = new QGraphicsRectItem(this);
-                    m_backgroundItem->setZValue(-1);
                 m_backgroundItem->setBrush(brush);
                 m_backgroundItem->update();
             }
             void QChart::setChartBackgroundPen(const QPen& pen)
             {
+                createChartBackgroundItem();
-                if(!m_backgroundItem) {
-                    m_backgroundItem = new QGraphicsRectItem(this);
-                    m_backgroundItem->setZValue(-1);
                 m_backgroundItem->setPen(pen);
                 m_backgroundItem->update();
             }
             void QChart::setChartTitle(const QString& title)
             {
-                if(!m_titleItem) m_titleItem = new QGraphicsTextItem(this);
+                createChartTitleItem();
                 m_titleItem->setPlainText(title);
             }
             void QChart::setChartTitleFont(const QFont& font)
             {
-                if(!m_titleItem) m_titleItem = new QGraphicsTextItem(this);
+                createChartTitleItem();
                 m_titleItem->setFont(font);
             }
+            void QChart::createChartBackgroundItem()
+            {
+                if(!m_backgroundItem) {
+                    m_backgroundItem = new QGraphicsRectItem(this);
+                    m_backgroundItem->setZValue(-1);
+                }
+            }
+            void QChart::createChartTitleItem()
+            {
+                if(!m_titleItem) m_titleItem = new QGraphicsTextItem(this);
+            }
             int QChart::margin() const
             {
                 return m_presenter->margin();
             }
             void QChart::setMargin(int margin)
             {
                 m_presenter->setMargin(margin);
             }
             void QChart::setChartTheme(QChart::ChartTheme theme)
             {
                 m_presenter->setChartTheme(theme);
             }
             QChart::ChartTheme QChart::chartTheme() const
             {
                 return m_presenter->chartTheme();
             }
-            void QChart::zoomInToRect(const QRectF& rectangle)
-                m_presenter->zoomInToRect(rectangle);
             void QChart::zoomIn()
             {
-                m_presenter->zoomIn();
+                if (!m_dataset->nextDomain()) {
+                    QRectF rect = m_presenter->geometry();
+                    rect.setWidth(rect.width()/2);
-            void QChart::zoomOut()
+                    rect.setHeight(rect.height()/2);
+                    rect.moveCenter(m_presenter->geometry().center());
-                m_presenter->zoomOut();
+                    zoomIn(rect);
                 }
-            void QChart::zoomReset()
-                m_presenter->zoomReset();
             }
-            void QChart::setDefaultAxisX(const QChartAxis& axis)
+            void QChart::zoomIn(const QRectF& rect)
             {
-                m_presenter->setDefaultAxisX(axis);
+                if(!rect.isValid()) return;
+                   QRectF r = rect.normalized();
+                   int margin = m_presenter->margin();
+                   r.translate(-margin, -margin);
+                   m_dataset->addDomain(r,m_presenter->geometry());
             }
-            void QChart::setDefaultAxisY(const QChartAxis& axis)
+            void QChart::zoomOut()
-                m_presenter->setDefaultAxisY(axis);
-            QChartAxis QChart::defaultAxisX() const
-                return m_presenter->defaultAxisX();
-            QChartAxis QChart::defaultAxisY() const
             {
-                return m_presenter->defaultAxisY();
+                m_dataset->previousDomain();
             }
-            int QChart::addAxisY(const QChartAxis& axis)
+            void QChart::zoomReset()
             {
-                return m_presenter->addAxisY(axis);
+                m_dataset->clearDomains();
             }
-            QChartAxis QChart::axisY(int id) const
+            QChartAxis* QChart::axisX() const
             {
-                return m_presenter->axisY(id);
+                return m_dataset->axisX();
             }
-            void QChart::removeAxisY(int id)
+            QChartAxis* QChart::axisY() const
             {
-                m_presenter->removeAxisY(id);
+                return m_dataset->axisY();
             }
             void QChart::resizeEvent(QGraphicsSceneResizeEvent *event)
             {
                 m_rect = QRectF(QPoint(0,0),event->newSize());
                 QRectF rect = m_rect.adjusted(margin(),margin(), -margin(), -margin());
                 // recalculate title position
                 if (m_titleItem) {
                     QPointF center = m_rect.center() -m_titleItem->boundingRect().center();
                     m_titleItem->setPos(center.x(),m_rect.top()/2 + margin()/2);
                 }
                 //recalculate background gradient
                 if (m_backgroundItem) {
                     m_backgroundItem->setRect(rect);
                 }
                 QGraphicsWidget::resizeEvent(event);
                 update();
             }
             #include "moc_qchart.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/qchart.h +9 -18

             #ifndef CHART_H
             #define CHART_H
             #include <qchartglobal.h>
             #include <qchartseries.h>
             #include <QGraphicsWidget>
             #include <QLinearGradient>
             #include <QFont>
             class QGraphicsSceneResizeEvent;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class AxisItem;
             class QChartSeries;
             class PlotDomain;
             class BarPresenter;
             class QChartAxis;
             class ChartTheme;
             class ChartItem;
             class ChartDataSet;
             class ChartPresenter;
-            // TODO: We don't need to have QChart tied to QGraphicsItem:
-            //class QTCOMMERCIALCHART_EXPORT QChart
-            //class QTCOMMERCIALCHART_EXPORT QChartGraphicsItem : public QGraphicsItem {
-            // public: QChartGraphicsItem(QChart &chart);
             /*!
              * TODO: define the responsibilities
              */
             class QTCOMMERCIALCHART_EXPORT QChart : public QGraphicsWidget
             {
                 Q_OBJECT
             public:
                 enum ChartTheme {
                     /*! The default theme follows the GUI style of the Operating System */
                     ChartThemeDefault,
                     ChartThemeVanilla,
                     ChartThemeIcy,
                     ChartThemeGrayscale,
                     ChartThemeScientific,
                     //ChartThemeUnnamed1
                 };
             public:
                 QChart(QGraphicsItem *parent = 0, Qt::WindowFlags wFlags = 0);
                 ~QChart();
-                void addSeries(QChartSeries* series);
+                void addSeries(QChartSeries* series,QChartAxis *axisY=0);
+                void removeSeries(QChartSeries* series);
-                //TODO: QChartSeries* createSeries(QSeriesData *data, QChartSeries::QChartSeriesType type);
-                // TODO: who owns the series now? maybe owned by chart and returned a reference instead...
-                QChartSeries* createSeries(QChartSeries::QChartSeriesType type);
                 void setMargin(int margin);
                 int margin() const;
                 void setChartTheme(QChart::ChartTheme theme);
                 QChart::ChartTheme chartTheme() const;
                 void setChartTitle(const QString& title);
                 void setChartTitleFont(const QFont& font);
                 void setChartBackgroundBrush(const QBrush& brush);
                 void setChartBackgroundPen(const QPen& pen);
-                void zoomInToRect(const QRectF& rectangle);
                 void zoomIn();
+                void zoomIn(const QRectF& rect);
                 void zoomOut();
                 void zoomReset();
-                void setDefaultAxisX(const QChartAxis& axis);
+                QChartAxis* axisX() const;
-                void setDefaultAxisY(const QChartAxis& axis);
+                QChartAxis* axisY() const;
-                QChartAxis defaultAxisX() const;
-                QChartAxis defaultAxisY() const;
-                QChartAxis axisY(int id) const;
-                int addAxisY(const QChartAxis& axis);
-                void removeAxisY(int id);
             protected:
                 void resizeEvent(QGraphicsSceneResizeEvent *event);
             private:
+                inline void createChartBackgroundItem();
+                inline void createChartTitleItem();
+            private:
                 Q_DISABLE_COPY(QChart)
                 QGraphicsRectItem* m_backgroundItem;
                 QGraphicsTextItem* m_titleItem;
                 QRectF m_rect;
                 ChartDataSet *m_dataset;
                 ChartPresenter *m_presenter;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/qchartaxis.cpp +74 -6

             #include "qchartaxis.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            QChartAxis::QChartAxis():
+            QChartAxis::QChartAxis(QObject* parent):QObject(parent),
             m_axisVisible(true),
             m_gridVisible(true),
             m_labelsVisible(true),
+            m_labelsAngle(0),
             m_shadesVisible(true),
-            m_shadesOpacity(1.0)
+            m_shadesOpacity(1.0),
+            m_min(0),
+            m_max(0),
+            m_ticksCount(4)
             {
-                // TODO Auto-generated constructor stub
             }
             QChartAxis::~QChartAxis()
             {
-                // TODO Auto-generated destructor stub
             }
             void QChartAxis::setAxisPen(const QPen& pen)
             {
                 m_axisPen=pen;
+                emit update(this);
             }
             void QChartAxis::setAxisVisible(bool visible)
             {
                 m_axisVisible=visible;
+                emit update(this);
             }
             void QChartAxis::setGridVisible(bool visible)
             {
                 m_gridVisible=visible;
+                emit update(this);
             }
             void QChartAxis::setGridPen(const QPen& pen)
             {
                 m_gridPen=pen;
+                emit update(this);
             }
             void QChartAxis::setLabelsVisible(bool visible)
             {
                 m_labelsVisible=visible;
+                emit update(this);
             }
             void QChartAxis::setLabelsPen(const QPen& pen)
             {
                 m_labelsPen=pen;
+                emit update(this);
             }
             void QChartAxis::setLabelsBrush(const QBrush& brush)
             {
                 m_labelsBrush=brush;
+                emit update(this);
             }
             void QChartAxis::setLabelsFont(const QFont& font)
             {
                 m_labelsFont=font;
+                emit update(this);
             }
-            void QChartAxis::setLabelsOrientation(LabelsOrientation orientation)
+            void QChartAxis::setLabelsAngle(int angle)
             {
-                m_labelsOrientation=orientation;
+            	m_labelsAngle=angle;
+            	 emit update(this);
             }
             void QChartAxis::setShadesVisible(bool visible)
             {
                 m_shadesVisible=visible;
+                emit update(this);
             }
             void QChartAxis::setShadesPen(const QPen& pen)
             {
                 m_shadesPen=pen;
+                emit update(this);
             }
             void QChartAxis::setShadesBrush(const QBrush& brush)
             {
                 m_shadesBrush=brush;
+                emit update(this);
             }
             void QChartAxis::setShadesOpacity(qreal opacity)
             {
                 m_shadesOpacity=opacity;
+                emit update(this);
             }
+            void QChartAxis::setMin(qreal min)
+            {
+            	if(m_min!=min){
+            		m_min=min;
+            		emit minChanged(m_min);
+            	}
+            }
+            void QChartAxis::setMax(qreal max)
+            {
+            	if(m_max!=max){
+            		m_max=max;
+            		emit maxChanged(m_max);
+            	}
+            }
+            void QChartAxis::setRange(qreal min, qreal max)
+            {
+            	setMin(min);
+            	setMax(max);
+            }
+            void QChartAxis::setTicksCount(int count)
+            {
+            	m_ticksCount=count;
+            	emit ticksChanged(this);
+            }
+            void QChartAxis::addAxisTickLabel(qreal value,const QString& label)
+            {
+            	m_ticks.insert(value,label);
+            	emit ticksChanged(this);
+            }
+            void QChartAxis::removeAxisTickLabel(qreal value)
+            {
+            	m_ticks.remove(value);
+            	emit ticksChanged(this);
+            }
+            QString QChartAxis::axisTickLabel(qreal value) const
+            {
+            	return m_ticks.value(value);
+            }
+            void QChartAxis::clearAxisTickLabels()
+            {
+            	m_ticks.clear();
+            	emit ticksChanged(this);
+            }
+            #include "moc_qchartaxis.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/qchartaxis.h +36 -15

             #ifndef QCHARTAXIS_H_
             #define QCHARTAXIS_H_
             #include <qchartglobal.h>
             #include <QPen>
             #include <QFont>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            class QTCOMMERCIALCHART_EXPORT QChartAxis
+            class QTCOMMERCIALCHART_EXPORT QChartAxis : public QObject
             {
+            	Q_OBJECT
             public:
-                enum LabelsOrientation{ LabelsOrientationHorizontal, LabelsOrientationVertical , LabelsOrientationSlide };
+                QChartAxis(QObject* parent =0);
+                ~QChartAxis();
-                QChartAxis();
+                //axis handling
-                virtual ~QChartAxis();
-                //axis
                 bool isAxisVisible() const { return m_axisVisible;};
                 void setAxisVisible(bool visible);
                 void setAxisPen(const QPen& pen);
                 QPen axisPen() const { return m_axisPen;};
                 void setAxisBrush(const QBrush& brush);
                 QBrush axisBrush() const { return m_axisBrush;};
-                //grid
+                //grid handling
                 bool isGridVisible() const { return m_gridVisible;};
                 void setGridVisible(bool visible);
                 void setGridPen(const QPen& pen);
                 QPen gridPen() const {return m_gridPen;}
-                //labels
+                //labels handling
                 bool isLabelsVisible() 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 labelFont() const { return m_labelsFont;}
-                void setLabelsOrientation(LabelsOrientation orientation);
+                void setLabelsAngle(int angle);
-                LabelsOrientation labelsOrientation() const { return m_labelsOrientation;};
+                int labelsAngle() const { return m_labelsAngle;};
-                //shades
+                //shades handling
                 bool isShadesVisible() 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;}
+                void addAxisTickLabel(qreal value,const QString& label);
+                void removeAxisTickLabel(qreal value);
+                QString axisTickLabel(qreal value) const ;
+                void clearAxisTickLabels();
+            signals:
+            	void minChanged(qreal min);
+            	void maxChanged(qreal max);
+            //private signal
+            	void update(QChartAxis*);
+            	void ticksChanged(QChartAxis*);
             private:
                 bool m_axisVisible;
                 QPen m_axisPen;
                 QBrush m_axisBrush;
                 bool m_gridVisible;
                 QPen m_gridPen;
                 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;
-                LabelsOrientation m_labelsOrientation;
+                int m_ticksCount;
+                QMap<qreal, QString> m_ticks;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif /* QCHARTAXIS_H_ */

src/qchartview.cpp +11 -41

             #include "qchartview.h"
             #include "qchart.h"
             #include "qchartaxis.h"
             #include <QGraphicsView>
             #include <QGraphicsScene>
             #include <QRubberBand>
             #include <QResizeEvent>
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             QChartView::QChartView(QWidget *parent) :
             QGraphicsView(parent),
             m_scene(new QGraphicsScene(this)),
             m_chart(new QChart()),
             m_rubberBand(0),
             m_verticalRubberBand(false),
             m_horizonalRubberBand(false)
             {
                 setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
                 setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
                 setScene(m_scene);
                 m_chart->setMargin(50);
                 m_scene->addItem(m_chart);
                 setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
             }
             QChartView::~QChartView()
             {
             }
             void QChartView::resizeEvent(QResizeEvent *event)
             {
                 m_scene->setSceneRect(0,0,size().width(),size().height());
                 m_chart->resize(size());
                 QWidget::resizeEvent(event);
             }
-            void QChartView::addSeries(QChartSeries* series)
+            void QChartView::addSeries(QChartSeries* series,QChartAxis *axisY)
             {
-                m_chart->addSeries(series);
+                m_chart->addSeries(series,axisY);
             }
-            QChartSeries* QChartView::createSeries(QChartSeries::QChartSeriesType type)
+            void QChartView::zoomIn()
             {
+                m_chart->zoomIn();
-                return m_chart->createSeries(type);
             }
-            void QChartView::zoomInToRect(const QRect& rectangle)
+            void QChartView::zoomIn(const QRect& rect)
             {
-                m_chart->zoomInToRect(rectangle);
+                m_chart->zoomIn(rect);
-            void QChartView::zoomIn()
-                m_chart->zoomIn();
             }
             void QChartView::zoomOut()
             {
                 m_chart->zoomOut();
             }
             int QChartView::margin() const
             {
                 return m_chart->margin();
             }
             void QChartView::setChartTitle(const QString& title)
             {
                 m_chart->setChartTitle(title);
             }
             void QChartView::setChartTitleFont(const QFont& font)
             {
                 m_chart->setChartTitleFont(font);
             }
             void QChartView::setChartBackgroundBrush(const QBrush& brush)
             {
                 m_chart->setChartBackgroundBrush(brush);
             }
             void QChartView::setChartBackgroundPen(const QPen& pen)
             {
                 m_chart->setChartBackgroundPen(pen);
             }
             void QChartView::setRubberBandPolicy(const RubberBandPolicy policy)
             {
                 switch(policy) {
                     case VerticalRubberBand:
                     m_verticalRubberBand = true;
                     m_horizonalRubberBand = false;
                     break;
                     case HorizonalRubberBand:
                     m_verticalRubberBand = false;
                     m_horizonalRubberBand = true;
                     break;
                     case RectangleRubberBand:
                     m_verticalRubberBand = true;
                     m_horizonalRubberBand = true;
                     break;
                     case NoRubberBand:
                     default:
                     delete m_rubberBand;
                     m_rubberBand=0;
                     m_horizonalRubberBand = false;
                     m_verticalRubberBand = false;
                     return;
                 }
                 if(!m_rubberBand) {
                     m_rubberBand = new QRubberBand(QRubberBand::Rectangle, this);
                     m_rubberBand->setEnabled(true);
                 }
             }
             QChartView::RubberBandPolicy QChartView::rubberBandPolicy() const
             {
                 if(m_horizonalRubberBand && m_verticalRubberBand) return RectangleRubberBand;
                 if(m_horizonalRubberBand) return HorizonalRubberBand;
                 if(m_verticalRubberBand) return VerticalRubberBand;
                 return NoRubberBand;
             }
             void QChartView::mousePressEvent(QMouseEvent *event)
             {
                 if(m_rubberBand && m_rubberBand->isEnabled() && event->button() == Qt::LeftButton) {
                     int margin = m_chart->margin();
                     QRect rect(margin, margin, width() - 2 * margin, height() - 2 * margin);
                     if (rect.contains(event->pos())) {
                         m_rubberBandOrigin = event->pos();
                         m_rubberBand->setGeometry(QRect(m_rubberBandOrigin, QSize()));
                         m_rubberBand->show();
                         event->accept();
                     }
                 }
             }
             void QChartView::mouseMoveEvent(QMouseEvent *event)
             {
                 if(m_rubberBand && m_rubberBand->isVisible()) {
                     int margin = m_chart->margin();
                     QRect rect(margin, margin, width() - 2 * margin, height() - 2 * margin);
                     int width = event->pos().x() - m_rubberBandOrigin.x();
                     int height = event->pos().y() - m_rubberBandOrigin.y();
                     if(!m_verticalRubberBand) {
                         m_rubberBandOrigin.setY(rect.top());
                         height = rect.height();
                     }
                     if(!m_horizonalRubberBand) {
                         m_rubberBandOrigin.setX(rect.left());
                         width= rect.width();
                     }
                     m_rubberBand->setGeometry(QRect(m_rubberBandOrigin.x(),m_rubberBandOrigin.y(), width,height).normalized());
                 }
                 else {
                     QGraphicsView::mouseMoveEvent(event);
                 }
             }
             void QChartView::mouseReleaseEvent(QMouseEvent *event)
             {
                 if(m_rubberBand) {
                     if (event->button() == Qt::LeftButton && m_rubberBand->isVisible()) {
                         m_rubberBand->hide();
                         QRect rect = m_rubberBand->geometry();
-                        m_chart->zoomInToRect(rect);
+                        m_chart->zoomIn(rect);
                         event->accept();
                     }
                     if(event->button()==Qt::RightButton)
                     m_chart->zoomReset();
                 }
                 else {
                     QGraphicsView::mouseReleaseEvent(event);
                 }
             }
             void QChartView::keyPressEvent(QKeyEvent *event)
             {
                 switch (event->key()) {
                     case Qt::Key_Plus:
                     zoomIn();
                     break;
                     case Qt::Key_Minus:
                     zoomOut();
                     break;
                     default:
                     QGraphicsView::keyPressEvent(event);
                     break;
                 }
             }
             void QChartView::setChartTheme(QChart::ChartTheme theme)
             {
                 m_chart->setChartTheme(theme);
             }
             QChart::ChartTheme QChartView::chartTheme() const
             {
                 return m_chart->chartTheme();
             }
-            void QChartView::setDefaultAxisX(const QChartAxis& axis)
+            QChartAxis* QChartView::axisX() const
-                m_chart->setDefaultAxisX(axis);
-            void QChartView::setDefaultAxisY(const QChartAxis& axis)
             {
-                m_chart->setDefaultAxisY(axis);
+                return m_chart->axisX();
             }
-            QChartAxis QChartView::defaultAxisX() const
+            QChartAxis* QChartView::axisY() const
             {
-                return m_chart->defaultAxisX();
+                return m_chart->axisY();
             }
-            QChartAxis QChartView::defaultAxisY() const
-                return m_chart->defaultAxisY();
-            int QChartView::addAxisY(const QChartAxis& axis)
-                return m_chart->addAxisY(axis);
-            QChartAxis QChartView::axisY(int id) const
-                return m_chart->axisY(id);
-            void QChartView::removeAxisY(int id)
-                m_chart->removeAxisY(id);
             QTCOMMERCIALCHART_END_NAMESPACE

src/qchartview.h +5 -12

             #ifndef QCHARTWIDGET_H
             #define QCHARTWIDGET_H
             #include "qchartglobal.h"
             #include "qchartseries.h"
             #include "qchart.h"
             #include <QGraphicsView>
             class QGraphicsScene;
             class QRubberBand;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QChart;
             class QTCOMMERCIALCHART_EXPORT QChartView : public QGraphicsView
             {
             public:
                 enum  RubberBandPolicy { NoRubberBand, VerticalRubberBand, HorizonalRubberBand, RectangleRubberBand };
                 explicit QChartView(QWidget *parent = 0);
                 ~QChartView();
                 //implement from QWidget
                 void resizeEvent(QResizeEvent *event);
-                void addSeries(QChartSeries* series); // takes ownership
+                void addSeries(QChartSeries* series,QChartAxis* axisY=0) ;// takes ownership
+                void removeSeries(QChartSeries* series);
-                // Convenience function
-                QChartSeries* createSeries(QChartSeries::QChartSeriesType type);
                 int margin() const;
                 void setChartTitle(const QString& title);
                 void setChartTitleFont(const QFont& font);
                 void setChartBackgroundBrush(const QBrush& brush);
                 void setChartBackgroundPen(const QPen& pen);
-                void zoomInToRect(const QRect& rectangle);
                 void zoomIn();
+                void zoomIn(const QRect& rect);
                 void zoomOut();
                 void setRubberBandPolicy(const RubberBandPolicy );
                 RubberBandPolicy rubberBandPolicy() const;
                 void setChartTheme(QChart::ChartTheme theme);
                 QChart::ChartTheme chartTheme() const;
-                void setDefaultAxisX(const QChartAxis& axis);
+                QChartAxis* axisX() const;
-                void setDefaultAxisY(const QChartAxis& axis);
+                QChartAxis* axisY() const;
-                QChartAxis defaultAxisX() const;
-                QChartAxis defaultAxisY() const;
-                QChartAxis axisY(int id) const;
-                int addAxisY(const QChartAxis& axis);
-                void removeAxisY(int id);
             protected:
                 void mousePressEvent(QMouseEvent *event);
                 void mouseMoveEvent(QMouseEvent *event);
                 void mouseReleaseEvent(QMouseEvent *event);
                 void keyPressEvent(QKeyEvent *event);
             private:
                 QGraphicsScene *m_scene;
                 QChart* m_chart;
                 QPoint m_rubberBandOrigin;
                 QRubberBand* m_rubberBand;
                 bool m_verticalRubberBand;
                 bool m_horizonalRubberBand;
                 Q_DISABLE_COPY(QChartView)
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QCHARTWIDGET_H

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