HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r241:0019f0f15db3

Bugfix shades not updated aftet tick changed

Michal Klocek -

r241:0019f0f15db3

parent child

Context file:

r241:0019f0f15db3

Collapse all files

src/axisitem.cpp +2 -3

             #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_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);
             }
             AxisItem::~AxisItem()
             {
             }
             QRectF AxisItem::boundingRect() const
             {
                 return m_rect;
             }
             void AxisItem::createItems(int count)
             {
                 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::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() / (count-1);
                           m_axis.setLine(m_rect.left(), m_rect.bottom(), m_rect.right(), m_rect.bottom());
                           for (int i = 0; i < count; ++i) {
                               int x = i * deltaX + m_rect.left();
                               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(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()/ (count-1);
                           m_axis.setLine(m_rect.left() , m_rect.top(), m_rect.left(), m_rect.bottom());
                           for (int i = 0; i < count; ++i) {
                               int y = i * -deltaY + m_rect.bottom();
                               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(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::handleAxisUpdate(QChartAxis* axis)
             {
                 if(axis->isAxisVisible()) {
                     setAxisOpacity(100);
                 }
                 else {
                     setAxisOpacity(0);
                 }
                 if(axis->isGridVisible()) {
                     setGridOpacity(100);
                 }
                 else {
                     setGridOpacity(0);
                 }
                 if(axis->isLabelsVisible())
                 {
                     setLabelsOpacity(100);
                 }
                 else {
                     setLabelsOpacity(0);
                 }
                 if(axis->isShadesVisible()) {
                     setShadesOpacity(axis->shadesOpacity());
                 }
                 else {
                     setShadesOpacity(0);
                 }
                 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)
+            void AxisItem::handleLabelsChanged(QChartAxis* axis,const QStringList& labels)
             {
                 m_thicksList=labels;
                 QList<QGraphicsItem*> items = m_labels.childItems();
                 if(items.size()!=m_thicksList.size()){
                    clear();
                    m_thicksList=labels;
                    createItems(m_thicksList.size());
                    items = m_labels.childItems();
+                   handleAxisUpdate(axis);
                  }
                 Q_ASSERT(items.size()==m_thicksList.size());
                 int i=0;
                 foreach(QGraphicsItem* item, items){
                     static_cast<QGraphicsSimpleTextItem*>(item)->setText(m_thicksList.at(i));
                     i++;
                 }
                 update();
             }
             void AxisItem::handleGeometryChanged(const QRectF& rect)
             {
                 m_rect = rect;
                 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);
                 }
             }
             //TODO "nice numbers algorithm"
             #include "moc_axisitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/axisitem_p.h +1 -1

             #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 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 handleAxisUpdate(QChartAxis* axis);
-                void handleLabelsChanged(const QStringList& labels);
+                void handleLabelsChanged(QChartAxis* axis,const QStringList& labels);
                 void handleGeometryChanged(const QRectF& size);
             protected:
                 void updateItem(int count);
             private:
                 void clear();
                 void createItems(int count);
             private:
                 AxisType m_type;
                 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 +1 -1

             #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),
             m_axisX(new QChartAxis(this)),
             m_axisY(new QChartAxis(this)),
             m_domainIndex(0),
             m_axisXInitialized(false)
             {
             }
             ChartDataSet::~ChartDataSet()
             {
                 // TODO Auto-generated destructor stub
             }
             const Domain ChartDataSet::domain(QChartAxis *axisY) const
             {
             	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, QChartAxis *axisY)
             {
                 // TODO: we should check the series not already added
                 series->setParent(this); // take ownership
                 series->setParent(this); // take ownership
                 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);
                 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()
             {
                 int limit = (m_domainMap.values().size()/m_domainMap.uniqueKeys().size())-1;
                 if (m_domainIndex < limit) {
                     m_domainIndex++;
                     setDomain(m_domainIndex);
                     return true;
                 }
                 else {
                     return false;
                 }
             }
             bool ChartDataSet::previousDomain()
             {
                 if (m_domainIndex > 0) {
                     m_domainIndex--;
                     setDomain(m_domainIndex);
                     return true;
                 }
                 else {
                     return false;
                 }
             }
             void ChartDataSet::setDomain(int index)
             {
                 QList<QChartAxis*> domainList = m_domainMap.uniqueKeys();
                 foreach (QChartAxis* axis , domainList) {
                     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::clearDomains(int toIndex)
             {
                 Q_ASSERT(toIndex>=0);
                 m_domainIndex = toIndex;
                 QList<QChartAxis*> keys = m_domainMap.uniqueKeys();
                 foreach (QChartAxis* key , keys)
                 {
                     QList<Domain> domains = m_domainMap.values(key);
                     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);
                 QStringList labels;
-                int ticks = axis->ticksCount();
+                int ticks = axis->ticksCount()-1;
                 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/chartpresenter.cpp +1 -1

             #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_marginSize(0),
             m_rect(QRectF(QPoint(0,0),m_chart->size()))
             {
             	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(m_dataset,SIGNAL(seriesRemoved(QChartSeries*)),this,SLOT(handleSeriesRemoved(QChartSeries*)));
                 QObject::connect(m_dataset,SIGNAL(axisAdded(QChartAxis*)),this,SLOT(handleAxisAdded(QChartAxis*)));
                 QObject::connect(m_dataset,SIGNAL(axisRemoved(QChartAxis*)),this,SLOT(handleAxisRemoved(QChartAxis*)));
                 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)
             {
                 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(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(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(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(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&)));
                         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&)));
                         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::handleSeriesRemoved(QChartSeries* series)
             {
             	ChartItem* item = m_chartItems.take(series);
             	delete item;
             }
             void ChartPresenter::handleSeriesChanged(QChartSeries* series)
             {
                 //TODO:
             }
             void ChartPresenter::handleSeriesDomainChanged(QChartSeries* series, const Domain& domain)
             {
                 m_chartItems.value(series)->handleDomainChanged(domain);
             }
             void ChartPresenter::handleAxisLabelsChanged(QChartAxis* axis,const QStringList& labels)
             {
-                m_axisItems.value(axis)->handleLabelsChanged(labels);
+                m_axisItems.value(axis)->handleLabelsChanged(axis,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);
                 }
                 QMapIterator<QChartAxis*,AxisItem*> j(m_axisItems);
                 while (j.hasNext()) {
                         j.next();
                         m_chartTheme->decorate(j.key(),j.value());
                 }
             }
             QChart::ChartTheme ChartPresenter::chartTheme()
             {
                 return m_chartTheme->id();
             }
             #include "moc_chartpresenter_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/qchartaxis.cpp +1 -1

             #include "qchartaxis.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             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_min(0),
             m_max(0),
-            m_ticksCount(4)
+            m_ticksCount(5)
             {
             }
             QChartAxis::~QChartAxis()
             {
             }
             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::setLabelsAngle(int angle)
             {
             	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

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