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

Adds back reimplemnted categories handling

Michal Klocek -

r701:0d46cd22e84d

parent child

Context file:

r701:0d46cd22e84d

Collapse all files

src/axis/axisitem.cpp +22 -9

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

src/axis/axisitem_p.h +1 -1

             #ifndef AXISITEM_H_
             #define AXISITEM_H_
             #include "domain_p.h"
             #include "chart_p.h"
             #include <QGraphicsItem>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QChartAxis;
             class ChartPresenter;
             class Axis : public Chart
             {
                 Q_OBJECT
             public:
                 enum AxisType{X_AXIS,Y_AXIS};
                 Axis(QChartAxis* axis,ChartPresenter* presenter,AxisType type = X_AXIS);
                 ~Axis();
                 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);
                 inline QRectF geometry() const { return m_rect; }
                 inline QVector<qreal> layout() { return m_layoutVector;};
             public slots:
                 void handleAxisUpdated();
                 void handleAxisCategoriesUpdated();
                 void handleRangeChanged(qreal min , qreal max,int tickCount);
                 void handleGeometryChanged(const QRectF& size);
             private:
                 inline bool isEmpty();
                 void createItems(int count);
                 void deleteItems(int count);
                 QVector<qreal> calculateLayout() const;
                 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:
                 QChartAxis* m_chartAxis;
                 AxisType m_type;
                 QRectF m_rect;
                 int m_labelsAngle;
                 QGraphicsItemGroup m_grid;
                 QGraphicsItemGroup m_shades;
                 QGraphicsItemGroup m_labels;
                 QGraphicsItemGroup m_axis;
                 QVector<qreal> m_layoutVector;
                 qreal m_min;
                 qreal m_max;
                 int m_ticksCount;
                 qreal m_zoomFactor;
                 friend class AxisAnimation;
                 friend class AxisItem;
             };
             class AxisItem: public QGraphicsLineItem
             {
             public:
                 AxisItem(Axis* axis,QGraphicsItem* parent=0):QGraphicsLineItem(parent),m_axis(axis){};
             protected:
                void mousePressEvent(QGraphicsSceneMouseEvent *event)
                {
                    Q_UNUSED(event)
                    m_axis->axisSelected();
                }
                QRectF boundingRect() const
                {
                   return shape().boundingRect();
                }
                QPainterPath shape() const
                {
                    QPainterPath path = QGraphicsLineItem::shape();
                    QRectF rect = path.boundingRect();
                    path.addRect(rect.adjusted(0,0,m_axis->axisType()!=Axis::X_AXIS?8:0,m_axis->axisType()!=Axis::Y_AXIS?8:0));
                    return path;
                }
             private:
                Axis* m_axis;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif /* AXISITEM_H_ */

src/axis/qchartaxiscategories.cpp +10 0

             #include "qchartaxiscategories.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             QChartAxisCategories::QChartAxisCategories()
             {
                 // TODO Auto-generated constructor stub
             }
             QChartAxisCategories::~QChartAxisCategories()
             {
                 // 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);
                 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 +3 0

             #ifndef QCHARTAXISCATEGORIES_H_
             #define QCHARTAXISCATEGORIES_H_
             #include <qchartglobal.h>
+            #include <qbarseries.h>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QTCOMMERCIALCHART_EXPORT QChartAxisCategories : public QObject
             {
                 Q_OBJECT
             private:
                 QChartAxisCategories();
             public:
                 ~QChartAxisCategories();
+                void insert(QBarCategory& category);
                 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/barchartitem.cpp 0 -34

             #include "barchartitem_p.h"
             #include "bar_p.h"
             #include "barvalue_p.h"
             #include "qbarset.h"
             #include "qbarseries.h"
             #include "qchart.h"
             #include "qchartaxis.h"
             #include "qchartaxiscategories.h"
             #include "chartpresenter_p.h"
             #include "chartanimator_p.h"
             #include "chartdataset_p.h"
             #include <QDebug>
             #include <QToolTip>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             BarChartItem::BarChartItem(QBarSeries *series, ChartPresenter *presenter) :
                 ChartItem(presenter),
                 mLayoutSet(false),
                 mSeries(series)
             {
                 connect(series,SIGNAL(showToolTip(QPoint,QString)),this,SLOT(showToolTip(QPoint,QString)));
                 connect(series, SIGNAL(updatedBars()), this, SLOT(handleLayoutChanged()));
             //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();
             }
             BarChartItem::~BarChartItem()
             {
                 disconnect(this,SLOT(showToolTip(QPoint,QString)));
             }
             void BarChartItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 if (!mLayoutSet) {
                     qDebug() << "BarChartItem::paint called without layout set. Aborting.";
                     return;
                 }
                 foreach(QGraphicsItem* i, childItems()) {
                     i->paint(painter,option,widget);
                 }
             }
             QRectF BarChartItem::boundingRect() const
             {
                 return m_rect;
             }
             void BarChartItem::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();
                 mFloatingValues.clear();
                 mLayout.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()));
                         mLayout.append(QRectF(0,0,0,0));
                     }
                 }
                 // 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()));
                     }
                 }
             }
             QVector<QRectF> BarChartItem::calculateLayout()
             {
                 QVector<QRectF> layout;
                 // Use temporary qreals for accurancy (we might get some compiler warnings... :)
                 qreal categoryCount = mSeries->categoryCount();
                 qreal setCount = mSeries->barsetCount();
                 qreal width = geometry().width();
                 qreal height = geometry().height();
                 qreal max = mSeries->max();
                 // Domain:
                 if (mDomainMaxY > max) {
                     max = mDomainMaxY;
                 }
                 qreal scale = (height/max);
                 qreal categoryWidth = width/categoryCount;
                 qreal barWidth = categoryWidth / (setCount+1);
                 int itemIndex(0);
                 for (int category=0; category < categoryCount; category++) {
                     qreal xPos = categoryWidth * category + barWidth/2;
                     qreal yPos = height;
                     for (int set = 0; set < setCount; set++) {
                         qreal barHeight = mSeries->valueAt(set,category) * scale;
                         Bar* bar = mBars.at(itemIndex);
                         QRectF rect(xPos,yPos-barHeight,barWidth,barHeight);
                         layout.append(rect);
                         bar->setPen(mSeries->barsetAt(set)->pen());
                         bar->setBrush(mSeries->barsetAt(set)->brush());
                         itemIndex++;
                         xPos += barWidth;
                     }
                 }
                 // Position floating values
                 itemIndex = 0;
                 for (int category=0; category < mSeries->categoryCount(); category++) {
                     qreal xPos = categoryWidth * category  + barWidth;
                     qreal yPos = height;
                     for (int set=0; set < mSeries->barsetCount(); set++) {
                         qreal barHeight = mSeries->valueAt(set,category) * scale;
                         BarValue* value = mFloatingValues.at(itemIndex);
                         QBarSet* barSet = mSeries->barsetAt(set);
                         value->resize(100,50);  // TODO: proper layout for this.
                         value->setPos(xPos, yPos-barHeight/2);
                         value->setPen(barSet->floatingValuePen());
                         if (mSeries->valueAt(set,category) != 0) {
                             value->setValueString(QString::number(mSeries->valueAt(set,category)));
                         } else {
                             value->setValueString(QString(""));
                         }
                         itemIndex++;
                         xPos += barWidth;
                     }
                 }
                 return layout;
             }
             void BarChartItem::applyLayout(const QVector<QRectF> &layout)
             {
                 if (animator())
                     animator()->updateLayout(this, mLayout, layout);
                 else
                     setLayout(layout);
             }
             void BarChartItem::setLayout(const QVector<QRectF> &layout)
             {
                 mLayout = layout;
                 for (int i=0; i<mBars.count(); i++) {
                     mBars.at(i)->setRect(layout.at(i));
                 }
                 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)
             {
                 Q_UNUSED(index)
                 dataChanged();
             }
             void BarChartItem::handleDomainChanged(qreal minX, qreal maxX, qreal minY, qreal maxY)
             {
                 mDomainMinX = minX;
                 mDomainMaxX = maxX;
                 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)
             {
                 m_rect=rect;
                 handleLayoutChanged();
                 mLayoutSet = true;
                 setPos(rect.topLeft());
             }
             void BarChartItem::handleLayoutChanged()
             {
                 QVector<QRectF> layout = calculateLayout();
                 applyLayout(layout);
                 update();
             }
             void BarChartItem::showToolTip(QPoint pos, QString tip)
             {
                 // TODO: cool tooltip instead of default
                 QToolTip::showText(pos,tip);
             }
             #include "moc_barchartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/barchartitem_p.h 0 -3

             #ifndef BARCHARTITEM_H
             #define BARCHARTITEM_H
             #include "chartitem_p.h"
             #include "qbarseries.h"
             #include <QPen>
             #include <QBrush>
             #include <QGraphicsItem>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class Bar;
             class BarValue;
             class QChartAxisCategories;
             class QChart;
             //typedef QVector<QRectF> BarLayout;
             class BarChartItem : public ChartItem
             {
                 Q_OBJECT
             public:
                 BarChartItem(QBarSeries *series, ChartPresenter *presenter);
                 virtual ~BarChartItem();
             // Common implemantation of different presenters. Not to be instantiated.
             // TODO: combine this with BarPresenter and derive other presenters from it?
             public:
                 // From QGraphicsItem
                 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
                 QRectF boundingRect() const;
                 // TODO: Consider the domain for layoutChanged. May be use case, may not be. If it is, then the derived classes need to implement it
                 virtual void dataChanged();     // data of series has changed -> need to recalculate bar sizes
             private slots:
             public:
                 virtual QVector<QRectF> calculateLayout();
                 void applyLayout(const QVector<QRectF> &layout);
                 void setLayout(const QVector<QRectF> &layout);
                 void updateLayout(const QVector<QRectF> &layout);
                 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);
                 void handleGeometryChanged(const QRectF& size);
                 void handleLayoutChanged();
                 // Internal slots
                 void showToolTip(QPoint pos, QString tip);      // shows tooltip (if enabled)
             protected:
                 // TODO: consider these.
                 qreal mDomainMinX;
                 qreal mDomainMaxX;
                 qreal mDomainMinY;
                 qreal mDomainMaxY;
                 QRectF m_rect;
                 bool mLayoutSet;    // True, if component has been laid out.
                 QVector<QRectF> mLayout;
                 // Not owned.
                 QBarSeries* mSeries;
                 QList<Bar*> mBars;
                 QList<BarValue*> mFloatingValues;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // BARCHARTITEM_H

src/barchart/qbarseries.h +2 0

             #ifndef BARSERIES_H
             #define BARSERIES_H
             #include <qseries.h>
             #include <QStringList>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
+            typedef QStringList QBarCategory;
             class QBarSet;
             class BarChartModel;
             class BarCategory;
             // Container for series
             class QTCOMMERCIALCHART_EXPORT QBarSeries : public QSeries
             {
                 Q_OBJECT
             public:
                 QBarSeries(QStringList categories, QObject* parent=0);
                 virtual QSeriesType type() const { return QSeries::SeriesTypeBar; }
                 void addBarSet(QBarSet *set);               // Takes ownership of set
                 void removeBarSet(QBarSet *set);            // Releases ownership, doesn't delete set
                 void insertBarSet(int i, QBarSet *set);
                 void insertCategory(int i, QString category);
                 void removeCategory(int i);
                 int barsetCount();
                 int categoryCount();
                 QList<QBarSet*> barSets();
                 bool setModel(QAbstractItemModel* model);
                 QAbstractItemModel* modelExt() {return m_model;}
                 void setModelMapping(int categories, int bottomBoundry, int topBoundry, Qt::Orientation orientation = Qt::Vertical);
             public:
                 // TODO: Functions below this are not part of api and will be moved
                 // to private implementation, when we start using it
                 // TODO: TO PIMPL --->
                 QBarSet* barsetAt(int index);
                 QString categoryName(int category);
                 qreal min();
                 qreal max();
                 qreal valueAt(int set, int category);
                 qreal percentageAt(int set, int category);
                 qreal categorySum(int category);
                 qreal maxCategorySum();
                 BarChartModel& model();
                 // <--- TO PIMPL
             signals:
                 //void changed(int index);
                 void clicked(QBarSet* barset, QString category);        // Up to user of api, what to do with these signals
                 void rightClicked(QBarSet* barset, QString category);
                 //
                 void updatedBars();
                 void restructuredBar(int);
                 // TODO: internal signals, these to private implementation.
                 // TODO: TO PIMPL --->
                 void showToolTip(QPoint pos, QString tip);
                 // <--- TO PIMPL
             public Q_SLOTS:
                 void setToolTipEnabled(bool enabled=true);           // enables tooltips
                 // TODO: TO PIMPL --->
                 void barsetClicked(QString category);
                 void barsetRightClicked(QString category);
                 // <--- TO PIMPL
             private Q_SLOTS:
                 // slots for updating bars when data in model changes
                 void modelUpdated(QModelIndex topLeft, QModelIndex bottomRight);
                 void modelDataAdded(QModelIndex parent, int start, int end);
                 void modelDataRemoved(QModelIndex parent, int start, int end);
                 void barsetChanged();
             protected:
                 BarChartModel* mModel;
             //    QAbstractItemModel* m_model;
                 int m_mapCategories;
                 int m_mapBarBottom;
                 int m_mapBarTop;
                 Qt::Orientation m_mapOrientation;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // BARSERIES_H

src/chartdataset.cpp +51 -29

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

src/chartdataset_p.h +3 -1

             #ifndef CHARTDATASET_P_H_
             #define CHARTDATASET_P_H_
             #include "qseries.h"
             #include "domain_p.h"
             #include <QVector>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QChartAxis;
+            class QBarSeries;
             class ChartDataSet : public QObject
             {
                 Q_OBJECT
             public:
                 ChartDataSet(QObject* parent=0);
                 virtual ~ChartDataSet();
                 void addSeries(QSeries* series,QChartAxis *axisY = 0);
                 void removeSeries(QSeries* series);
                 void removeAllSeries();
                 void zoomInDomain(const QRectF& rect, const QSizeF& size);
                 void zoomOutDomain(const QRectF& rect, const QSizeF& size);
                 void scrollDomain(int dx,int dy,const QSizeF& size);
                 int seriesCount(QSeries::QSeriesType type);
                 int seriesIndex(QSeries *series);
                 Domain* domain(QSeries* series) const;
                 Domain* domain(QChartAxis* axis) const;
                 QChartAxis* axis(QSeries* series) const;
                 QChartAxis* axisX() const { return m_axisX;};
                 QChartAxis* axisY(QSeries* series = 0) const;
             signals:
                 void seriesAdded(QSeries* series,Domain* domain);
                 void seriesRemoved(QSeries* series);
                 void axisAdded(QChartAxis* axis,Domain* domain);
                 void axisRemoved(QChartAxis* axis);
             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;
                 QMap<QChartAxis*, Domain*> m_axisDomainMap;
                 QChartAxis* m_axisX;
                 QChartAxis* m_axisY;
                 int m_domainIndex;
                 bool m_axisXInitialized;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif /* CHARTENGINE_P_H_ */

src/chartpresenter_p.h +1 -1

             #ifndef CHARTPRESENTER_H_
             #define CHARTPRESENTER_H_
             #include "qchartglobal.h"
             #include "qchart.h" //becouse of QChart::ChartThemeId //TODO
             #include "qchartaxis.h"
             #include <QRectF>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class Chart;
             class QSeries;
             class ChartDataSet;
             class Domain;
             class Axis;
             class ChartTheme;
             class ChartAnimator;
             class ChartPresenter: public QObject
             {
                 Q_OBJECT
             public:
                 enum ZValues {
                     BackgroundZValue = -1,
                     ShadesZValue,
                     GridZValue,
-                    AxisZValue,
                     LineChartZValue,
                     BarSeriesZValue,
                     ScatterSeriesZValue,
                     PieSeriesZValue,
+                    AxisZValue,
                     LegendZValue
                 };
                 ChartPresenter(QChart* chart,ChartDataSet *dataset);
                 virtual ~ChartPresenter();
                 void setMargin(int margin);
                 int margin() const;
                 QRectF geometry() const;
                 ChartAnimator* animator() const {return m_animator;}
                 ChartTheme *theme() { return m_chartTheme; }
                 ChartDataSet *dataSet() { return m_dataset; }
                 void setChartTheme(QChart::ChartTheme theme,bool force = true);
                 QChart::ChartTheme chartTheme();
                 void setAnimationOptions(QChart::AnimationOptions options);
                 QChart::AnimationOptions animationOptions() const;
                 QGraphicsItem* rootItem() const {return m_chart;};
                 void zoomIn();
                 void zoomIn(const QRectF& rect);
                 void zoomOut();
                 void scroll(int dx,int dy);
             private:
                 void createConnections();
                 void resetAllElements();
             public slots:
                 void handleSeriesAdded(QSeries* series,Domain* domain);
                 void handleSeriesRemoved(QSeries* series);
                 void handleAxisAdded(QChartAxis* axis,Domain* domain);
                 void handleAxisRemoved(QChartAxis* axis);
                 void handleGeometryChanged();
             signals:
                 void geometryChanged(const QRectF& rect);
             private:
                 QChart* m_chart;
                 ChartAnimator* m_animator;
                 ChartDataSet* m_dataset;
                 ChartTheme *m_chartTheme;
                 QMap<QSeries*,Chart*> m_chartItems;
                 QMap<QChartAxis*,Axis*> m_axisItems;
                 QRectF m_rect;
                 QChart::AnimationOptions m_options;
                 bool m_themeForce;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif /* CHARTPRESENTER_H_ */

General Comments 0

Write
Preview

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

No TODOs yet

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

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