HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r497:9455cddd70de

Adds draft of axis bar label support

Michal Klocek -

r497:9455cddd70de

parent child

Context file:

r497:9455cddd70de

Collapse all files

src/axis/axisitem.cpp +19 -15

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

src/axis/axisitem_p.h +2 -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(QChartAxis* axis,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 handleAxisUpdated();//qchartaxis update calls
+                void handleAxisCategoriesUpdated();//qchartaxis update calls
                 void handleRangeChanged(qreal min , qreal max); //domain update calls
-                void handleTicksCountChanged(int ticks); //ticks changed
                 void handleGeometryChanged(const QRectF& size); //geometry update calls
             public:
                 virtual void updateItem();
                 QVector<qreal> calculateLayout() const;
                 void setLayout(const QVector<qreal>& points);
                 QVector<qreal> layout() { return m_layoutVector;};
             private:
                 inline bool isEmpty();
                 void clear(int count);
                 void createItems(int count);
                 QStringList createLabels(int ticks, qreal min, qreal max);
             private:
                 QChartAxis* m_chartAxis;
                 AxisType m_type;
                 QRectF m_rect;
                 int m_labelsAngle;
                 QGraphicsItemGroup m_grid;
                 QGraphicsItemGroup m_shades;
                 QGraphicsItemGroup m_labels;
                 QGraphicsItemGroup m_axis;
                 QStringList m_thicksList;
                 QVector<qreal> m_layoutVector;
                 qreal m_min;
                 qreal m_max;
                 int m_ticks;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif /* AXISITEM_H_ */

src/axis/qchartaxis.h +1 -1

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

src/axis/qchartaxiscategories.cpp +5 0

             #include "qchartaxiscategories.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             QChartAxisCategories::QChartAxisCategories()
             {
                 // TODO Auto-generated constructor stub
             }
             QChartAxisCategories::~QChartAxisCategories()
             {
                 // TODO Auto-generated destructor stub
             }
             void QChartAxisCategories::insert(qreal value,QString label)
             {
                 m_map.insert(value,label);
                 emit updated();
             }
             void QChartAxisCategories::remove(qreal value)
             {
                 m_map.remove(value);
                 emit updated();
             }
             void QChartAxisCategories::clear()
             {
                 m_map.clear();
                 emit updated();
             }
             int QChartAxisCategories::count()
             {
                 return m_map.count();
                 emit updated();
             }
+            QString QChartAxisCategories::label(qreal value) const
+            {
+                return m_map.value(value);
+            }
             #include "moc_qchartaxiscategories.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/qchartaxiscategories.h +1 0

             #ifndef QCHARTAXISCATEGORIES_H_
             #define QCHARTAXISCATEGORIES_H_
             #include "qchartglobal.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QTCOMMERCIALCHART_EXPORT QChartAxisCategories : public QObject
             {
                 Q_OBJECT
             private:
                 QChartAxisCategories();
             public:
                 ~QChartAxisCategories();
                 void insert(qreal value,QString label);
                 void remove(qreal value);
+                QString label(qreal value) const;
                 void clear();
                 int count();
             //internal signal
             signals:
                 void updated();
             private:
                 QMap<qreal,QString> m_map;
             friend class QChartAxis;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif /* QCHARTAXISCATEGORIES_H_ */

src/barchart/barpresenterbase.cpp +8 -8

             #include "barpresenterbase_p.h"
             #include "bar_p.h"
             #include "barvalue_p.h"
             #include "separator_p.h"
             #include "qbarset.h"
             #include "qbarseries.h"
             #include "qchart.h"
             #include "qchartaxis.h"
             #include "qchartaxiscategories.h"
             #include <QDebug>
             #include <QToolTip>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             BarPresenterBase::BarPresenterBase(QBarSeries *series, QChart *parent)
                 : ChartItem(parent)
                 ,mLayoutSet(false)
                 ,mSeparatorsEnabled(false)
                 ,mSeries(series)
                 ,mChart(parent)
             {
                 connect(series,SIGNAL(showToolTip(QPoint,QString)),this,SLOT(showToolTip(QPoint,QString)));
                 initAxisLabels();
                 dataChanged();
             }
             BarPresenterBase::~BarPresenterBase()
             {
                 disconnect(this,SLOT(showToolTip(QPoint,QString)));
             }
             void BarPresenterBase::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 if (!mLayoutSet) {
                     qDebug() << "BarPresenterBase::paint called without layout set. Aborting.";
                     return;
                 }
                 foreach(QGraphicsItem* i, childItems()) {
                     i->paint(painter,option,widget);
                 }
             }
             QRectF BarPresenterBase::boundingRect() const
             {
                 return QRectF(0,0,mWidth,mHeight);
             }
             void BarPresenterBase::dataChanged()
             {
                 // TODO: performance optimizations. Do we really need to delete and create items every time data is changed or can we reuse them?
                 // Delete old bars
                 foreach (QGraphicsItem* item, childItems()) {
                     delete item;
                 }
                 mBars.clear();
                 mSeparators.clear();
                 mFloatingValues.clear();
                 // Create new graphic items for bars
                 for (int c=0; c<mSeries->categoryCount(); c++) {
                     QString category = mSeries->categoryName(c);
                     for (int s=0; s<mSeries->barsetCount(); s++) {
                         QBarSet *set = mSeries->barsetAt(s);
                         Bar *bar = new Bar(category,this);
                         childItems().append(bar);
                         mBars.append(bar);
                         connect(bar,SIGNAL(clicked(QString)),set,SIGNAL(clicked(QString)));
                         connect(bar,SIGNAL(rightClicked(QString)),set,SIGNAL(rightClicked(QString)));
                         connect(bar,SIGNAL(hoverEntered(QPoint)),set,SLOT(barHoverEnterEvent(QPoint)));
                         connect(bar,SIGNAL(hoverLeaved()),set,SLOT(barHoverLeaveEvent()));
                     }
                 }
                 // Create separators
                 int count = mSeries->categoryCount() - 1;   // There is one less separator than columns
                 for (int i=0; i<count; i++) {
                     Separator* sep = new Separator(this);
                     sep->setColor(QColor(255,0,0,255));     // TODO: color for separations from theme
                     sep->setVisible(mSeparatorsEnabled);
                     childItems().append(sep);
                     mSeparators.append(sep);
                 }
                 // Create floating values
                 for (int category=0; category<mSeries->categoryCount(); category++) {
                     for (int s=0; s<mSeries->barsetCount(); s++) {
                         QBarSet *set = mSeries->barsetAt(s);
                         BarValue *value = new BarValue(*set, this);
                         childItems().append(value);
                         mFloatingValues.append(value);
                         connect(set,SIGNAL(toggleFloatingValues()),value,SLOT(toggleVisible()));
                     }
                 }
             }
             void BarPresenterBase::initAxisLabels()
             {
                 int count = mSeries->categoryCount();
                 if (0 == count) {
                     return;
                 }
+                count++;
                 mChart->axisX()->setTicksCount(count);
                 qreal min = 0;
-                qreal max = mSeries->categoryCount();
+                qreal max = count;
                 mChart->axisX()->setMin(min);
                 mChart->axisX()->setMax(max);
-                qreal step = (max-min)/count;
+                min++;
-                QChartAxisCategories& categories = mChart->axisX()->categories();
+                QChartAxisCategories* categories = mChart->axisX()->categories();
-                categories.clear();
+                categories->clear();
-                for (int i=0; i<count; i++) {
+                for (int i=0; i<count-1; i++) {
-                    qDebug() << "initAxisLabels" << min << mSeries->categoryName(i);
+                    categories->insert(min,mSeries->categoryName(i));
-                    categories.insert(min,mSeries->categoryName(i));
+                    min++;
-                    min += step;
                 }
                 mChart->axisX()->setLabelsVisible(true);
             }
             //handlers
             void BarPresenterBase::handleModelChanged(int index)
             {
             //    qDebug() << "BarPresenterBase::handleModelChanged" << index;
                 dataChanged();
             }
             void BarPresenterBase::handleDomainChanged(const Domain& domain)
             {
                 qDebug() << "BarPresenterBase::handleDomainChanged";
                 /*
                 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 BarPresenterBase::handleGeometryChanged(const QRectF& rect)
             {
                 mWidth = rect.width();
                 mHeight = rect.height();
                 layoutChanged();
                 mLayoutSet = true;
                 setPos(rect.topLeft());
             }
             void BarPresenterBase::showToolTip(QPoint pos, QString tip)
             {
                 // TODO: cool tooltip instead of default
                 QToolTip::showText(pos,tip);
             }
             void BarPresenterBase::enableSeparators(bool enabled)
             {
                 for (int i=0; i<mSeparators.count(); i++) {
                     mSeparators.at(i)->setVisible(enabled);
                 }
                 mSeparatorsEnabled = enabled;
             }
             #include "moc_barpresenterbase_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/chartpresenter.cpp +1 -2

             #include "qchart.h"
             #include "qchartaxis.h"
             #include "chartpresenter_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             //series
             #include "qbarseries.h"
             #include "qstackedbarseries.h"
             #include "qpercentbarseries.h"
             #include "qlineseries.h"
             #include "qareaseries.h"
             #include "qpieseries.h"
             #include "qscatterseries.h"
             #include "qsplineseries.h"
             //items
             #include "axisitem_p.h"
             #include "axisanimationitem_p.h"
             #include "areachartitem_p.h"
             #include "barpresenter_p.h"
             #include "stackedbarpresenter_p.h"
             #include "percentbarpresenter_p.h"
             #include "linechartitem_p.h"
             #include "piepresenter_p.h"
             #include "scatterchartitem_p.h"
             #include "splinechartitem_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartPresenter::ChartPresenter(QChart* chart,ChartDataSet* dataset):QObject(chart),
                 m_chart(chart),
                 m_dataset(dataset),
                 m_chartTheme(0),
                 m_zoomIndex(0),
                 m_marginSize(0),
                 m_rect(QRectF(QPoint(0,0),m_chart->size())),
                 m_options(QChart::NoAnimation)
             {
                 createConnections();
                 setChartTheme(QChart::ChartThemeDefault);
             }
             ChartPresenter::~ChartPresenter()
             {
             }
             void ChartPresenter::createConnections()
             {
                 QObject::connect(m_chart,SIGNAL(geometryChanged()),this,SLOT(handleGeometryChanged()));
                 QObject::connect(m_dataset,SIGNAL(seriesAdded(QSeries*,Domain*)),this,SLOT(handleSeriesAdded(QSeries*,Domain*)));
                 QObject::connect(m_dataset,SIGNAL(seriesRemoved(QSeries*)),this,SLOT(handleSeriesRemoved(QSeries*)));
                 QObject::connect(m_dataset,SIGNAL(axisAdded(QChartAxis*,Domain*)),this,SLOT(handleAxisAdded(QChartAxis*,Domain*)));
                 QObject::connect(m_dataset,SIGNAL(axisRemoved(QChartAxis*)),this,SLOT(handleAxisRemoved(QChartAxis*)));
             }
             QRectF ChartPresenter::geometry() const
             {
                 return m_rect;
             }
             void ChartPresenter::handleGeometryChanged()
             {
                 QRectF rect(QPoint(0,0),m_chart->size());
                 rect.adjust(m_marginSize,m_marginSize, -m_marginSize, -m_marginSize);
                 //rewrite zoom stack
                 for(int i=0;i<m_zoomStack.count();i++){
                     QRectF r = m_zoomStack[i];
                     qreal w = rect.width()/m_rect.width();
                     qreal h = rect.height()/m_rect.height();
                     QPointF tl = r.topLeft();
                     tl.setX(tl.x()*w);
                     tl.setY(tl.y()*h);
                     QPointF br = r.bottomRight();
                     br.setX(br.x()*w);
                     br.setY(br.y()*h);
                     r.setTopLeft(tl);
                     r.setBottomRight(br);
                     m_zoomStack[i]=r;
                 }
                 m_rect = rect;
                 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,Domain* domain)
             {
                 AxisItem* item ;
                 if(!m_options.testFlag(QChart::GridAxisAnimations))
                 {
                     item = new AxisItem(axis,axis==m_dataset->axisX()?AxisItem::X_AXIS : AxisItem::Y_AXIS,m_chart);
                 }else{
                     item = new AxisAnimationItem(axis,axis==m_dataset->axisX()?AxisItem::X_AXIS : AxisItem::Y_AXIS,m_chart);
                 }
                 if(axis==m_dataset->axisX()){
                     QObject::connect(domain,SIGNAL(rangeXChanged(qreal,qreal)),item,SLOT(handleRangeChanged(qreal,qreal)));
                     //initialize
                     item->handleRangeChanged(domain->minX(),domain->maxX());
-                    item->handleTicksCountChanged(4);
                 }
                 else{
                     QObject::connect(domain,SIGNAL(rangeYChanged(qreal,qreal)),item,SLOT(handleRangeChanged(qreal,qreal)));
                     //initialize
                     item->handleRangeChanged(domain->minY(),domain->maxY());
-                    item->handleTicksCountChanged(4);
                 }
                 QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),item,SLOT(handleGeometryChanged(const QRectF&)));
                 //initialize
                 item->handleGeometryChanged(m_rect);
                 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(QSeries* series,Domain* domain)
             {
                 switch(series->type())
                 {
                 case QSeries::SeriesTypeLine: {
                     QLineSeries* lineSeries = static_cast<QLineSeries*>(series);
                     LineChartItem* item;
                     if(m_options.testFlag(QChart::SeriesAnimations)){
                         item = new  LineChartAnimationItem(lineSeries,m_chart);
                     }else{
                         item = new LineChartItem(lineSeries,m_chart);
                     }
                     QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),item,SLOT(handleGeometryChanged(const QRectF&)));
                     QObject::connect(domain,SIGNAL(domainChanged(qreal,qreal,qreal,qreal)),item,SLOT(handleDomainChanged(qreal,qreal,qreal,qreal)));
                     //initialize
                     item->handleDomainChanged(domain->minX(),domain->maxX(),domain->minY(),domain->maxY());
                     if(m_rect.isValid()) item->handleGeometryChanged(m_rect);
                     //decorate
                     m_chartTheme->decorate(item,lineSeries,m_chartItems.count());
                     m_chartItems.insert(series,item);
                     break;
                 }
                 case QSeries::SeriesTypeArea: {
                     QAreaSeries* areaSeries = static_cast<QAreaSeries*>(series);
                     AreaChartItem* item;
                     if(m_options.testFlag(QChart::SeriesAnimations)) {
                         item = new AreaChartItem(areaSeries,m_chart);
                     }
                     else {
                         item = new AreaChartItem(areaSeries,m_chart);
                     }
                     QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),item,SLOT(handleGeometryChanged(const QRectF&)));
                     QObject::connect(domain,SIGNAL(domainChanged(qreal,qreal,qreal,qreal)),item,SLOT(handleDomainChanged(qreal,qreal,qreal,qreal)));
                     //initialize
                      item->handleDomainChanged(domain->minX(),domain->maxX(),domain->minY(),domain->maxY());
                      if(m_rect.isValid()) item->handleGeometryChanged(m_rect);
                      //decorate
                     m_chartTheme->decorate(item,areaSeries,m_chartItems.count());
                     m_chartItems.insert(series,item);
                     break;
                 }
                 case QSeries::SeriesTypeBar: {
                     QBarSeries* barSeries = static_cast<QBarSeries*>(series);
                     BarPresenter* item = new BarPresenter(barSeries,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);
                     if(m_rect.isValid()) item->handleGeometryChanged(m_rect);
                     break;
                 }
                 case QSeries::SeriesTypeStackedBar: {
                     QStackedBarSeries* stackedBarSeries = static_cast<QStackedBarSeries*>(series);
                     StackedBarPresenter* item = new StackedBarPresenter(stackedBarSeries,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);
                     if(m_rect.isValid()) item->handleGeometryChanged(m_rect);
                     break;
                 }
                 case QSeries::SeriesTypePercentBar: {
                     QPercentBarSeries* percentBarSeries = static_cast<QPercentBarSeries*>(series);
                     PercentBarPresenter* item = new PercentBarPresenter(percentBarSeries,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);
                     if(m_rect.isValid()) item->handleGeometryChanged(m_rect);
                     break;
                 }
                 case QSeries::SeriesTypeScatter: {
             			QScatterSeries *scatterSeries = qobject_cast<QScatterSeries *>(series);
             			ScatterChartItem *item;
             			if(m_options.testFlag(QChart::SeriesAnimations)) {
             				item = new ScatterChartAnimationItem(scatterSeries,m_chart);
             			} else {
             				item = new ScatterChartItem(scatterSeries, m_chart);
             			}
             			QObject::connect(this, SIGNAL(geometryChanged(const QRectF&)),
             					item, SLOT(handleGeometryChanged(const QRectF&)));
             			QObject::connect(domain, SIGNAL(domainChanged(qreal,qreal,qreal,qreal)),
             					item, SLOT(handleDomainChanged(qreal,qreal,qreal,qreal)));
             			//initialize
             			if (m_rect.isValid())
             			item->handleGeometryChanged(m_rect);
             			item->handleDomainChanged(domain->minX(), domain->maxX(), domain->minY(), domain->maxY());
             			//decorate
             			m_chartTheme->decorate(item, scatterSeries, m_chartItems.count());
             			m_chartItems.insert(scatterSeries, item);
             			break;
             		}
                 case QSeries::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&)));
                     // Hide all from background when there is only piechart
                     // TODO: refactor this ugly code... should be one setting for this
                     if (m_chartItems.count() == 0) {
                         m_chart->axisX()->setAxisVisible(false);
                         m_chart->axisY()->setAxisVisible(false);
                         m_chart->axisX()->setGridVisible(false);
                         m_chart->axisY()->setGridVisible(false);
                         m_chart->axisX()->setLabelsVisible(false);
                         m_chart->axisY()->setLabelsVisible(false);
                         m_chart->axisX()->setShadesVisible(false);
                         m_chart->axisY()->setShadesVisible(false);
                         m_chart->setChartBackgroundBrush(Qt::transparent);
                     }
                     m_chartItems.insert(series, pie);
                     pie->handleGeometryChanged(m_rect);
                     break;
                 }
                 case QSeries::SeriesTypeSpline: {
             			QSplineSeries* splineSeries = qobject_cast<QSplineSeries*>(series);
             			SplineChartItem* item;
             			if(m_options.testFlag(QChart::SeriesAnimations)) {
             				item = new SplineChartAnimationItem(splineSeries, m_chart);
             			} else {
             				item = new SplineChartItem(splineSeries, m_chart);
             			}
             			QObject::connect(this, SIGNAL(geometryChanged(const QRectF&)), item, SLOT(handleGeometryChanged(const QRectF&)));
             			QObject::connect(domain,SIGNAL(domainChanged(qreal,qreal,qreal,qreal)),item,SLOT(handleDomainChanged(qreal,qreal,qreal,qreal)));
             			//initialize
             			item->handleDomainChanged(domain->minX(),domain->maxX(),domain->minY(),domain->maxY());
             			if(m_rect.isValid()) item->handleGeometryChanged(m_rect);
             			//decorate
             			m_chartTheme->decorate(item, splineSeries, m_chartItems.count());
             			m_chartItems.insert(splineSeries, item);
             			break;
             		}
                 default: {
                     qDebug()<< "Series type" << series->type() << "not implemented.";
                     break;
                 }
                 }
                 zoomReset();
             }
             void ChartPresenter::handleSeriesRemoved(QSeries* series)
             {
                 ChartItem* item = m_chartItems.take(series);
                 delete item;
             }
             void ChartPresenter::setChartTheme(QChart::ChartTheme theme)
             {
                 delete m_chartTheme;
                 m_chartTheme = ChartTheme::createTheme(theme);
                 m_chartTheme->decorate(m_chart);
                 QMapIterator<QSeries*,ChartItem*> i(m_chartItems);
                 int index=0;
                 while (i.hasNext()) {
                     i.next();
                     m_chartTheme->decorate(i.value(),i.key(),index);
                     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();
             }
             void ChartPresenter::setAnimationOptions(QChart::AnimationOptions options)
             {
                 if(m_options!=options) {
                     m_options=options;
                     //recreate elements
                     QList<QChartAxis*> axisList = m_axisItems.uniqueKeys();
                     QList<QSeries*> seriesList = m_chartItems.uniqueKeys();
                     foreach(QChartAxis* axis, axisList) {
                         handleAxisRemoved(axis);
                         handleAxisAdded(axis,m_dataset->domain(axis));
                     }
                     foreach(QSeries* series, seriesList) {
                         handleSeriesRemoved(series);
                         handleSeriesAdded(series,m_dataset->domain(series));
                     }
                 }
             }
             void ChartPresenter::zoomIn()
             {
             	QRectF rect = geometry();
             	rect.setWidth(rect.width()/2);
             	rect.setHeight(rect.height()/2);
             	rect.moveCenter(geometry().center());
             	zoomIn(rect);
             }
             void ChartPresenter::zoomIn(const QRectF& rect)
             {
             	QRectF r = rect.normalized();
             	r.translate(-m_marginSize, -m_marginSize);
             	m_dataset->zoomInDomain(r,geometry().size());
             	m_zoomStack<<r;
             	m_zoomIndex++;
             }
             void ChartPresenter::zoomOut()
             {
             	if(m_zoomIndex==0) return;
             	m_dataset->zoomOutDomain(m_zoomStack[m_zoomIndex-1],geometry().size());
             	m_zoomIndex--;
             	m_zoomStack.resize(m_zoomIndex);
             }
             void ChartPresenter::zoomReset()
             {
                 m_zoomIndex=0;
                 m_zoomStack.resize(m_zoomIndex);
             }
             QChart::AnimationOptions ChartPresenter::animationOptions() const
             {
                 return m_options;
             }
             #include "moc_chartpresenter_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

General Comments 0

Write
Preview

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

No TODOs yet

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

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