HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r701:0d46cd22e84d

src/axis/axisitem.cpp +29 -16

                  else setLayout(layout);
              }
-             QStringList Axis::createLabels(int ticks, qreal min, qreal max) const
+             bool Axis::createLabels(QStringList& labels,qreal min, qreal max,int ticks) const
              {
                  Q_ASSERT(max>=min);
                  Q_ASSERT(ticks>1);
-                 QStringList labels;
-                 int n =  qMax(int(-floor(log10((max-min)/(ticks-1)))),0);
                  QChartAxisCategories* categories = m_chartAxis->categories();
-                 for(int i=0; i< ticks; i++) {
-                     qreal value = min + (i * (max - min)/ (ticks-1));
-                     if(categories->count()==0) {
+                 bool category = categories->count()>0;
+                 if(!category) {
+                     int n = qMax(int(-floor(log10((max-min)/(ticks-1)))),0);
+                     for(int i=0; i< ticks; i++) {
+                         qreal value = min + (i * (max - min)/ (ticks-1));
                          labels << QString::number(value,'f',n);
                      }
-                     else {
+                 }
+                 else {
+                     for(int i=0; i< ticks; i++) {
+                         int value = ceil(min + (i * (max - min)/ (ticks-1)));
                          QString label = categories->label(value);
                          labels << label;
                      }
                  }
-                 return labels;
+                 return category;
              }
              void Axis::setAxisOpacity(qreal opacity)
              	if(diff!=0) handleAxisUpdated();
-                 QStringList ticksList = createLabels(layout.size(),m_min,m_max);
+             	QStringList ticksList;
+                 bool categories = createLabels(ticksList,m_min,m_max,layout.size());
              	QList<QGraphicsItem *> lines = m_grid.childItems();
              	QList<QGraphicsItem *> labels = m_labels.childItems();
              				QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(lines.at(i));
              				lineItem->setLine(layout[i], m_rect.top(), layout[i], m_rect.bottom());
              				QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem*>(labels.at(i));
-             				labelItem->setText(ticksList.at(i));
-             				QPointF center = labelItem->boundingRect().center();
-             				labelItem->setTransformOriginPoint(center.x(), center.y());
-             				labelItem->setPos(layout[i] - center.x(), m_rect.bottom() + label_padding);
+             				if(!categories){
+             				    labelItem->setText(ticksList.at(i));
+             				    QPointF center = labelItem->boundingRect().center();
+             				    labelItem->setTransformOriginPoint(center.x(), center.y());
+             				    labelItem->setPos(layout[i] - center.x(), m_rect.bottom() + label_padding);
+             				}else if(i>0){
+             				    labelItem->setText(ticksList.at(i));
+             				    QPointF center = labelItem->boundingRect().center();
+             				    labelItem->setTransformOriginPoint(center.x(), center.y());
+             				    labelItem->setPos(layout[i] - (layout[i] - layout[i-1])/2 - center.x(), m_rect.bottom() + label_padding);
+             				}
              				if((i+1)%2 && i>1) {
              					QGraphicsRectItem *rectItem = static_cast<QGraphicsRectItem*>(shades.at(i/2-1));
              					rectItem->setRect(layout[i-1],m_rect.top(),layout[i]-layout[i-1],m_rect.height());

src/axis/axisitem_p.h +1 -1

                  void updateLayout(QVector<qreal>& layout);
                  void setLayout(QVector<qreal>& layout);
-                 QStringList createLabels(int ticks, qreal min, qreal max) const;
+                 bool createLabels(QStringList& labels,qreal min, qreal max,int ticks) const;
                  void axisSelected();
              private:

src/axis/qchartaxiscategories.cpp +10 0

                  // TODO Auto-generated destructor stub
              }
+             void QChartAxisCategories::insert(QBarCategory& category)
+             {
+                 int i=1;
+                 foreach(QString string , category){
+                     m_map.insert(i,string);
+                     i++;
+                 }
+                 emit updated();
+             }
              void QChartAxisCategories::insert(qreal value,QString label)
              {
                  m_map.insert(value,label);

src/axis/qchartaxiscategories.h +3 0

              #ifndef QCHARTAXISCATEGORIES_H_
              #define QCHARTAXISCATEGORIES_H_
              #include <qchartglobal.h>
+             #include <qbarseries.h>
              QTCOMMERCIALCHART_BEGIN_NAMESPACE
              public:
                  ~QChartAxisCategories();
+                 void insert(QBarCategory& category);
                  void insert(qreal value,QString label);
                  void remove(qreal value);
                  QString label(qreal value) const;

src/barchart/barchartitem.cpp 0 -34

              //TODO:  connect(series,SIGNAL("position or size has changed"), this, SLOT(handleLayoutChanged()));
                  connect(series, SIGNAL(restructuredBar(int)), this, SLOT(handleModelChanged(int)));
                  setZValue(ChartPresenter::BarSeriesZValue);
-                 initAxisLabels();
                  dataChanged();
              }
                  update();
              }
-             void BarChartItem::initAxisLabels()
+             {
-                 int count = mSeries->categoryCount();
-                 if (0 == count) {
-                     return;
+                 }
-                 Domain* domain = presenter()->dataSet()->domain(mSeries);
-                 qreal min = 0;
-                 qreal max = count+1;
-                 domain->setRangeX(min,max,count+1);
+             }
              //handlers
              void BarChartItem::handleModelChanged(int index)
                  mDomainMinY = minY;
                  mDomainMaxY = maxY;
                  handleLayoutChanged();
-                 /*
-                 int count = mSeries->categoryCount();
-                 if (0 == count) {
-                     return;
+                 }
-                 // Position labels to domain
-                 qreal min = domain.minX();
-                 qreal max = domain.maxX();
-                 qreal step = (max-min)/count;
-                 QChartAxisCategories& categories = mChart->axisX()->categories();
-                 categories.clear();
-                 for (int i=0; i<count; i++) {
-                     categories.insert(min,mSeries->categoryName(i));
-                     min += step;
+                 }
-                 */
              }
              void BarChartItem::handleGeometryChanged(const QRectF& rect)

src/barchart/barchartitem_p.h 0 -3

                  QRectF geometry() const { return m_rect;}
-             protected:
-                 void initAxisLabels();
              public slots:
                  void handleModelChanged(int index);
                  void handleDomainChanged(qreal minX, qreal maxX, qreal minY, qreal maxY);

src/barchart/qbarseries.h +2 0

              QTCOMMERCIALCHART_BEGIN_NAMESPACE
+             typedef QStringList QBarCategory;
              class QBarSet;
              class BarChartModel;
              class BarCategory;

src/chartdataset.cpp +51 -29

              }
              //to be removed with PIMPL
-             void ChartDataSet::calculateDomain(QSeries* series,Domain* domain) const
+             void ChartDataSet::calculateDomain(QSeries* series,Domain* domain)
              {
+                 qreal minX(domain->minX());
+                 qreal minY(domain->minY());
+                 qreal maxX(domain->maxX());
+                 qreal maxY(domain->maxY());
+                 int tickXCount(domain->tickXCount());
+                 int tickYCount(domain->tickYCount());
                  switch(series->type())
                  {
                      case QSeries::SeriesTypeLine:
                          QXYSeries* xySeries = static_cast<QXYSeries*>(series);
-                         qreal minX(domain->minX());
-                         qreal minY(domain->minY());
-                         qreal maxX(domain->maxX());
-                         qreal maxY(domain->maxY());
                          for (int i = 0; i < xySeries->count(); i++)
                          {
                              qreal x = xySeries->x(i);
                              maxX = qMax(maxX, x);
                              maxY = qMax(maxY, y);
                          }
-                         domain->setRange(minX, maxX,  minY,  maxY);
                          break;
                      }
                      case QSeries::SeriesTypeArea: {
                          QAreaSeries* areaSeries = static_cast<QAreaSeries*>(series);
                          QLineSeries* upperSeries = areaSeries->upperSeries();
                          QLineSeries* lowerSeries = areaSeries->lowerSeries();
                          {
                              qreal x = upperSeries->x(i);
                              qreal y = upperSeries->y(i);
-                             domain->setMinX(qMin(domain->minX(),x));
-                             domain->setMinY(qMin(domain->minY(),y));
-                             domain->setMaxX(qMax(domain->maxX(),x));
-                             domain->setMaxY(qMax(domain->maxY(),y));
+                             minX = qMin(minX, x);
+                             minY = qMin(minY, y);
+                             maxX = qMax(maxX, x);
+                             maxY = qMax(maxY, y);
                          }
                          if(lowerSeries) {
                              for (int i = 0; i < lowerSeries->count(); i++)
                              {
                                  qreal x = lowerSeries->x(i);
                                  qreal y = lowerSeries->y(i);
-                                 domain->setMinX(qMin(domain->minX(),x));
-                                 domain->setMinY(qMin(domain->minY(),y));
-                                 domain->setMaxX(qMax(domain->maxX(),x));
-                                 domain->setMaxY(qMax(domain->maxY(),y));
+                                 minX = qMin(minX, x);
+                                 minY = qMin(minY, y);
+                                 maxX = qMax(maxX, x);
+                                 maxY = qMax(maxY, y);
                              }}
                          break;
                      }
                      case QSeries::SeriesTypeBar: {
                          QBarSeries* barSeries = static_cast<QBarSeries*>(series);
                          qreal x = barSeries->categoryCount();
                          qreal y = barSeries->max();
-                         domain->setMinX(qMin(domain->minX(),x));
-                         domain->setMinY(qMin(domain->minY(),y));
-                         domain->setMaxX(qMax(domain->maxX(),x));
-                         domain->setMaxY(qMax(domain->maxY(),y));
+                         minX = qMin(minX, x);
+                         minY = qMin(minY, y);
+                         maxX = qMax(maxX, x);
+                         maxY = qMax(maxY, y);
+                         tickXCount = x+1;
+                         setupCategories(barSeries);
                          break;
                      }
                      case QSeries::SeriesTypeStackedBar: {
                          QStackedBarSeries* stackedBarSeries = static_cast<QStackedBarSeries*>(series);
                          qreal x = stackedBarSeries->categoryCount();
                          qreal y = stackedBarSeries->maxCategorySum();
-                         domain->setMinX(qMin(domain->minX(),x));
-                         domain->setMinY(qMin(domain->minY(),y));
-                         domain->setMaxX(qMax(domain->maxX(),x));
-                         domain->setMaxY(qMax(domain->maxY(),y));
+                         minX = qMin(minX, x);
+                         minY = qMin(minY, y);
+                         maxX = qMax(maxX, x);
+                         maxY = qMax(maxY, y);
+                         tickXCount = x+1;
+                         setupCategories(stackedBarSeries);
                          break;
                      }
                      case QSeries::SeriesTypePercentBar: {
                          QPercentBarSeries* percentBarSeries = static_cast<QPercentBarSeries*>(series);
                          qreal x = percentBarSeries->categoryCount();
-                         domain->setMinX(qMin(domain->minX(),x));
-                         domain->setMinY(0);
-                         domain->setMaxX(qMax(domain->maxX(),x));
-                         domain->setMaxY(100);
+                         minX = qMin(minX, x);
+                         maxX = qMax(maxX, x);
+                         minY = 0;
+                         maxY = 100;
+                         setupCategories(percentBarSeries);
                          break;
                      }
                      }
                  }
+                 domain->setRangeX(minX,maxX,tickXCount);
+                 domain->setRangeY(minY,maxY,tickYCount);
+             }
+             void ChartDataSet::setupCategories(QBarSeries* series)
+             {
+                int count = series->categoryCount();
+                QChartAxisCategories* categories = axisX()->categories();
+                categories->clear();
+                for (int i=1; i<=count; i++) {
+                    categories->insert(i,series->categoryName(i-1));
+                }
              }
              void ChartDataSet::zoomInDomain(const QRectF& rect, const QSizeF& size)

src/chartdataset_p.h +3 -1

              QTCOMMERCIALCHART_BEGIN_NAMESPACE
              class QChartAxis;
+             class QBarSeries;
              class ChartDataSet : public QObject
              {
              private:
                  QStringList createLabels(QChartAxis* axis,qreal min, qreal max);
-                 void calculateDomain(QSeries* series,Domain* domain) const;
+                 void calculateDomain(QSeries* series,Domain* domain);
+                 void setupCategories(QBarSeries* series);
              private:
                  QMap<QSeries*, QChartAxis*> m_seriesAxisMap;

src/chartpresenter_p.h +1 -1

                      BackgroundZValue = -1,
                      ShadesZValue,
                      GridZValue,
-                     AxisZValue,
                      LineChartZValue,
                      BarSeriesZValue,
                      ScatterSeriesZValue,
                      PieSeriesZValue,
+                     AxisZValue,
                      LegendZValue
                  };

	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