HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r611:e622b3a8d8a0

Squashed bunch of warnings

Tero Ahola -

r611:e622b3a8d8a0

parent child

Context file:

r611:e622b3a8d8a0

Collapse all files

src/areachart/areachartitem.cpp +3 -2

             #include "areachartitem_p.h"
             #include "qareaseries.h"
             #include "qlineseries.h"
             #include "chartpresenter_p.h"
             #include <QPainter>
             #include <QGraphicsSceneMouseEvent>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             //TODO: optimize : remove points which are not visible
             AreaChartItem::AreaChartItem(QAreaSeries* areaSeries,QGraphicsItem *parent):ChartItem(parent),
             m_series(areaSeries),
             m_upper(0),
             m_lower(0),
             m_pointsVisible(false)
             {
                 setZValue(ChartPresenter::LineChartZValue);
                 m_upper = new AreaBoundItem(this,m_series->upperSeries());
                 if(m_series->lowerSeries()){
                 m_lower = new AreaBoundItem(this,m_series->lowerSeries());
                 }
                 QObject::connect(areaSeries,SIGNAL(updated()),this,SLOT(handleUpdated()));
                 QObject::connect(this,SIGNAL(clicked(const QPointF&)),areaSeries,SIGNAL(clicked(const QPointF&)));
                 handleUpdated();
             }
             AreaChartItem::~AreaChartItem()
             {
                 delete m_upper;
                 delete m_lower;
             };
             QRectF AreaChartItem::boundingRect() const
             {
                 return m_rect;
             }
             QPainterPath AreaChartItem::shape() const
             {
                 return m_path;
             }
             void AreaChartItem::updatePath()
             {
                 QPainterPath path;
                 path.connectPath(m_upper->shape());
                 if(m_lower){
                 path.connectPath(m_lower->shape().toReversed());
                 }
                 else{
                     QPointF first = path.pointAtPercent(0);
                     QPointF last =  path.pointAtPercent(1);
                     path.lineTo(last.x(),m_clipRect.bottom());
                     path.lineTo(first.x(),m_clipRect.bottom());
                 }
                 path.closeSubpath();
                 prepareGeometryChange();
                 m_path=path;
                 m_rect=path.boundingRect();
                 update();
             }
             void AreaChartItem::handleUpdated()
             {
                 m_pointsVisible = m_series->pointsVisible();
                 m_linePen = m_series->pen();
                 m_brush = m_series->brush();
                 m_pointPen = m_series->pen();
                 m_pointPen.setWidthF(2*m_pointPen.width());
                 update();
             }
             void AreaChartItem::handleDomainChanged(qreal minX, qreal maxX, qreal minY, qreal maxY)
             {
                 m_upper->handleDomainChanged(minX,maxX,minY,maxY);
                 if(m_lower)
                 m_lower->handleDomainChanged(minX,maxX,minY,maxY);
             }
             void AreaChartItem::handleGeometryChanged(const QRectF& rect)
             {
                 m_clipRect=rect.translated(-rect.topLeft());
                 setPos(rect.topLeft());
                 m_upper->handleGeometryChanged(rect);
                 if(m_lower)
                 m_lower->handleGeometryChanged(rect);
             }
             //painter
             void AreaChartItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
-                Q_UNUSED(widget);
+                Q_UNUSED(widget)
-                Q_UNUSED(option);
+                Q_UNUSED(option)
                 painter->save();
                 painter->setPen(m_linePen);
                 painter->setBrush(m_brush);
                 painter->setClipRect(m_clipRect);
                 painter->drawPath(m_path);
                 if(m_pointsVisible){
                        painter->setPen(m_pointPen);
                        painter->drawPoints(m_upper->points());
                        if(m_lower)  painter->drawPoints(m_lower->points());
                 }
                 painter->restore();
             }
             void AreaChartItem::mousePressEvent( QGraphicsSceneMouseEvent * event )
             {
                 emit clicked(m_upper->calculateDomainPoint(event->pos()));
             }
             #include "moc_areachartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/axisitem.cpp +3 -3

             #include "axisitem_p.h"
             #include "qchartaxis.h"
             #include "chartpresenter_p.h"
             #include "chartanimator_p.h"
             #include <QPainter>
             #include <QDebug>
             static int label_padding = 5;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             AxisItem::AxisItem(QChartAxis* axis,ChartPresenter* presenter,AxisType type,QGraphicsItem* parent) :
             ChartItem(parent),
             m_presenter(presenter),
             m_chartAxis(axis),
             m_type(type),
             m_labelsAngle(0),
             m_grid(parent),
             m_shades(parent),
             m_labels(parent),
             m_axis(parent),
             m_min(0),
             m_max(0),
             m_ticksCount(0)
             {
                 //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()));
                 handleAxisUpdated();
             }
             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());
                        m_axis.addToGroup(new QGraphicsLineItem());
                       if((m_grid.childItems().size())%2 && m_grid.childItems().size()>2) m_shades.addToGroup(new QGraphicsRectItem());
                    }
             }
             void AxisItem::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 AxisItem::updateLayout(QVector<qreal>& layout)
             {
                 if(m_animator){
                    m_animator->applyLayout(this,layout);
                 }
                 else setLayout(layout);
             }
             QStringList AxisItem::createLabels(int ticks, qreal min, qreal max) const
             {
                 Q_ASSERT(max>=min);
                 Q_ASSERT(ticks>0);
                 QStringList labels;
                 QChartAxisCategories* categories = m_chartAxis->categories();
                 for(int i=0; i< ticks; i++) {
                     qreal value = min + (i * (max - min)/ (ticks-1));
                     if(categories->count()==0) {
                         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
             {
                 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 AxisItem::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);
             	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));
             				labelItem->setText(ticksList.at(i));
             				QPointF center = labelItem->boundingRect().center();
             				labelItem->setTransformOriginPoint(center.x(), center.y());
             				labelItem->setPos(layout[i] - center.x(), m_rect.bottom() + label_padding);
             				if((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 AxisItem::isEmpty()
             {
                 return m_rect.isEmpty() || m_min==m_max || m_ticksCount==0;
             }
             //handlers
             void AxisItem::handleAxisCategoriesUpdated()
             {
             	if(isEmpty()) return;
             	updateLayout(m_layoutVector);
             }
             void AxisItem::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 AxisItem::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 AxisItem::handleGeometryChanged(const QRectF& rect)
             {
                 m_rect = rect;
                 if(isEmpty()) return;
                 QVector<qreal> layout = calculateLayout();
                 updateLayout(layout);
             }
             //painter
             void AxisItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
-                Q_UNUSED(painter);
+                Q_UNUSED(painter)
-                Q_UNUSED(option);
+                Q_UNUSED(option)
-                Q_UNUSED(widget);
+                Q_UNUSED(widget)
             }
             //TODO "nice numbers algorithm"
             #include "moc_axisitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/bar.cpp +3 0

             #include "bar_p.h"
             #include <QDebug>
             #include <QPainter>
             #include <QGraphicsSceneEvent>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             Bar::Bar(QString category, QGraphicsItem *parent)
                 : QGraphicsObject(parent),
                 mXpos(0),
                 mYpos(0),
                 mWidth(0),
                 mHeight(0),
                 mCategory(category)
             {
                 setAcceptedMouseButtons(Qt::LeftButton|Qt::RightButton);
                 setAcceptHoverEvents(true);
             }
             void Bar::setSize(const QSizeF& size)
             {
                 mWidth = size.width();
                 mHeight = size.height();
             }
             void Bar::resize( qreal w, qreal h )
             {
                 mWidth = w;
                 mHeight = h;
             }
             void Bar::setPos(qreal x, qreal y)
             {
                 mXpos = x;
                 mYpos = y;
             }
             void Bar::setPen(QPen pen)
             {
                 mPen = pen;
             }
             void Bar::setBrush(QBrush brush)
             {
                 mBrush = brush;
             }
             void Bar::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
+                Q_UNUSED(option)
+                Q_UNUSED(widget)
                 if (0 == mHeight) {
                     return;
                 }
                 painter->setBrush(mBrush);
                 // This compensates for rounding errors. drawRect takes ints and cumulative error of pos + size may be over 1.
                 int x0 = mXpos;
                 int x1 = (mXpos + mWidth);
                 int w = x1-x0;
                 int y0 = mYpos;
                 int y1 = (mYpos + mHeight);
                 int h = y1-y0;
                 painter->drawRect(x0, y0 ,w ,h);
             }
             QRectF Bar::boundingRect() const
             {
                 QRectF r(mXpos, mYpos, mWidth, mHeight);
                 return r;
             }
             void Bar::mousePressEvent(QGraphicsSceneMouseEvent* event)
             {
                 if (event->button() == Qt::LeftButton) {
                     emit clicked(mCategory);
                 } else if (event->button() == Qt::RightButton) {
                     emit rightClicked(mCategory);
                 }
             }
             void Bar::hoverEnterEvent(QGraphicsSceneHoverEvent* event)
             {
                 emit hoverEntered(event->lastScreenPos());
             }
             void Bar::hoverLeaveEvent(QGraphicsSceneHoverEvent* /*event*/)
             {
                 emit hoverLeaved();
             }
             #include "moc_bar_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/barpresenterbase.cpp +8 -3

             #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 "chartpresenter_p.h"
             #include <QDebug>
             #include <QToolTip>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             BarPresenterBase::BarPresenterBase(QBarSeries *series, QChart *parent) :
                 ChartItem(parent),
                 mHeight(0),
                 mWidth(0),
                 mLayoutSet(false),
                 mSeries(series),
                 mChart(parent)
             {
                 connect(series,SIGNAL(showToolTip(QPoint,QString)),this,SLOT(showToolTip(QPoint,QString)));
             //    connect(series,SIGNAL(enableSeparators(bool)),this,SLOT(enableSeparators(bool)));
             //    enableSeparators(series->separatorsVisible());
                 setZValue(ChartPresenter::BarSeriesZValue);
                 initAxisLabels();
                 dataChanged();
             }
             BarPresenterBase::~BarPresenterBase()
             {
                 disconnect(this,SLOT(showToolTip(QPoint,QString)));
                 disconnect(this,SLOT(enableSeparators(bool)));
             }
             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->setVisible(mSeries->separatorsVisible());
                     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;
                 }
                 mChart->axisX()->setTicksCount(count+2);
                 qreal min = 0;
                 qreal max = count+1;
                 mChart->axisX()->setMin(min);
                 mChart->axisX()->setMax(max);
                 QChartAxisCategories* categories = mChart->axisX()->categories();
                 categories->clear();
                 for (int i=0; i<count; i++) {
                     categories->insert(i+1,mSeries->categoryName(i));
                 }
                 mChart->axisX()->setLabelsVisible(true);
             }
             //handlers
             void BarPresenterBase::handleModelChanged(int index)
             {
-            //    qDebug() << "BarPresenterBase::handleModelChanged" << index;
+                Q_UNUSED(index)
                 dataChanged();
             }
-            void BarPresenterBase::handleDomainChanged(const Domain& domain)
+            void BarPresenterBase::handleDomainChanged(qreal minX, qreal maxX, qreal minY, qreal maxY)
             {
-                qDebug() << "BarPresenterBase::handleDomainChanged";
+                // TODO:
+                Q_UNUSED(minX)
+                Q_UNUSED(maxX)
+                Q_UNUSED(minY)
+                Q_UNUSED(maxY)
                 /*
                 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);
                 }
             }
             */
             #include "moc_barpresenterbase_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/barpresenterbase_p.h +1 -1

             #ifndef BARPRESENTERBASE_H
             #define BARPRESENTERBASE_H
             #include "chartitem_p.h"
             #include "qbarseries.h"
             #include <QPen>
             #include <QBrush>
             #include <QGraphicsItem>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class Bar;
             class Separator;
             class BarValue;
             class QChartAxisCategories;
             class QChart;
             // Common implemantation of different presenters. Not to be instantiated.
             // TODO: combine this with BarPresenter and derive other presenters from it?
             class BarPresenterBase : public QObject, public ChartItem
             {
                 Q_OBJECT
             public:
                 BarPresenterBase(QBarSeries *series, QChart *parent = 0);
                 virtual ~BarPresenterBase();
             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
                 virtual void layoutChanged() = 0;   // layout has changed -> need to recalculate bar sizes
             protected:
                 void initAxisLabels();
             public slots:
                 void handleModelChanged(int index);
-                void handleDomainChanged(const Domain& domain);
+                void handleDomainChanged(qreal minX, qreal maxX, qreal minY, qreal maxY);
                 void handleGeometryChanged(const QRectF& size);
                 // Internal slots
                 void showToolTip(QPoint pos, QString tip);      // shows tooltip (if enabled)
             //    void enableSeparators(bool enabled);
             protected:
                 // TODO: consider these.
                 int mHeight;        // Layout spesific
                 int mWidth;
                 qreal mBarWidth;
                 bool mLayoutSet;    // True, if component has been laid out.
                 // Not owned.
                 QBarSeries* mSeries;
                 QList<Bar*> mBars;
             //    QList<Separator*> mSeparators;
                 QList<BarValue*> mFloatingValues;
                 QChart* mChart;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // BARPRESENTERBASE_H

src/barchart/barvalue.cpp +3 0

             #include "barvalue_p.h"
             #include <QPainter>
             #include <QPen>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             BarValue::BarValue(QBarSet &set, QGraphicsItem *parent)
                 : QGraphicsObject(parent),
                 mBarSet(set),
                 mXpos(0),
                 mYpos(0),
                 mWidth(0),
                 mHeight(0)
             {
                 setVisible(false);
             }
             void BarValue::setValueString(QString str)
             {
                 mValueString = str;
             }
             QString BarValue::valueString()
             {
                 return mValueString;
             }
             void BarValue::setPen(const QPen pen)
             {
                 mPen = pen;
             }
             QPen BarValue::pen() const
             {
                 return mPen;
             }
             void BarValue::resize(qreal w, qreal h)
             {
                 mWidth = w;
                 mHeight = h;
             }
             void BarValue::setPos(qreal x, qreal y)
             {
                 mXpos = x;
                 mYpos = y;
             }
             void BarValue::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
+                Q_UNUSED(option)
+                Q_UNUSED(widget)
                 if (isVisible()) {
                     painter->setPen(mPen);
                     painter->drawText(boundingRect(),mValueString);
                 }
             }
             QRectF BarValue::boundingRect() const
             {
                 QRectF r(mXpos, mYpos, mWidth, mHeight);
                 return r;
             }
             void BarValue::toggleVisible()
             {
                 setVisible(!isVisible());
             }
             #include "moc_barvalue_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/qbarseries.cpp +4 -4

             #include <QDebug>
             #include "qbarseries.h"
             #include "qbarset.h"
             #include "barchartmodel_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QBarSeries
                 \brief part of QtCommercial chart API.
                 QBarSeries represents a series of data shown as bars. One QBarSeries can contain multible
                 QBarSet data sets. QBarSeries groups the data from sets to categories, which are defined
                 by QStringList.
                 \mainclass
                 \sa QBarSet, QStackedBarSeries, QPercentBarSeries
             */
             /*!
                 \fn virtual QSeriesType QBarSeries::type() const
                 \brief Returns type of series.
                 \sa QSeries, QSeriesType
             */
             /*!
                 \fn void QBarSeries::showToolTip(QPoint pos, QString tip)
                 \brief \internal \a pos \a tip
             */
             /*!
                 Constructs empty QBarSeries. Parameter \a categories defines the categories for chart.
                 QBarSeries is QObject which is a child of a \a parent.
             */
             QBarSeries::QBarSeries(QStringList categories, QObject *parent)
                 : QSeries(parent)
                 ,mModel(new BarChartModel(categories, this))
             {
                 m_model = NULL;
                 m_mapCategories = -1;
                 m_mapBarBottom = -1;
                 m_mapBarTop = -1;
             }
             /*!
                 Adds a set of bars to series. Takes ownership of \a set.
                 Connects the clicked(QString) and rightClicked(QString) signals
                 of \a set to this series
             */
             void QBarSeries::addBarSet(QBarSet *set)
             {
                 mModel->addBarSet(set);
                 connect(set,SIGNAL(clicked(QString)),this,SLOT(barsetClicked(QString)));
                 connect(set,SIGNAL(rightClicked(QString)),this,SLOT(barsetRightClicked(QString)));
             }
             /*!
                 Removes a set of bars from series. Releases ownership of \a set. Doesnt delete \a set.
                 Disconnects the clicked(QString) and rightClicked(QString) signals
                 of \a set from this series
             */
             void QBarSeries::removeBarSet(QBarSet *set)
             {
                 disconnect(set,SIGNAL(clicked(QString)),this,SLOT(barsetClicked(QString)));
                 disconnect(set,SIGNAL(rightClicked(QString)),this,SLOT(barsetRightClicked(QString)));
                 mModel->removeBarSet(set);
             }
             /*!
                 Returns number of sets in series.
             */
             int QBarSeries::barsetCount()
             {
                 if(m_model)
                     return m_mapBarTop - m_mapBarBottom;
                 else
                     return mModel->barsetCount();
             }
             /*!
                 Returns number of categories in series
             */
             int QBarSeries::categoryCount()
             {
                 return mModel->categoryCount();
             }
             /*!
                 Returns a list of sets in series. Keeps ownership of sets.
              */
             QList<QBarSet*> QBarSeries::barSets()
             {
                 return mModel->barSets();
             }
             /*!
                 \internal \a index
             */
             QBarSet* QBarSeries::barsetAt(int index)
             {
                 return mModel->setAt(index);
             }
             /*!
                 \internal \a category
             */
             QString QBarSeries::categoryName(int category)
             {
                 return mModel->categoryName(category);
             }
             /*!
                 Enables or disables tooltip depending on parameter \a enabled.
                 Tooltip shows the name of set, when mouse is hovering on top of bar.
                 Calling without parameter \a enabled, enables the tooltip
             */
             void QBarSeries::setToolTipEnabled(bool enabled)
             {
                 // TODO: what if we add sets after call to this function? Those sets won't have tooltip enabled.
                 if (enabled) {
                     for (int i=0; i<mModel->barsetCount(); i++) {
                         QBarSet *set = mModel->setAt(i);
                         connect(set,SIGNAL(showToolTip(QPoint,QString)),this,SIGNAL(showToolTip(QPoint,QString)));
                     }
                 } else {
                     for (int i=0; i<mModel->barsetCount(); i++) {
                         QBarSet *set = mModel->setAt(i);
                         disconnect(set,SIGNAL(showToolTip(QPoint,QString)),this,SIGNAL(showToolTip(QPoint,QString)));
                     }
                 }
             }
             /*!
                 Enables or disables separators depending on parameter \a enabled.
                 Separators are visual elements that are drawn between categories.
                 Calling without parameter \a enabled, enables the separators
             */
             void QBarSeries::setSeparatorsVisible(bool visible)
             {
                 mSeparatorsVisible = visible;
                 emit enableSeparators(visible);
             }
             /*!
                 \internal \a category
             */
             void QBarSeries::barsetClicked(QString category)
             {
                 emit clicked(qobject_cast<QBarSet*>(sender()), category);
             }
             /*!
                 \internal \a category
             */
             void QBarSeries::barsetRightClicked(QString category)
             {
                 emit rightClicked(qobject_cast<QBarSet*>(sender()), category);
             }
             /*!
                 \internal
             */
             qreal QBarSeries::min()
             {
                 return mModel->min();
             }
             /*!
                 \internal
             */
             qreal QBarSeries::max()
             {
                 return mModel->max();
             }
             /*!
                 \internal \a set \a category
             */
             qreal QBarSeries::valueAt(int set, int category)
             {
                 return mModel->valueAt(set,category);
             }
             /*!
                 \internal \a set \a category
             */
             qreal QBarSeries::percentageAt(int set, int category)
             {
                 return mModel->percentageAt(set,category);
             }
             /*!
                 \internal \a category
             */
             qreal QBarSeries::categorySum(int category)
             {
                 return mModel->categorySum(category);
             }
             /*!
                 \internal
             */
             qreal QBarSeries::maxCategorySum()
             {
                 return mModel->maxCategorySum();
             }
             /*!
                 \internal
             */
             BarChartModel& QBarSeries::model()
             {
                 return *mModel;
             }
             bool QBarSeries::separatorsVisible()
             {
                 return mSeparatorsVisible;
             }
             bool QBarSeries::setModel(QAbstractItemModel* model)
             {
                 m_model = model;
                 return true;
             }
-            void QBarSeries::setModelMappingCategories(int modelColumn)
+            // TODO
+            void QBarSeries::setModelMappingCategories(int /*modelColumn*/)
             {
-                //
             }
-            void QBarSeries::setModelMappingBarRange(int bottomBoundry, int topBoundry)
+            // TODO
+            void QBarSeries::setModelMappingBarRange(int /*bottomBoundry*/, int /*topBoundry*/)
             {
-                //
             }
             #include "moc_qbarseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/separator.cpp +3 0

             #include "separator_p.h"
             #include <QDebug>
             #include <QPainter>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             Separator::Separator(QGraphicsItem *parent)
                 : ChartItem(parent)
             {
             }
             void Separator::setPos(qreal x, qreal y)
             {
                 mXpos = x;
                 mYpos = y;
             }
             void Separator::setColor(QColor color)
             {
                 mColor = color;
             }
             void Separator::setSize(const QSizeF &size)
             {
                 mWidth = size.width();
                 mHeight = size.height();
             }
             void Separator::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
+                Q_UNUSED(option)
+                Q_UNUSED(widget)
                 if (isVisible()) {
                     QPen pen(mColor);
                     painter->setPen(pen);
                     painter->drawLine(mXpos,mYpos,mXpos,mHeight);
                 }
             }
             QRectF Separator::boundingRect() const
             {
                 QRectF r(mXpos,mYpos,mWidth,mHeight);
                 return r;
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/chartpresenter.cpp +4 -4

             #include "qchart.h"
             #include "qchartaxis.h"
             #include "chartpresenter_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             #include "chartanimator_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 "areachartitem_p.h"
             #include "barpresenter_p.h"
             #include "stackedbarpresenter_p.h"
             #include "percentbarpresenter_p.h"
             #include "linechartitem_p.h"
             #include "piechartitem_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_animator(0),
                 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()
             {
             	delete m_chartTheme;
             }
             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 = new AxisItem(axis,this,axis==m_dataset->axisX()?AxisItem::X_AXIS : AxisItem::Y_AXIS,m_chart);
                 if(m_options.testFlag(QChart::GridAxisAnimations)){
                     m_animator->addAnimation(item);
                 }
                 if(axis==m_dataset->axisX()){
                     m_chartTheme->decorate(axis,true);
                     QObject::connect(domain,SIGNAL(rangeXChanged(qreal,qreal,int)),item,SLOT(handleRangeChanged(qreal,qreal,int)));
                     //initialize
                     item->handleRangeChanged(domain->minX(),domain->maxX(),domain->tickXCount());
                 }
                 else{
                     m_chartTheme->decorate(axis,false);
                     QObject::connect(domain,SIGNAL(rangeYChanged(qreal,qreal,int)),item,SLOT(handleRangeChanged(qreal,qreal,int)));
                     //initialize
                     item->handleRangeChanged(domain->minY(),domain->maxY(),domain->tickYCount());
                 }
                 QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),item,SLOT(handleGeometryChanged(const QRectF&)));
                 //initialize
                 item->handleGeometryChanged(m_rect);
                 m_axisItems.insert(axis, item);
             }
             void ChartPresenter::handleAxisRemoved(QChartAxis* axis)
             {
                 AxisItem* item = m_axisItems.take(axis);
                 Q_ASSERT(item);
                 if(m_animator) m_animator->removeAnimation(item);
                 delete item;
             }
             void ChartPresenter::handleSeriesAdded(QSeries* series,Domain* domain)
             {
             	ChartItem *item = 0 ;
                 switch(series->type())
                 {
                 case QSeries::SeriesTypeLine: {
                     QLineSeries* lineSeries = static_cast<QLineSeries*>(series);
                     LineChartItem* line = new LineChartItem(lineSeries,m_chart);
                     if(m_options.testFlag(QChart::SeriesAnimations)) {
                     	m_animator->addAnimation(line);
                     }
                     m_chartTheme->decorate(lineSeries, m_dataset->seriesIndex(series));
                     QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),line,SLOT(handleGeometryChanged(const QRectF&)));
                     QObject::connect(domain,SIGNAL(domainChanged(qreal,qreal,qreal,qreal)),line,SLOT(handleDomainChanged(qreal,qreal,qreal,qreal)));
                     item = line;
                     break;
                 }
                 case QSeries::SeriesTypeArea: {
                     QAreaSeries* areaSeries = static_cast<QAreaSeries*>(series);
                     AreaChartItem* area = new AreaChartItem(areaSeries,m_chart);
                     if(m_options.testFlag(QChart::SeriesAnimations)) {
                        m_animator->addAnimation(area->upperLineItem());
                        if(areaSeries->lowerSeries())  m_animator->addAnimation(area->lowerLineItem());
                     }
                     m_chartTheme->decorate(areaSeries, m_dataset->seriesIndex(series));
                     QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),area,SLOT(handleGeometryChanged(const QRectF&)));
                     QObject::connect(domain,SIGNAL(domainChanged(qreal,qreal,qreal,qreal)),area,SLOT(handleDomainChanged(qreal,qreal,qreal,qreal)));
                     item=area;
                     break;
                 }
                 case QSeries::SeriesTypeBar: {
                     QBarSeries* barSeries = static_cast<QBarSeries*>(series);
                     BarPresenter* bar = new BarPresenter(barSeries,m_chart);
                     if(m_options.testFlag(QChart::SeriesAnimations)) {
                      //  m_animator->addAnimation(bar);
                     }
-                    m_chartTheme->decorate(bar, barSeries, m_dataset->seriesIndex(barSeries));
+                    m_chartTheme->decorate(barSeries, m_dataset->seriesIndex(barSeries));
                     QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),bar,SLOT(handleGeometryChanged(const QRectF&)));
                     QObject::connect(domain,SIGNAL(domainChanged(qreal,qreal,qreal,qreal)),bar,SLOT(handleDomainChanged(qreal,qreal,qreal,qreal)));
                     item=bar;
                     break;
                 }
                 case QSeries::SeriesTypeStackedBar: {
                     QStackedBarSeries* stackedBarSeries = static_cast<QStackedBarSeries*>(series);
                     StackedBarPresenter* bar = new StackedBarPresenter(stackedBarSeries,m_chart);
                     if(m_options.testFlag(QChart::SeriesAnimations)) {
                      //  m_animator->addAnimation(bar);
                     }
-                    m_chartTheme->decorate(bar, stackedBarSeries, m_dataset->seriesIndex(stackedBarSeries));
+                    m_chartTheme->decorate(stackedBarSeries, m_dataset->seriesIndex(stackedBarSeries));
                     QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),bar,SLOT(handleGeometryChanged(const QRectF&)));
                     QObject::connect(domain,SIGNAL(domainChanged(qreal,qreal,qreal,qreal)),bar,SLOT(handleDomainChanged(qreal,qreal,qreal,qreal)));
                     item=bar;
                     break;
                 }
                 case QSeries::SeriesTypePercentBar: {
                     QPercentBarSeries* percentBarSeries = static_cast<QPercentBarSeries*>(series);
                     PercentBarPresenter* bar = new PercentBarPresenter(percentBarSeries,m_chart);
                     if(m_options.testFlag(QChart::SeriesAnimations)) {
                      //  m_animator->addAnimation(bar);
                     }
-                    m_chartTheme->decorate(bar, percentBarSeries, m_dataset->seriesIndex(percentBarSeries));
+                    m_chartTheme->decorate(percentBarSeries, m_dataset->seriesIndex(percentBarSeries));
                     QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),bar,SLOT(handleGeometryChanged(const QRectF&)));
                     QObject::connect(domain,SIGNAL(domainChanged(qreal,qreal,qreal,qreal)),bar,SLOT(handleDomainChanged(qreal,qreal,qreal,qreal)));
                     item=bar;
                     break;
                 }
                 case QSeries::SeriesTypeScatter: {
                 	QScatterSeries *scatterSeries = static_cast<QScatterSeries *>(series);
                         ScatterChartItem *scatter = new ScatterChartItem(scatterSeries, m_chart);
                         if(m_options.testFlag(QChart::SeriesAnimations)) {
                             m_animator->addAnimation(scatter);
                         }
                         m_chartTheme->decorate(scatterSeries, m_dataset->seriesIndex(series));
                         QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),scatter,SLOT(handleGeometryChanged(const QRectF&)));
                         QObject::connect(domain,SIGNAL(domainChanged(qreal,qreal,qreal,qreal)),scatter,SLOT(handleDomainChanged(qreal,qreal,qreal,qreal)));
                         item = scatter;
                         break;
             	}
                 case QSeries::SeriesTypePie: {
                     QPieSeries *pieSeries = static_cast<QPieSeries *>(series);
                     PieChartItem* pie = new PieChartItem(m_chart, pieSeries);
                     if(m_options.testFlag(QChart::SeriesAnimations)) {
                        // m_animator->addAnimation(pie);
                     }
-                    m_chartTheme->decorate(pie, pieSeries, m_dataset->seriesIndex(series));
+                    m_chartTheme->decorate(pieSeries, m_dataset->seriesIndex(series));
                     QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),pie,SLOT(handleGeometryChanged(const QRectF&)));
                     QObject::connect(domain,SIGNAL(domainChanged(qreal,qreal,qreal,qreal)),pie,SLOT(handleDomainChanged(qreal,qreal,qreal,qreal)));
                     // 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()->hide();
                         m_chart->axisY()->hide();
                         m_chart->setChartBackgroundBrush(Qt::transparent);
                     }
                     item=pie;
                     break;
                 }
                 case QSeries::SeriesTypeSpline: {
                     QSplineSeries* splineSeries = static_cast<QSplineSeries*>(series);
                     SplineChartItem* spline  = new SplineChartItem(splineSeries, m_chart);
                     if(m_options.testFlag(QChart::SeriesAnimations)) {
                         m_animator->addAnimation(spline);
                     }
                     m_chartTheme->decorate(splineSeries, m_dataset->seriesIndex(series));
                     QObject::connect(this,SIGNAL(geometryChanged(const QRectF&)),spline,SLOT(handleGeometryChanged(const QRectF&)));
                     QObject::connect(domain,SIGNAL(domainChanged(qreal,qreal,qreal,qreal)),spline,SLOT(handleDomainChanged(qreal,qreal,qreal,qreal)));
                     item=spline;
                     break;
                 }
                 default: {
                     qDebug()<< "Series type" << series->type() << "not implemented.";
                     break;
                 }
                 }
                 //initialize
                 item->handleDomainChanged(domain->minX(),domain->maxX(),domain->minY(),domain->maxY());
                 if(m_rect.isValid()) item->handleGeometryChanged(m_rect);
                 m_chartItems.insert(series,item);
                 zoomReset();
             }
             void ChartPresenter::handleSeriesRemoved(QSeries* series)
             {
                 ChartItem* item = m_chartItems.take(series);
                 Q_ASSERT(item);
                 if(m_animator) {
                     //small hack to handle area animations
                     if(series->type()==QSeries::SeriesTypeArea){
                          QAreaSeries* areaSeries = static_cast<QAreaSeries*>(series);
                          AreaChartItem* area = static_cast<AreaChartItem*>(item);
                          m_animator->removeAnimation(area->upperLineItem());
                          if(areaSeries->lowerSeries())  m_animator->addAnimation(area->lowerLineItem());
                     }else
                     m_animator->removeAnimation(item);
                 }
                 delete item;
             }
             void ChartPresenter::setChartTheme(QChart::ChartTheme theme)
             {
             	if(m_chartTheme && m_chartTheme->id() == theme) return;
                 delete m_chartTheme;
                 m_chartTheme = ChartTheme::createTheme(theme);
                 m_chartTheme->decorate(m_chart);
                 m_chartTheme->decorate(m_chart->legend());
                 resetAllElements();
             }
             QChart::ChartTheme ChartPresenter::chartTheme()
             {
                 return m_chartTheme->id();
             }
             void ChartPresenter::setAnimationOptions(QChart::AnimationOptions options)
             {
                 if(m_options!=options) {
                     m_options=options;
                     if(m_options!=QChart::NoAnimation && !m_animator) {
                         m_animator= new ChartAnimator(this);
                     }
                     resetAllElements();
                 }
             }
             void ChartPresenter::resetAllElements()
             {
                  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);
             	if(m_animator) {
             		QPointF point(r.center().x()/geometry().width(),r.center().y()/geometry().height());
             		m_animator->setState(ChartAnimator::ZoomInState,point);
             	}
             	m_dataset->zoomInDomain(r,geometry().size());
             	m_zoomStack<<r;
             	m_zoomIndex++;
             	if(m_animator) {
             		m_animator->setState(ChartAnimator::ShowState);
             	}
             }
             void ChartPresenter::zoomOut()
             {
             	if(m_zoomIndex==0) return;
             	if(m_animator)
             	{
             		m_animator->setState(ChartAnimator::ZoomOutState);
             	}
             	m_dataset->zoomOutDomain(m_zoomStack[m_zoomIndex-1],geometry().size());
             	m_zoomIndex--;
             	m_zoomStack.resize(m_zoomIndex);
             	if(m_animator){
             			m_animator->setState(ChartAnimator::ShowState);
             	}
             }
             void ChartPresenter::zoomReset()
             {
                 m_zoomIndex=0;
                 m_zoomStack.resize(m_zoomIndex);
             }
             void ChartPresenter::scroll(int dx,int dy)
             {
             	if(m_animator){
             		if(dx<0) m_animator->setState(ChartAnimator::ScrollLeftState,QPointF());
             		if(dx>0) m_animator->setState(ChartAnimator::ScrollRightState,QPointF());
             		if(dy<0) m_animator->setState(ChartAnimator::ScrollUpState,QPointF());
             		if(dy>0) m_animator->setState(ChartAnimator::ScrollDownState,QPointF());
             	}
             	m_dataset->scrollDomain(dx,dy,geometry().size());
                 if(m_animator){
             		m_animator->setState(ChartAnimator::ShowState);
             	}
             }
             QChart::AnimationOptions ChartPresenter::animationOptions() const
             {
                 return m_options;
             }
             #include "moc_chartpresenter_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/charttheme.cpp +4 -4

             #include "charttheme_p.h"
             #include "qchart.h"
             #include "qchartview.h"
             #include "qlegend.h"
             #include "qchartaxis.h"
             #include <QTime>
             //series
             #include "qbarset.h"
             #include "qbarseries.h"
             #include "qstackedbarseries.h"
             #include "qpercentbarseries.h"
             #include "qlineseries.h"
             #include "qareaseries.h"
             #include "qscatterseries.h"
             #include "qpieseries.h"
             #include "qpieslice.h"
             #include "qsplineseries.h"
             //items
             #include "axisitem_p.h"
             #include "barpresenter_p.h"
             #include "stackedbarpresenter_p.h"
             #include "percentbarpresenter_p.h"
             #include "linechartitem_p.h"
             #include "areachartitem_p.h"
             #include "scatterchartitem_p.h"
             #include "piechartitem_p.h"
             #include "splinechartitem_p.h"
             //themes
             #include "chartthemedefault_p.h"
             #include "chartthemevanilla_p.h"
             #include "chartthemeicy_p.h"
             #include "chartthemegrayscale_p.h"
             #include "chartthemescientific_p.h"
             #include "chartthemebluecerulean_p.h"
             #include "chartthemelight_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartTheme::ChartTheme(QChart::ChartTheme id)
             {
                 m_id = id;
                 qsrand(QTime(0,0,0).secsTo(QTime::currentTime()));
             }
             ChartTheme* ChartTheme::createTheme(QChart::ChartTheme theme)
             {
                 switch(theme) {
                     case QChart::ChartThemeVanilla:
                         return new ChartThemeVanilla();
                     case QChart::ChartThemeIcy:
                         return new ChartThemeIcy();
                     case QChart::ChartThemeGrayscale:
                         return new ChartThemeGrayscale();
                     case QChart::ChartThemeScientific:
                         return new ChartThemeScientific();
                     case QChart::ChartThemeBlueCerulean:
                         return new ChartThemeBlueCerulean();
                     case QChart::ChartThemeLight:
                         return new ChartThemeLight();
                     default:
                         return new ChartThemeDefault();
                 }
             }
             void ChartTheme::decorate(QChart* chart)
             {
                 if (m_backgroundShades == BackgroundShadesNone) {
                     chart->setChartBackgroundBrush(m_chartBackgroundGradient);
                 } else {
                     chart->setChartBackgroundBrush(Qt::NoBrush);
                 }
                 chart->setChartTitleFont(m_masterFont);
             }
             void ChartTheme::decorate(QLegend* legend)
             {
                 legend->setBackgroundBrush(m_chartBackgroundGradient);
             }
             void ChartTheme::decorate(QAreaSeries* series, int index)
             {
                 QPen pen;
                 QBrush brush;
                 if (pen == series->pen()){
                     pen.setColor(colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), 1.0));
                     pen.setWidthF(2);
                     series->setPen(pen);
                 }
                 if (brush == series->brush()) {
                    QBrush brush(m_seriesColors.at(index % m_seriesColors.size()));
                    series->setBrush(brush);
                 }
             }
             void ChartTheme::decorate(QLineSeries* series,int index)
             {
                 QPen pen;
                 if(pen == series->pen()){
                     pen.setColor(m_seriesColors.at(index%m_seriesColors.size()));
                     pen.setWidthF(2);
                     series->setPen(pen);
                 }
             }
-            void ChartTheme::decorate(BarPresenter* item, QBarSeries* series,int index)
+            void ChartTheme::decorate(QBarSeries* series,int index)
             {
                 QList<QBarSet*> sets = series->barSets();
                 for (int i=0; i<sets.count(); i++) {
                     qreal pos = 0.5;
                     if (sets.count() > 1)
                         pos = (qreal) i / (qreal) (sets.count() - 1);
                     QColor c = colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), pos);
                     sets.at(i)->setBrush(QBrush(c));
                     // Pick label color as far as possible from bar color (within gradient).
                     // 0.3 is magic number that was picked as value that gave enough contrast with icy theme gradient :)
                     // TODO: better picking of label color?
                     if (pos < 0.3) {
                         c = colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), 1);
                     } else {
                         c = colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), 0);
                     }
                     sets.at(i)->setFloatingValuePen(QPen(c));
                 }
             }
-            void ChartTheme::decorate(StackedBarPresenter* item, QStackedBarSeries* series,int index)
+            void ChartTheme::decorate(QStackedBarSeries* series,int index)
             {
                 QList<QBarSet*> sets = series->barSets();
                 for (int i=0; i<sets.count(); i++) {
                     qreal pos = 0.5;
                     if (sets.count() > 1)
                         pos = (qreal) i / (qreal) (sets.count() - 1);
                     QColor c = colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), pos);
                     sets.at(i)->setBrush(QBrush(c));
                     if (pos < 0.3) {
                         c = colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), 1);
                     } else {
                         c = colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), 0);
                     }
                     sets.at(i)->setFloatingValuePen(QPen(c));
                 }
             }
-            void ChartTheme::decorate(PercentBarPresenter* item, QPercentBarSeries* series,int index)
+            void ChartTheme::decorate(QPercentBarSeries* series,int index)
             {
                 QList<QBarSet*> sets = series->barSets();
                 for (int i=0; i<sets.count(); i++) {
                     qreal pos = 0.5;
                     if (sets.count() > 1)
                         pos = (qreal) i / (qreal) (sets.count() - 1);
                     QColor c = colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), pos);
                     sets.at(i)->setBrush(QBrush(c));
                     if (pos < 0.3) {
                         c = colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), 1);
                     } else {
                         c = colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), 0);
                     }
                     sets.at(i)->setFloatingValuePen(QPen(c));
                 }
             }
             void ChartTheme::decorate(QScatterSeries* series, int index)
             {
                 QPen pen;
                 QBrush brush;
                 if (pen == series->pen()) {
                     pen.setColor(colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), 1.0));
                     pen.setWidthF(2);
                     series->setPen(pen);
                 }
                 if (brush == series->brush()) {
                     QBrush brush(m_seriesColors.at(index % m_seriesColors.size()));
                     series->setBrush(brush);
                 }
             }
-            void ChartTheme::decorate(PieChartItem* item, QPieSeries* series, int index)
+            void ChartTheme::decorate(QPieSeries* series, int index)
             {
                 // Get color for a slice from a gradient linearly, beginning from the start of the gradient
                 for (int i(0); i < series->slices().count(); i++) {
                     qreal pos = (qreal) i / (qreal) series->count();
                     QColor penColor = colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), 0.1);
                     series->slices().at(i)->setSlicePen(penColor);
                     QColor brushColor = colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), pos);
                     series->slices().at(i)->setSliceBrush(brushColor);
                 }
             }
             void ChartTheme::decorate(QSplineSeries* series, int index)
             {
                 QPen pen;
                 if(pen == series->pen()){
                     pen.setColor(m_seriesColors.at(index%m_seriesColors.size()));
                     pen.setWidthF(2);
                     series->setPen(pen);
                 }
             }
             void ChartTheme::decorate(QChartAxis* axis,bool axisX)
             {
                 if (axis->isAxisVisible()) {
                     axis->setLabelsBrush(m_axisLabelBrush);
                     axis->setLabelsPen(m_axisLabelPen);
                     if (m_backgroundShades == BackgroundShadesBoth
                             || (m_backgroundShades == BackgroundShadesVertical && axisX)
                             || (m_backgroundShades == BackgroundShadesHorizontal && !axisX)) {
                         axis->setShadesPen(m_backgroundShadesPen);
                         axis->setShadesBrush(m_backgroundShadesBrush);
                     } else {
                         // The shades not supposed to be shown for this axis, clear possible brush and pen
                         axis->setShadesPen(Qt::NoPen);
                         axis->setShadesBrush(Qt::NoBrush);
                     }
                     axis->setAxisPen(m_axisLinePen);
                     axis->setGridLinePen(m_gridLinePen);
                     axis->setLabelsFont(m_masterFont);
                 }
             }
             void ChartTheme::generateSeriesGradients()
             {
                 // Generate gradients in HSV color space
                 foreach (QColor color, m_seriesColors) {
                     QLinearGradient g;
                     qreal h = color.hsvHueF();
                     qreal s = color.hsvSaturationF();
                     // TODO: tune the algorithm to give nice results with most base colors defined in
                     // most themes. The rest of the gradients we can define manually in theme specific
                     // implementation.
                     QColor start = color;
                     start.setHsvF(h, 0.05, 0.95);
                     g.setColorAt(0.0, start);
                     g.setColorAt(0.5, color);
                     QColor end = color;
                     end.setHsvF(h, s, 0.25);
                     g.setColorAt(1.0, end);
                     m_seriesGradients << g;
                 }
             }
             QColor ChartTheme::colorAt(const QColor &start, const QColor &end, qreal pos)
             {
                 Q_ASSERT(pos >=0.0 && pos <= 1.0);
                 qreal r = start.redF() + ((end.redF() - start.redF()) * pos);
                 qreal g = start.greenF() + ((end.greenF() - start.greenF()) * pos);
                 qreal b = start.blueF() + ((end.blueF() - start.blueF()) * pos);
                 QColor c;
                 c.setRgbF(r, g, b);
                 return c;
             }
             QColor ChartTheme::colorAt(const QGradient &gradient, qreal pos)
             {
                 Q_ASSERT(pos >=0 && pos <= 1.0);
                 // another possibility:
                 // http://stackoverflow.com/questions/3306786/get-intermediate-color-from-a-gradient
                 QGradientStops stops = gradient.stops();
                 int count = stops.count();
                 // find previous stop relative to position
                 QGradientStop prev = stops.first();
                 for (int i=0; i<count; i++) {
                     QGradientStop stop = stops.at(i);
                     if (pos > stop.first)
                         prev = stop;
                     // given position is actually a stop position?
                     if (pos == stop.first) {
                         //qDebug() << "stop color" << pos;
                         return stop.second;
                     }
                 }
                 // find next stop relative to position
                 QGradientStop next = stops.last();
                 for (int i=count-1; i>=0; i--) {
                     QGradientStop stop = stops.at(i);
                     if (pos < stop.first)
                         next = stop;
                 }
                 //qDebug() << "prev" << prev.first << "pos" << pos << "next" << next.first;
                 qreal range = next.first - prev.first;
                 qreal posDelta = pos - prev.first;
                 qreal relativePos = posDelta / range;
                 //qDebug() << "range" << range << "posDelta" << posDelta << "relativePos" << relativePos;
                 return colorAt(prev.second, next.second, relativePos);
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/charttheme_p.h +4 -4

             #ifndef CHARTTHEME_H
             #define CHARTTHEME_H
             #include "qchartglobal.h"
             #include "qchart.h"
             #include <QColor>
             #include <QGradientStops>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class ChartItem;
             class QSeries;
             class LineChartItem;
             class QLineSeries;
             class BarPresenter;
             class QBarSeries;
             class StackedBarPresenter;
             class QStackedBarSeries;
             class QPercentBarSeries;
             class PercentBarPresenter;
             class QScatterSeries;
             class ScatterChartItem;
             class PieChartItem;
             class QPieSeries;
             class SplineChartItem;
             class QSplineSeries;
             class AreaChartItem;
             class QAreaSeries;
             class ChartTheme
             {
             public:
                 enum BackgroundShadesMode {
                     BackgroundShadesNone = 0,
                     BackgroundShadesVertical,
                     BackgroundShadesHorizontal,
                     BackgroundShadesBoth
                 };
             protected:
                 explicit ChartTheme(QChart::ChartTheme id =  QChart::ChartThemeDefault);
             public:
                 static ChartTheme* createTheme(QChart::ChartTheme theme);
                 QChart::ChartTheme id() const {return m_id;}
                 void decorate(QChart* chart);
                 void decorate(QLegend* legend);
                 //void decorate(ChartItem* item, QSeries* series,int index);
-                void decorate(BarPresenter* item, QBarSeries* series, int index);
+                void decorate(QBarSeries* series, int index);
-                void decorate(StackedBarPresenter* item, QStackedBarSeries* series, int index);
+                void decorate(QStackedBarSeries* series, int index);
-                void decorate(PercentBarPresenter* item, QPercentBarSeries* series, int index);
+                void decorate(QPercentBarSeries* series, int index);
                 void decorate(QLineSeries* series, int index);
                 void decorate(QAreaSeries* series, int index);
                 void decorate(QScatterSeries* series, int index);
-                void decorate(PieChartItem* item, QPieSeries* series, int index);
+                void decorate(QPieSeries* series, int index);
                 void decorate(QSplineSeries* series, int index);
                 void decorate(QChartAxis* axis, bool axisX);
             public: // utils
                 void generateSeriesGradients();
                 static QColor colorAt(const QColor &start, const QColor &end, qreal pos);
                 static QColor colorAt(const QGradient &gradient, qreal pos);
             protected:
                 QChart::ChartTheme m_id;
                 QList<QColor> m_seriesColors;
                 QList<QGradient> m_seriesGradients;
                 QLinearGradient m_chartBackgroundGradient;
                 QFont m_masterFont;
                 QPen m_axisLinePen;
                 QBrush m_axisLabelBrush;
                 QPen m_axisLabelPen;
                 QPen m_backgroundShadesPen;
                 QBrush m_backgroundShadesBrush;
                 BackgroundShadesMode m_backgroundShades;
                 QPen m_gridLinePen;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // CHARTTHEME_H

src/legendmarker.cpp +3 0

             #include "qchartglobal.h"
             #include "legendmarker_p.h"
             #include <qpieslice.h>
             #include <qbarset.h>
             #include <QPainter>
             #include <QGraphicsSceneEvent>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             LegendMarker::LegendMarker(QSeries* series, QGraphicsItem *parent)
                 : QGraphicsObject(parent)
                 ,mBoundingRect(0,0,1,1)
                 ,mMarkerBoundingRect(0,0,1,1)
                 ,mSeries(series)
                 ,mBarset(0)
                 ,mPieslice(0)
                 ,mType(LegendMarkerTypeSeries)
                 ,mTextItem(new QGraphicsSimpleTextItem(this))
                 {
                     setAcceptedMouseButtons(Qt::LeftButton|Qt::RightButton);
                 }
             LegendMarker::LegendMarker(QSeries *series, QBarSet *barset, QGraphicsItem *parent)
                 : QGraphicsObject(parent)
                 ,mBoundingRect(0,0,1,1)
                 ,mMarkerBoundingRect(0,0,1,1)
                 ,mSeries(series)
                 ,mBarset(barset)
                 ,mPieslice(0)
                 ,mType(LegendMarkerTypeBarset)
                 ,mTextItem(new QGraphicsSimpleTextItem(this))
                 {
                     setAcceptedMouseButtons(Qt::LeftButton|Qt::RightButton);
                 }
             LegendMarker::LegendMarker(QSeries *series, QPieSlice *pieslice, QGraphicsItem *parent)
                 : QGraphicsObject(parent)
                 ,mBoundingRect(0,0,1,1)
                 ,mMarkerBoundingRect(0,0,1,1)
                 ,mSeries(series)
                 ,mBarset(0)
                 ,mPieslice(pieslice)
                 ,mType(LegendMarkerTypePieslice)
                 ,mTextItem(new QGraphicsSimpleTextItem(this))
                 {
                     setAcceptedMouseButtons(Qt::LeftButton|Qt::RightButton);
                 }
             void LegendMarker::setBoundingRect(const QRectF rect)
             {
                 mBoundingRect = rect;
                 // Calculate Marker pos
                 // TODO: remove hard coding. 5 is marigin around marker
                 QSizeF markerSize(10,10);
                 qreal x = mBoundingRect.x() + 5;
                 qreal y = mBoundingRect.y() + (mBoundingRect.height() - markerSize.height())/2;
                 mMarkerBoundingRect = QRectF(x,y,markerSize.width(),markerSize.height());
                 mTextItem.setPos(mBoundingRect.x() + markerSize.width() + 10, y );
             }
             void LegendMarker::setBrush(const QBrush brush)
             {
                 mBrush = brush;
             }
             QBrush LegendMarker::brush() const
             {
                 return mBrush;
             }
             void LegendMarker::setName(const QString name)
             {
                 mTextItem.setText(name);
             }
             QString LegendMarker::name() const
             {
                 return mTextItem.text();
             }
             QSeries* LegendMarker::series() const
             {
                 return mSeries;
             }
             void LegendMarker::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
+                Q_UNUSED(option)
+                Q_UNUSED(widget)
                 painter->setBrush(mBrush);
                 painter->drawRect(mMarkerBoundingRect);
             }
             QRectF LegendMarker::boundingRect() const
             {
                 return mBoundingRect;
             }
             void LegendMarker::mousePressEvent(QGraphicsSceneMouseEvent *event)
             {
                 switch (mType)
                 {
                 case LegendMarkerTypeSeries: {
                     emit clicked(mSeries,event->button());
                     break;
                     }
                 case LegendMarkerTypeBarset: {
                     emit clicked(mBarset,event->button());
                     break;
                     }
                 case LegendMarkerTypePieslice: {
                     emit clicked(mPieslice,event->button());
                     break;
                     }
                 default: {
                     break;
                     }
                 }
             }
             void LegendMarker::changed()
             {
                 switch (mType)
                 {
                 case LegendMarkerTypeSeries: {
                     // TODO:
                     break;
                 }
                 case LegendMarkerTypeBarset: {
                     setBrush(mBarset->brush());
                     setName(mBarset->name());
                     break;
                 }
                 case LegendMarkerTypePieslice: {
                     setBrush(mPieslice->sliceBrush());
                     setName(mPieslice->label());
                     break;
                 }
                 }
             }
             #include "moc_legendmarker_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/linechart/linechartitem.cpp +3 -2

             #include "linechartitem_p.h"
             #include "qlineseries.h"
             #include "chartpresenter_p.h"
             #include <QPainter>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             //TODO: optimize : remove points which are not visible
             LineChartItem::LineChartItem(QLineSeries* series,QGraphicsItem *parent):XYChartItem(series,parent),
             m_series(series),
             m_pointsVisible(false)
             {
                 setZValue(ChartPresenter::LineChartZValue);
                 QObject::connect(series,SIGNAL(updated()),this,SLOT(handleUpdated()));
                 handleUpdated();
             }
             QRectF LineChartItem::boundingRect() const
             {
             	return m_rect;
             }
             QPainterPath LineChartItem::shape() const
             {
                 return m_path;
             }
             void LineChartItem::setLayout(QVector<QPointF>& points)
             {
                 if(points.size()==0)
                 {
                     XYChartItem::setLayout(points);
                     return;
                 }
                 QList<QGraphicsItem*> items = m_items.childItems();
                 QPainterPath linePath(points.at(0));
                 for(int i=1; i< points.size();i++) {
                     linePath.lineTo(points.at(i));
                 }
                 prepareGeometryChange();
                 m_path = linePath;
                 m_rect = linePath.boundingRect();
                 XYChartItem::setLayout(points);
             }
             void LineChartItem::handleUpdated()
             {
                 m_pointsVisible = m_series->pointsVisible();
                 m_linePen = m_series->pen();
                 m_pointPen = m_series->pen();
                 m_pointPen.setWidthF(2*m_pointPen.width());
                 update();
             }
             //painter
             void LineChartItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
-                Q_UNUSED(widget);
+                Q_UNUSED(widget)
-                Q_UNUSED(option);
+                Q_UNUSED(option)
                 painter->save();
                 painter->setPen(m_linePen);
                 painter->setClipRect(clipRect());
                 painter->drawPath(m_path);
                 if(m_pointsVisible){
                 	painter->setPen(m_pointPen);
                 	painter->drawPoints(points());
                 }
                 painter->restore();
             }
             #include "moc_linechartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/piechart/piechartitem.cpp +1 0

             #include "piechartitem_p.h"
             #include "pieslice_p.h"
             #include "qpieslice.h"
             #include "qpieseries.h"
             #include "chartpresenter_p.h"
             #include <QDebug>
             #include <QPainter>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             PieChartItem::PieChartItem(QGraphicsItem *parent, QPieSeries *series)
                 :ChartItem(parent),
                 m_series(series)
             {
                 Q_ASSERT(series);
                 connect(series, SIGNAL(changed()), this, SLOT(handleSeriesChanged()));
                 // Note: the following does not affect as long as the item does not have anything to paint
                 setZValue(ChartPresenter::PieSeriesZValue);
             }
             PieChartItem::~PieChartItem()
             {
                 // slices deleted automatically through QGraphicsItem
             }
             void PieChartItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *, QWidget *)
             {
+                Q_UNUSED(painter)
                 // TODO: paint shadows for all components
                 // - get paths from items & merge & offset and draw with shadow color?
                 //painter->setBrush(QBrush(Qt::red));
                 //painter->drawRect(m_debugRect);
             }
             void PieChartItem::handleSeriesChanged()
             {
                 QVector<PieSliceLayout> sliceLayout = calculateLayout();
                 applyLayout(sliceLayout);
                 update();
             }
             void PieChartItem::handleSliceChanged()
             {
                 // TODO: optimize don't need to handle all slices
                 QVector<PieSliceLayout> sliceLayout = calculateLayout();
                 applyLayout(sliceLayout);
                 update();
             }
             void PieChartItem::handleDomainChanged(qreal, qreal, qreal, qreal)
             {
                 // TODO
             }
             void PieChartItem::handleGeometryChanged(const QRectF& rect)
             {
                 prepareGeometryChange();
                 m_rect = rect;
                 QVector<PieSliceLayout> sliceLayout = calculateLayout();
                 applyLayout(sliceLayout);
                 update();
             }
             QVector<PieSliceLayout> PieChartItem::calculateLayout()
             {
                 // find pie center coordinates
                 QPointF center;
                 center.setX(m_rect.left() + (m_rect.width() * m_series->pieHorizontalPosition()));
                 center.setY(m_rect.top() + (m_rect.height() * m_series->pieVerticalPosition()));
                 // find maximum radius for pie
                 qreal radius = m_rect.height() / 2;
                 if (m_rect.width() < m_rect.height())
                     radius = m_rect.width() / 2;
                 // apply size factor
                 radius *= m_series->pieSize();
                 QVector<PieSliceLayout> layout;
                 foreach (QPieSlice* s, m_series->slices()) {
                     PieSliceLayout sliceLayout;
                     sliceLayout.m_data = s;
                     sliceLayout.m_center = PieSlice::sliceCenter(center, radius, s);
                     sliceLayout.m_radius = radius;
                     sliceLayout.m_startAngle = s->startAngle();
                     sliceLayout.m_angleSpan = s->m_angleSpan;
                     layout << sliceLayout;
                 }
                 return layout;
             }
             void PieChartItem::applyLayout(const QVector<PieSliceLayout> &layout)
             {
                 //if(m_animator)
                 //        m_animator->applyLayout(this,points);
                 //else
                 setLayout(layout);
             }
             void PieChartItem::setLayout(const QVector<PieSliceLayout> &layout)
             {
                 foreach (PieSliceLayout l, layout) {
                     // find slice
                     PieSlice *slice = m_slices.value(l.m_data);
                     if (!slice) {
                         // add a new slice
                         slice = new PieSlice(this);
                         m_slices.insert(l.m_data, slice);
                         // connect signals
                         connect(l.m_data, SIGNAL(changed()), this, SLOT(handleSliceChanged()));
                         connect(slice, SIGNAL(clicked()), l.m_data, SIGNAL(clicked()));
                         connect(slice, SIGNAL(hoverEnter()), l.m_data, SIGNAL(hoverEnter()));
                         connect(slice, SIGNAL(hoverLeave()), l.m_data, SIGNAL(hoverLeave()));
                     }
                     // update
                     slice->setLayout(l);
                     slice->updateGeometry();
                     slice->update();
                 }
                 // delete slices
                 foreach (QPieSlice *s, m_slices.keys()) {
                     bool found = false;
                     foreach (PieSliceLayout l, layout) {
                         if (l.m_data == s)
                             found = true;
                     }
                     if (!found)
                         delete m_slices.take(s);
                 }
             }
             #include "moc_piechartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/piechart/qpieseries.cpp +7 0

             #include "qpieseries.h"
             #include "qpieslice.h"
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QPieSeries::ChangeSet
                 \brief Defines the changes in the series.
                 Contains the changes that have occurred in the series. Lists of added, changed and removed slices.
                 \sa QPieSeries::changed()
             */
             /*!
                 \internal
             */
             void QPieSeries::ChangeSet::appendAdded(QPieSlice* slice)
             {
                 if (!m_added.contains(slice))
                     m_added << slice;
             }
             /*!
                 \internal
             */
             void QPieSeries::ChangeSet::appendAdded(QList<QPieSlice*> slices)
             {
                 foreach (QPieSlice* s, slices)
                     appendAdded(s);
             }
             /*!
                 \internal
             */
             void QPieSeries::ChangeSet::appendChanged(QPieSlice* slice)
             {
                 if (!m_changed.contains(slice))
                     m_changed << slice;
             }
             /*!
                 \internal
             */
             void QPieSeries::ChangeSet::appendRemoved(QPieSlice* slice)
             {
                 if (!m_removed.contains(slice))
                     m_removed << slice;
             }
             /*!
                 Returns a list of slices that have been added to the series.
                 \sa QPieSeries::changed()
             */
             QList<QPieSlice*> QPieSeries::ChangeSet::added() const
             {
                 return m_added;
             }
             /*!
                 Returns a list of slices that have been changed in the series.
                 \sa QPieSeries::changed()
             */
             QList<QPieSlice*> QPieSeries::ChangeSet::changed() const
             {
                 return m_changed;
             }
             /*!
                 Returns a list of slices that have been removed from the series.
                 \sa QPieSeries::changed()
             */
             QList<QPieSlice*> QPieSeries::ChangeSet::removed() const
             {
                 return m_removed;
             }
             /*!
                 Returns true if there are no added/changed or removed slices in the change set.
             */
             bool QPieSeries::ChangeSet::isEmpty() const
             {
                 if (m_added.count() || m_changed.count() || m_removed.count())
                     return false;
                 return true;
             }
             /*!
                 \class QPieSeries
                 \brief Pie series API for QtCommercial Charts
                 The pie series defines a pie chart which consists of pie slices which are QPieSlice objects.
                 The slices can have any values as the QPieSeries will calculate its relative value to the sum of all slices.
                 The actual slice size is determined by that relative value.
                 By default the pie is defined as a full pie but it can be a partial pie.
                 This can be done by setting a starting angle and angle span to the series.
             */
             /*!
                 Constructs a series object which is a child of \a parent.
             */
             QPieSeries::QPieSeries(QObject *parent) :
                 QSeries(parent),
                 m_pieRelativeHorPos(0.5),
                 m_pieRelativeVerPos(0.5),
                 m_pieRelativeSize(0.7),
                 m_pieStartAngle(0),
                 m_pieEndAngle(360),
                 m_total(0)
             {
             }
             /*!
                 Destroys the object. Note that adding series to QChart transfers the ownership to the chart.
             */
             QPieSeries::~QPieSeries()
             {
             }
             /*!
                 Returns QChartSeries::SeriesTypePie.
             */
             QSeries::QSeriesType QPieSeries::type() const
             {
                 return QSeries::SeriesTypePie;
             }
             /*!
                 Sets an array of \a slices to the series replacing the existing slices.
                 Slice ownership is passed to the series.
             */
             void QPieSeries::replace(QList<QPieSlice*> slices)
             {
                 clear();
                 add(slices);
             }
             /*!
                 Adds an array of \a slices to the series.
                 Slice ownership is passed to the series.
             */
             void QPieSeries::add(QList<QPieSlice*> slices)
             {
                 foreach (QPieSlice* s, slices) {
                     s->setParent(this);
                     m_slices << s;
                 }
                 updateDerivativeData();
                 foreach (QPieSlice* s, slices) {
                     connect(s, SIGNAL(changed()), this, SLOT(sliceChanged()));
                     connect(s, SIGNAL(clicked()), this, SLOT(sliceClicked()));
                     connect(s, SIGNAL(hoverEnter()), this, SLOT(sliceHoverEnter()));
                     connect(s, SIGNAL(hoverLeave()), this, SLOT(sliceHoverLeave()));
                 }
                 emit changed();
             }
             /*!
                 Adds a single \a slice to the series.
                 Slice ownership is passed to the series.
             */
             void QPieSeries::add(QPieSlice* slice)
             {
                 add(QList<QPieSlice*>() << slice);
             }
             /*!
                 Adds a single \a slice to the series and returns a reference to the series.
                 Slice ownership is passed to the series.
             */
             QPieSeries& QPieSeries::operator << (QPieSlice* slice)
             {
                 add(slice);
                 return *this;
             }
             /*!
                 Adds a single slice to the series with give \a value and \a name.
                 Slice ownership is passed to the series.
             */
             QPieSlice* QPieSeries::add(qreal value, QString name)
             {
                 QPieSlice* slice = new QPieSlice(value, name);
                 add(slice);
                 return slice;
             }
             void QPieSeries::insert(int i, QPieSlice* slice)
             {
                 Q_ASSERT(i <= m_slices.count());
                 slice->setParent(this);
                 m_slices.insert(i, slice);
                 updateDerivativeData();
                 connect(slice, SIGNAL(changed()), this, SLOT(sliceChanged()));
                 connect(slice, SIGNAL(clicked()), this, SLOT(sliceClicked()));
                 connect(slice, SIGNAL(hoverEnter()), this, SLOT(sliceHoverEnter()));
                 connect(slice, SIGNAL(hoverLeave()), this, SLOT(sliceHoverLeave()));
                 emit changed();
             }
             /*!
                 Removes a single \a slice from the series and deletes the slice.
                 Do not reference this pointer after this call.
             */
             void QPieSeries::remove(QPieSlice* slice)
             {
                 if (!m_slices.removeOne(slice)) {
                     Q_ASSERT(0); // TODO: how should this be reported?
                     return;
                 }
                 emit changed();
                 updateDerivativeData();
                 delete slice;
                 slice = NULL;
             }
             /*!
                 Clears all slices from the series.
             */
             void QPieSeries::clear()
             {
                 if (m_slices.count() == 0)
                     return;
                 foreach (QPieSlice* s, m_slices) {
                     m_slices.removeOne(s);
                     delete s;
                 }
                 emit changed();
                 updateDerivativeData();
             }
             /*!
                 Counts the number of the slices in this series.
             */
             int QPieSeries::count() const
             {
                 return m_slices.count();
             }
             /*!
                 Returns a list of slices that belong to this series.
             */
             QList<QPieSlice*> QPieSeries::slices() const
             {
                 return m_slices;
             }
             /*!
                 Sets the center position of the pie by \a relativeHorizontalPosition and \a relativeVerticalPosition.
                 The factors are relative to the chart rectangle where:
                 \a relativeHorizontalPosition 0.0 means the absolute left.
                 \a relativeHorizontalPosition 1.0 means the absolute right.
                 \a relativeVerticalPosition 0.0 means the absolute top.
                 \a relativeVerticalPosition 1.0 means the absolute bottom.
                 By default both values are 0.5 which puts the pie in the middle of the chart rectangle.
                 \sa pieHorizontalPosition(), pieVerticalPosition(), setPieSize()
             */
             void QPieSeries::setPiePosition(qreal relativeHorizontalPosition, qreal relativeVerticalPosition)
             {
                 if (relativeHorizontalPosition < 0.0 || relativeHorizontalPosition > 1.0 ||
                         relativeVerticalPosition < 0.0 || relativeVerticalPosition > 1.0)
                     return;
                 if (m_pieRelativeHorPos != relativeHorizontalPosition || m_pieRelativeVerPos != relativeVerticalPosition) {
                     m_pieRelativeHorPos = relativeHorizontalPosition;
                     m_pieRelativeVerPos = relativeVerticalPosition;
                     emit changed();
                 }
             }
             /*!
                 Gets the horizontal position of the pie.
                 The returned value is relative to the chart rectangle where:
 .0 means the absolute left.
 .0 means the absolute right.
                 By default it is 0.5 which puts the pie in the horizontal middle of the chart rectangle.
                 \sa setPiePosition(), pieVerticalPosition(), setPieSize()
             */
             qreal QPieSeries::pieHorizontalPosition() const
             {
                 return m_pieRelativeHorPos;
             }
             /*!
                 Gets the vertical position position of the pie.
                 The returned value is relative to the chart rectangle where:
 .0 means the absolute top.
 .0 means the absolute bottom.
                 By default it is 0.5 which puts the pie in the vertical middle of the chart rectangle.
                 \sa setPiePosition(), pieHorizontalPosition(), setPieSize()
             */
             qreal QPieSeries::pieVerticalPosition() const
             {
                 return m_pieRelativeVerPos;
             }
             /*!
                 Sets the relative size of the pie.
                 The \a relativeSize is defined so that the 1.0 is the maximum that can fit the given chart rectangle.
                 Default value is 0.7.
                 \sa pieSize(), setPiePosition(), pieVerticalPosition(), pieHorizontalPosition()
             */
             void QPieSeries::setPieSize(qreal relativeSize)
             {
                 if (relativeSize < 0.0 || relativeSize > 1.0)
                     return;
                 if (m_pieRelativeSize != relativeSize) {
                     m_pieRelativeSize = relativeSize;
                     emit changed();
                 }
             }
             /*!
                 Gets the relative size of the pie.
                 The size is defined so that the 1.0 is the maximum that can fit the given chart rectangle.
                 Default value is 0.7.
                 \sa setPieSize(), setPiePosition(), pieVerticalPosition(), pieHorizontalPosition()
             */
             qreal QPieSeries::pieSize() const
             {
                 return m_pieRelativeSize;
             }
             /*!
                 Sets the end angle of the pie.
                 Full pie is 360 degrees where 0 degrees is at 12 a'clock.
                 \a angle must be less than pie end angle. Default value is 0.
                 \sa pieStartAngle(), pieEndAngle(), setPieEndAngle()
             */
             void QPieSeries::setPieStartAngle(qreal angle)
             {
                 if (angle >= 0 && angle <= 360 && angle != m_pieStartAngle && angle <= m_pieEndAngle) {
                     m_pieStartAngle = angle;
                     updateDerivativeData();
                 }
             }
             /*!
                 Gets the start angle of the pie.
                 Full pie is 360 degrees where 0 degrees is at 12 a'clock. Default value is 360.
                 \sa setPieStartAngle(), pieEndAngle(), setPieEndAngle()
             */
             qreal QPieSeries::pieStartAngle() const
             {
                 return m_pieStartAngle;
             }
             /*!
                 Sets the end angle of the pie.
                 Full pie is 360 degrees where 0 degrees is at 12 a'clock.
                 \a angle must be greater than start angle.
                 \sa pieEndAngle(), pieStartAngle(), setPieStartAngle()
             */
             void QPieSeries::setPieEndAngle(qreal angle)
             {
                 if (angle >= 0 && angle <= 360 && angle != m_pieEndAngle && angle >= m_pieStartAngle) {
                     m_pieEndAngle = angle;
                     updateDerivativeData();
                 }
             }
             /*!
                 Returns the end angle of the pie.
                 Full pie is 360 degrees where 0 degrees is at 12 a'clock.
                 \sa setPieEndAngle(), pieStartAngle(), setPieStartAngle()
             */
             qreal QPieSeries::pieEndAngle() const
             {
                 return m_pieEndAngle;
             }
             /*!
                 Sets the all the slice labels \a visible or invisible.
                 \sa QPieSlice::isLabelVisible(), QPieSlice::setLabelVisible()
             */
             void QPieSeries::setLabelsVisible(bool visible)
             {
                 foreach (QPieSlice* s, m_slices)
                     s->setLabelVisible(visible);
             }
             /*!
                 Returns the sum of all slice values in this series.
                 \sa QPieSlice::value(), QPieSlice::setValue()
             */
             qreal QPieSeries::total() const
             {
                 return m_total;
             }
             /*!
                 \fn void QPieSeries::changed()
                 This signal emitted when something has changed in the series.
                 \sa QPieSeries::ChangeSet, QPieSlice::changed()
             */
             /*!
                 \fn void QPieSeries::clicked(QPieSlice* slice)
                 This signal is emitted when a \a slice has been clicked.
                 \sa QPieSlice::clicked()
             */
             /*!
                 \fn void QPieSeries::hoverEnter(QPieSlice* slice)
                 This signal is emitted when user has hovered over a \a slice.
                 \sa QPieSlice::hoverEnter()
             */
             /*!
                 \fn void QPieSeries::hoverLeave(QPieSlice* slice)
                 This signal is emitted when user has hovered away from a \a slice.
                 \sa QPieSlice::hoverLeave()
             */
             void QPieSeries::sliceChanged()
             {
                 QPieSlice* slice = qobject_cast<QPieSlice *>(sender());
                 Q_ASSERT(m_slices.contains(slice));
                 updateDerivativeData();
             }
             void QPieSeries::sliceClicked()
             {
                 QPieSlice* slice = qobject_cast<QPieSlice *>(sender());
                 Q_ASSERT(m_slices.contains(slice));
                 emit clicked(slice);
             }
             void QPieSeries::sliceHoverEnter()
             {
                 QPieSlice* slice = qobject_cast<QPieSlice *>(sender());
                 Q_ASSERT(m_slices.contains(slice));
                 emit hoverEnter(slice);
             }
             void QPieSeries::sliceHoverLeave()
             {
                 QPieSlice* slice = qobject_cast<QPieSlice *>(sender());
                 Q_ASSERT(m_slices.contains(slice));
                 emit hoverLeave(slice);
             }
             void QPieSeries::updateDerivativeData()
             {
                 m_total = 0;
                 // nothing to do?
                 if (m_slices.count() == 0)
                     return;
                 // calculate total
                 foreach (QPieSlice* s, m_slices)
                     m_total += s->value();
                 // we must have some values
                 if (m_total == 0) {
                     qDebug() << "QPieSeries::updateDerivativeData() total == 0";
                     Q_ASSERT(m_total > 0); // TODO: is this the correct way to handle this?
                 }
                 // update slice attributes
                 qreal sliceAngle = m_pieStartAngle;
                 qreal pieSpan = m_pieEndAngle - m_pieStartAngle;
                 foreach (QPieSlice* s, m_slices) {
                     bool changed = false;
                     qreal percentage = s->value() / m_total;
                     if (s->m_percentage != percentage) {
                         s->m_percentage = percentage;
                         changed = true;
                     }
                     qreal sliceSpan = pieSpan * percentage;
                     if (s->m_angleSpan != sliceSpan) {
                         s->m_angleSpan = sliceSpan;
                         changed = true;
                     }
                     if (s->m_startAngle != sliceAngle) {
                         s->m_startAngle = sliceAngle;
                         changed = true;
                     }
                     sliceAngle += sliceSpan;
                     if (changed)
                         emit s->changed();
                 }
             }
             bool QPieSeries::setModel(QAbstractItemModel* model)
             {
                 // disconnect signals from old model
                 if(m_model)
                 {
                     disconnect(m_model,SIGNAL(dataChanged(QModelIndex,QModelIndex)), 0, 0);
                     disconnect(m_model,SIGNAL(rowsInserted(QModelIndex, int, int)), 0, 0);
                     disconnect(m_model, SIGNAL(rowsRemoved(QModelIndex, int, int)), 0, 0);
                 }
                 // set new model if not NULL and connect necessary signals from it
                 if(model)
                 {
                     m_model = model;
                     connect(m_model,SIGNAL(dataChanged(QModelIndex,QModelIndex)), this, SLOT(modelUpdated(QModelIndex, QModelIndex)));
                     connect(m_model,SIGNAL(rowsInserted(QModelIndex, int, int)), this, SLOT(modelDataAdded(QModelIndex,int,int)));
                     connect(m_model, SIGNAL(rowsRemoved(QModelIndex, int, int)), this, SLOT(modelDataRemoved(QModelIndex,int,int)));
                 }
                 return true;
             }
             void QPieSeries::setModelMapping(int modelValuesLine, int modelLabelsLine, Qt::Orientation orientation)
             {
                 m_mapValues = modelValuesLine;
                 m_mapLabels = modelLabelsLine;
                 m_mapOrientation = orientation;
                 if (m_model == NULL)
                     return;
                 if (m_mapOrientation == Qt::Vertical)
                     for (int i = 0; i < m_model->rowCount(); i++)
                         add(m_model->data(m_model->index(i, m_mapValues), Qt::DisplayRole).toDouble(), m_model->data(m_model->index(i, m_mapLabels), Qt::DisplayRole).toString());
                 else
                     for (int i = 0; i < m_model->columnCount(); i++)
                         add(m_model->data(m_model->index(m_mapValues, i), Qt::DisplayRole).toDouble(), m_model->data(m_model->index(m_mapLabels, i), Qt::DisplayRole).toString());
             }
             void QPieSeries::modelUpdated(QModelIndex topLeft, QModelIndex bottomRight)
             {
+                Q_UNUSED(bottomRight)
                 if (m_mapOrientation == Qt::Vertical)
                 {
                     //        slices().at(topLeft.row())->setValue(m_model->data(m_model->index(topLeft.row(), topLeft.column()), Qt::DisplayRole).toDouble());
                     if (topLeft.column() == m_mapValues)
                         slices().at(topLeft.row())->setValue(m_model->data(topLeft, Qt::DisplayRole).toDouble());
                     else if (topLeft.column() == m_mapLabels)
                         slices().at(topLeft.row())->setLabel(m_model->data(topLeft, Qt::DisplayRole).toString());
                 }
                 else
                 {
                     //        slices().at(topLeft.column())->setValue(m_model->data(m_model->index(topLeft.row(), topLeft.column()), Qt::DisplayRole).toDouble());
                     if (topLeft.column() == m_mapValues)
                         slices().at(topLeft.column())->setValue(m_model->data(topLeft, Qt::DisplayRole).toDouble());
                     else if (topLeft.column() == m_mapLabels)
                         slices().at(topLeft.column())->setLabel(m_model->data(topLeft, Qt::DisplayRole).toString());
                 }
             }
             void QPieSeries::modelDataAdded(QModelIndex parent, int start, int end)
             {
+                Q_UNUSED(parent)
+                Q_UNUSED(end)
                 QPieSlice* newSlice = new QPieSlice;
                 newSlice->setLabelVisible(true);
                 if (m_mapOrientation == Qt::Vertical)
                 {
                     newSlice->setValue(m_model->data(m_model->index(start, m_mapValues), Qt::DisplayRole).toDouble());
                     newSlice->setLabel(m_model->data(m_model->index(start, m_mapLabels), Qt::DisplayRole).toString());
                 }
                 else
                 {
                     newSlice->setValue(m_model->data(m_model->index(m_mapValues, start), Qt::DisplayRole).toDouble());
                     newSlice->setLabel(m_model->data(m_model->index(m_mapLabels, start), Qt::DisplayRole).toString());
                 }
                 insert(start, newSlice);
             }
             void QPieSeries::modelDataRemoved(QModelIndex parent, int start, int end)
             {
+                Q_UNUSED(parent)
+                Q_UNUSED(end)
                 remove(slices().at(start));
             }
             #include "moc_qpieseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/qlegend.cpp +6 -1

             #include "qchartglobal.h"
             #include "qlegend.h"
             #include "qseries.h"
             #include "legendmarker_p.h"
             #include "qxyseries.h"
             #include "qlineseries.h"
             #include "qareaseries.h"
             #include "qscatterseries.h"
             #include "qsplineseries.h"
             #include "qbarseries.h"
             #include "qstackedbarseries.h"
             #include "qpercentbarseries.h"
             #include "qbarset.h"
             #include "qpieseries.h"
             #include "qpieslice.h"
             #include <QPainter>
             #include <QPen>
             #include <QGraphicsSceneEvent>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             QLegend::QLegend(QGraphicsItem *parent)
                 : QGraphicsObject(parent)
                 ,mBoundingRect(0,0,1,1)
                 ,mBackgroundBrush(Qt::darkGray)     // TODO: from theme?
                 ,mMinimumSize(50,20)                // TODO: magic numbers
             {
                 setVisible(false);
             }
             void QLegend::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
+                Q_UNUSED(option)
+                Q_UNUSED(widget)
                 painter->setBrush(mBackgroundBrush);
                 painter->drawRect(mBoundingRect);
             }
             QRectF QLegend::boundingRect() const
             {
                 return mBoundingRect;
             }
             void QLegend::setBackgroundBrush(const QBrush& brush)
             {
                 mBackgroundBrush = brush;
             }
             QBrush QLegend::backgroundBrush() const
             {
                 return mBackgroundBrush;
             }
             QSizeF QLegend::minimumSize() const
             {
                 return mMinimumSize;
             }
             void QLegend::setMinimumSize(const QSizeF size)
             {
                 mMinimumSize = size;
             }
-            void QLegend::handleSeriesAdded(QSeries* series,Domain* domain)
+            void QLegend::handleSeriesAdded(QSeries* series, Domain* domain)
             {
+                Q_UNUSED(domain)
                 mSeriesList.append(series);
                 createMarkers(series);
                 layoutChanged();
             }
             void QLegend::handleSeriesRemoved(QSeries* series)
             {
                 if (series->type() == QSeries::SeriesTypeArea)
                 {
                     // This is special case. Area series has upper and lower series, which each have markers
                     QAreaSeries* s = static_cast<QAreaSeries*> (series);
                     deleteMarkers(s->upperSeries());
                     deleteMarkers(s->lowerSeries());
                 } else {
                     deleteMarkers(series);
                 }
                 mSeriesList.removeOne(series);
                 layoutChanged();
             }
             void QLegend::handleGeometryChanged(const QRectF& size)
             {
                 mBoundingRect = size;
                 layoutChanged();
             }
             void QLegend::createMarkers(QSeries *series)
             {
                 switch (series->type())
                 {
                 case QSeries::SeriesTypeLine: {
                     QLineSeries* lineSeries = static_cast<QLineSeries*>(series);
                     appendMarkers(lineSeries);
                     break;
                 }
                 case QSeries::SeriesTypeArea: {
                     QAreaSeries* areaSeries = static_cast<QAreaSeries*>(series);
                     appendMarkers(areaSeries->upperSeries());
                     if(areaSeries->lowerSeries())
                     appendMarkers(areaSeries->lowerSeries());
                     break;
                 }
                 case QSeries::SeriesTypeBar: {
                     QBarSeries* barSeries = static_cast<QBarSeries*>(series);
                     appendMarkers(barSeries);
                     break;
                 }
                 case QSeries::SeriesTypeStackedBar: {
                     QStackedBarSeries* stackedBarSeries = static_cast<QStackedBarSeries*>(series);
                     appendMarkers(stackedBarSeries);
                     break;
                 }
                 case QSeries::SeriesTypePercentBar: {
                     QPercentBarSeries* percentBarSeries = static_cast<QPercentBarSeries*>(series);
                     appendMarkers(percentBarSeries);
                     break;
                 }
                 case QSeries::SeriesTypeScatter: {
                     QScatterSeries *scatterSeries = static_cast<QScatterSeries *>(series);
                     appendMarkers(scatterSeries);
                     break;
                 }
                 case QSeries::SeriesTypePie: {
                     QPieSeries *pieSeries = static_cast<QPieSeries *>(series);
                     appendMarkers(pieSeries);
                     break;
                 }
                 case QSeries::SeriesTypeSpline: {
                     QSplineSeries* splineSeries = static_cast<QSplineSeries*>(series);
                     appendMarkers(splineSeries);
                     break;
                 }
                 default: {
                     qDebug()<< "QLegend::createMarkers" << series->type() << "not implemented.";
                     break;
                 }
                 }
             }
             void QLegend::appendMarkers(QXYSeries* series)
             {
                 LegendMarker* marker = new LegendMarker(series,this);
                 marker->setName(series->name());
                 marker->setBrush(series->brush());
                 connect(marker,SIGNAL(clicked(QSeries*,Qt::MouseButton)),this,SIGNAL(clicked(QSeries*,Qt::MouseButton)));
                 mMarkers.append(marker);
                 childItems().append(marker);
             }
             void QLegend::appendMarkers(QBarSeries *series)
             {
                 foreach(QBarSet* s, series->barSets()) {
                     LegendMarker* marker = new LegendMarker(series,s,this);
                     marker->setName(s->name());
                     marker->setBrush(s->brush());
                     connect(marker,SIGNAL(clicked(QBarSet*,Qt::MouseButton)),this,SIGNAL(clicked(QBarSet*,Qt::MouseButton)));
                     connect(s,SIGNAL(changed()),marker,SLOT(changed()));
                     mMarkers.append(marker);
                     childItems().append(marker);
                 }
             }
             void QLegend::appendMarkers(QPieSeries *series)
             {
                 foreach(QPieSlice* s, series->slices()) {
                     LegendMarker* marker = new LegendMarker(series,s,this);
                     marker->setName(s->label());
                     marker->setBrush(s->sliceBrush());
                     connect(marker,SIGNAL(clicked(QPieSlice*,Qt::MouseButton)),this,SIGNAL(clicked(QPieSlice*,Qt::MouseButton)));
                     connect(s,SIGNAL(changed()),marker,SLOT(changed()));
                     mMarkers.append(marker);
                     childItems().append(marker);
                 }
             }
             void QLegend::deleteMarkers(QSeries *series)
             {
                 // Search all markers that belong to given series and delete them.
                 foreach (LegendMarker *m, mMarkers) {
                     if (m->series() == series) {
                         mMarkers.removeOne(m);
                         delete m;
                     }
                 }
             }
             void QLegend::layoutChanged()
             {
                 // Calculate layout for markers and text
                 if (mMarkers.count() <= 0) {
                     // Nothing to do
                     return;
                 }
                 qreal steps = mMarkers.count();
                 qreal xStep = mBoundingRect.width() / steps;
                 qreal x=mBoundingRect.x();
                 qreal y = mBoundingRect.y() + (mBoundingRect.height()/4);
                 foreach (LegendMarker* m, mMarkers) {
                     m->setBoundingRect(QRectF(x,y,xStep,mBoundingRect.height()/2));
                     x += xStep;
                 }
             }
             #include "moc_qlegend.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/scatterseries/scatterchartitem.cpp +3 -7

             #include "scatterchartitem_p.h"
             #include "qscatterseries.h"
             #include "chartpresenter_p.h"
             #include <QPainter>
             #include <QGraphicsScene>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ScatterChartItem::ScatterChartItem(QScatterSeries *series, QGraphicsItem *parent) :
                 XYChartItem(series,parent),
                 m_series(series),
                 m_items(this),
                 m_shape(QScatterSeries::MarkerShapeRectangle),
                 m_size(10)
             {
                 Q_ASSERT(parent);
                 Q_ASSERT(series);
                 QObject::connect(m_series,SIGNAL(updated()), this, SLOT(handleUpdated()));
                 setZValue(ChartPresenter::ScatterSeriesZValue);
                 setFlags(QGraphicsItem::ItemHasNoContents);
                 setFlags(QGraphicsItem::ItemClipsChildrenToShape);
                 handleUpdated();
                 m_items.setHandlesChildEvents(false);
                 // TODO: how to draw a drop shadow?
             //    QGraphicsDropShadowEffect *dropShadow = new QGraphicsDropShadowEffect();
             //    dropShadow->setOffset(2.0);
             //    dropShadow->setBlurRadius(2.0);
             //    setGraphicsEffect(dropShadow);
             }
             QRectF ScatterChartItem::boundingRect() const
             {
                 return m_rect;
             }
             void ScatterChartItem::createPoints(int count)
             {
                 for (int i = 0; i < count; ++i) {
                     QGraphicsItem *item;
                     switch (m_shape) {
                                case QScatterSeries::MarkerShapeCircle:{
                                    QGraphicsEllipseItem* i = new QGraphicsEllipseItem(0,0,m_size,m_size);
                                    const QRectF& rect = i->boundingRect();
                                    i->setPos(-rect.width()/2,-rect.height()/2);
                                    item = new Marker(i,this);
                                    break;
                                }
                                case QScatterSeries::MarkerShapeRectangle:{
                                    QGraphicsRectItem* i = new QGraphicsRectItem(0,0,m_size,m_size);
                                    i->setPos(-m_size/2,-m_size/2);
                                    item = new Marker(i,this);
                                    break;
                                }
                                default:
                                    qWarning()<<"Unsupported marker type";
                                    break;
                     }
                     m_items.addToGroup(item);
                 }
             }
             void ScatterChartItem::deletePoints(int count)
             {
                 QList<QGraphicsItem *> items = m_items.childItems();
                 for (int i = 0; i < count; ++i) {
                     delete(items.takeLast());
                 }
             }
             void ScatterChartItem::markerSelected(Marker* marker)
             {
                 emit XYChartItem::clicked(QPointF(m_series->x(marker->index()), m_series->y(marker->index())));
             }
             void ScatterChartItem::setLayout(QVector<QPointF>& points)
             {
                 if(points.size()==0)
                 {
                     XYChartItem::setLayout(points);
                     return;
                 }
                 int diff = XYChartItem::points().size() - points.size();
                 if(diff>0) {
                     deletePoints(diff);
                 }
                 else if(diff<0) {
                     createPoints(-diff);
                 }
                 if(diff!=0) handleUpdated();
                 QList<QGraphicsItem*> items = m_items.childItems();
                 for(int i=0; i< points.size();i++) {
                     Marker* item = static_cast<Marker*>(items.at(i));
                     const QPointF& point = points.at(i);
                     const QRectF& rect = item->boundingRect();
                     item->setIndex(i);
                     item->setPos(point.x()-rect.width()/2,point.y()-rect.height()/2);
                     if(!clipRect().contains(point)) {
                         item->setVisible(false);
                     }
                     else {
                         item->setVisible(true);
                     }
                 }
                 prepareGeometryChange();
                 m_rect = clipRect();
                 XYChartItem::setLayout(points);
             }
             void ScatterChartItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
-                Q_UNUSED(painter);
+                Q_UNUSED(painter)
-                Q_UNUSED(option);
+                Q_UNUSED(option)
-                Q_UNUSED(widget);
+                Q_UNUSED(widget)
             }
             void ScatterChartItem::setPen(const QPen& pen)
             {
                 foreach(QGraphicsItem* item , m_items.childItems()) {
                        static_cast<Marker*>(item)->setPen(pen);
                 }
             }
             void ScatterChartItem::setBrush(const QBrush& brush)
             {
                 foreach(QGraphicsItem* item , m_items.childItems()) {
                         static_cast<Marker*>(item)->setBrush(brush);
                  }
             }
             void ScatterChartItem::handleUpdated()
             {
                 int count = m_items.childItems().count();
                 if(count==0) return;
                 bool recreate = m_size != m_series->size() || m_shape != m_series->shape();
                 //TODO: only rewrite on size change
                 m_size = m_series->size();
                 m_shape = m_series->shape();
                 if(recreate){
                     deletePoints(count);
                     createPoints(count);
                 }
                 setPen(m_series->pen());
                 setBrush(m_series->brush());
             }
-            void ScatterChartItem::mousePressEvent( QGraphicsSceneMouseEvent * event )
             #include "moc_scatterchartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/scatterseries/scatterchartitem_p.h +2 -1

             #ifndef SCATTERPRESENTER_H
             #define SCATTERPRESENTER_H
             #include "qchartglobal.h"
             #include "xychartitem_p.h"
             #include <QGraphicsEllipseItem>
             #include <QPen>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QScatterSeries;
             class Marker;
             class ScatterChartItem : public XYChartItem
             {
                 Q_OBJECT
             public:
                 explicit ScatterChartItem(QScatterSeries *series, QGraphicsItem *parent = 0);
             public:
                 //from QGraphicsItem
                 QRectF boundingRect() const;
                 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
                 void setPen(const QPen& pen);
                 void setBrush(const QBrush& brush);
                 void markerSelected(Marker* item);
             public slots:
                 void handleUpdated();
             private:
                 void createPoints(int count);
                 void deletePoints(int count);
             protected:
                 void setLayout(QVector<QPointF>& points);
                 void mousePressEvent( QGraphicsSceneMouseEvent * event );
             private:
                 QScatterSeries *m_series;
                 QGraphicsItemGroup m_items;
                 int m_shape;
                 int m_size;
                 QRectF m_rect;
             };
             class Marker: public QAbstractGraphicsShapeItem
             {
             public:
                Marker(QAbstractGraphicsShapeItem* item , ScatterChartItem* parent):QAbstractGraphicsShapeItem(0),m_item(item),m_parent(parent)
                {
                };
                ~Marker()
                {
                    delete m_item;
                }
                void setIndex(int index)
                {
                    m_index=index;
                }
                int index() const
                {
                    return m_index;
                }
                QPainterPath shape() const
                {
                    return m_item->shape();
                }
                QRectF boundingRect() const
                {
                    return m_item->boundingRect();
                }
                bool contains(const QPointF &point) const
                {
                    return m_item->contains(point);
                }
                void setPen(const QPen& pen)
                {
                    m_item->setPen(pen);
                }
                void setBrush(const QBrush& brush)
                {
                    m_item->setBrush(brush);
                }
                void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
                {
                    m_item->paint(painter,option,widget);
                }
             protected:
-               void mousePressEvent( QGraphicsSceneMouseEvent * event )
+               void mousePressEvent(QGraphicsSceneMouseEvent *event)
                {
+                   Q_UNUSED(event)
                    m_parent->markerSelected(this);
                }
             private:
                QAbstractGraphicsShapeItem* m_item;
                ScatterChartItem* m_parent;
                int m_index;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // SCATTERPRESENTER_H

src/splinechart/splinechartitem.cpp +3 -2

             #include "splinechartitem_p.h"
             #include "chartpresenter_p.h"
             #include <QPainter>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             SplineChartItem::SplineChartItem(QSplineSeries* series, QGraphicsItem *parent) :
             XYChartItem(series, parent),
             m_series(series),
             m_pointsVisible(false)
             {
                 setZValue(ChartPresenter::LineChartZValue);
                 QObject::connect(series,SIGNAL(updated()),this,SLOT(handleUpdated()));
                 handleUpdated();
             }
             QRectF SplineChartItem::boundingRect() const
             {
                 return m_rect;
             }
             QPainterPath SplineChartItem::shape() const
             {
                 return m_path;
             }
             QPointF SplineChartItem::calculateGeometryControlPoint(int index) const
             {
                 return XYChartItem::calculateGeometryPoint(m_series->controlPoint(index));
             }
             void SplineChartItem::setLayout(QVector<QPointF>& points)
             {
                 if(points.size()==0)
                 {
                     XYChartItem::setLayout(points);
                     return;
                 }
                 QPainterPath splinePath;
                 const QPointF& point = points.at(0);
                 splinePath.moveTo(point);
                 for (int i = 0; i < points.size() - 1; i++)
                 {
                     const QPointF& point = points.at(i + 1);
                     splinePath.cubicTo(calculateGeometryControlPoint(2 * i), calculateGeometryControlPoint(2 * i + 1), point);
                 }
                 prepareGeometryChange();
                 m_path = splinePath;
                 m_rect = splinePath.boundingRect();
                 XYChartItem::setLayout(points);
             }
             //handlers
             void SplineChartItem::handleUpdated()
             {
                 m_pointsVisible = m_series->pointsVisible();
                 m_linePen = m_series->pen();
                 m_pointPen = m_series->pen();
                 m_pointPen.setWidthF(2*m_pointPen.width());
                 update();
             }
             //painter
             void SplineChartItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
-                Q_UNUSED(widget);
+                Q_UNUSED(widget)
-                Q_UNUSED(option);
+                Q_UNUSED(option)
                 painter->save();
                 painter->setClipRect(clipRect());
                 painter->setPen(m_linePen);
                 painter->drawPath(m_path);
                 if(m_pointsVisible){
                        painter->setPen(m_pointPen);
                        painter->drawPoints(points());
                 }
                 painter->restore();
             }
             #include "moc_splinechartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/xychart/qxyseries.cpp +6 0

             #include "qxyseries.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QXYSeries
                 \brief The QXYSeries class is a base class for line, spline and scatter series.
             */
             /*!
                \fn QPen QXYSeries::pen() const
                \brief  Returns pen used to draw points for series.
                 \sa setPen()
             */
             /*!
                \fn QBrush QXYSeries::brush() const
                \brief  Returns brush used to draw points for series.
                 \sa setBrush()
             */
             /*!
                 \fn void QXYSeries::clicked(const QPointF& point)
                 \brief Signal is emitted when user clicks the \a point on chart.
             */
             /*!
                 \fn void QXYSeries::pointReplaced(int index)
                 \brief \internal \a index
             */
             /*!
                 \fn void QXYSeries::pointAdded(int index)
                 \brief \internal \a index
             */
             /*!
                 \fn void QXYSeries::pointRemoved(int index)
                 \brief \internal \a index
             */
             /*!
                 \fn void QXYSeries::updated()
                 \brief \internal
             */
             /*!
                 Constructs empty series object which is a child of \a parent.
                 When series object is added to QChartView or QChart instance ownerships is transfered.
             */
             QXYSeries::QXYSeries(QObject* parent):QSeries(parent)
             {
                 m_mapX = -1;
                 m_mapY = -1;
                 m_mapOrientation = Qt::Vertical;
             //    m_mapYOrientation = Qt::Vertical;
             }
             /*!
                 Destroys the object. Series added to QChartView or QChart instances are owned by those,
                 and are deleted when mentioned object are destroyed.
             */
             QXYSeries::~QXYSeries()
             {
             }
             /*!
                 Adds data point \a x \a y to the series. Points are connected with lines on the chart.
              */
             void QXYSeries::add(qreal x,qreal y)
             {
                 Q_ASSERT(m_x.size() == m_y.size());
                 m_x<<x;
                 m_y<<y;
                 emit pointAdded(m_x.size()-1);
             }
             /*!
                This is an overloaded function.
                Adds data \a point to the series. Points are connected with lines on the chart.
              */
             void QXYSeries::add(const QPointF& point)
             {
                 add(point.x(),point.y());
             }
             /*!
                This is an overloaded function.
                Adds list of data \a points to the series. Points are connected with lines on the chart.
              */
             void QXYSeries::add(const QList<QPointF> points)
             {
                 foreach(const QPointF& point , points) {
                     add(point.x(),point.y());
                 }
             }
             /*!
               Modifies \a y value for given \a x a value.
             */
             void QXYSeries::replace(qreal x,qreal y)
             {
                 int index = m_x.indexOf(x);
                 m_x[index]=x;
                 m_y[index]=y;
                 emit pointReplaced(index);
             }
             /*!
               This is an overloaded function.
               Replaces current y value of for given \a point x value with \a point y value.
             */
             void QXYSeries::replace(const QPointF& point)
             {
                 replace(point.x(),point.y());
             }
             /*!
               Removes current \a x and \a y value.
             */
             void QXYSeries::remove(qreal x,qreal y)
             {
                 int index =-1;
                 do{
                     index = m_x.indexOf(x,index+1);
                 }while(index !=-1 && m_y.at(index)!=y);
                 if(index==-1) return;
                 m_x.remove(index);
                 m_y.remove(index);
                 emit pointRemoved(index);
             }
             /*!
               Removes current \a point x value. Note \a point y value is ignored.
             */
             void QXYSeries::remove(const QPointF& point)
             {
                 remove(point.x(),point.y());
             }
             /*!
                Removes all data points from the series.
             */
             void QXYSeries::removeAll()
             {
                 m_x.clear();
                 m_y.clear();
             }
             /*!
                 \internal \a pos
             */
             qreal QXYSeries::x(int pos) const
             {
                 if (m_model)
                     if (m_mapOrientation == Qt::Vertical)
                         // consecutive data is read from model's column
                         return m_model->data(m_model->index(pos, m_mapX), Qt::DisplayRole).toDouble();
                     else
                         // consecutive data is read from model's row
                         return m_model->data(m_model->index(m_mapX, pos), Qt::DisplayRole).toDouble();
                 else
                     // model is not specified, return the data from series' internal data store
                     return m_x.at(pos);
             }
             /*!
                 \internal \a pos
             */
             qreal QXYSeries::y(int pos) const
             {
                 if (m_model)
                     if (m_mapOrientation == Qt::Vertical)
                         // consecutive data is read from model's column
                         return m_model->data(m_model->index(pos, m_mapY), Qt::DisplayRole).toDouble();
                     else
                         // consecutive data is read from model's row
                         return m_model->data(m_model->index(m_mapY, pos), Qt::DisplayRole).toDouble();
                 else
                     // model is not specified, return the data from series' internal data store
                     return m_y.at(pos);
             }
             /*!
                 Returns number of data points within series.
             */
             int QXYSeries::count() const
             {
                 Q_ASSERT(m_x.size() == m_y.size());
                 if (m_model) {
                     if (m_mapOrientation == Qt::Vertical)
                         // data is in a column, so return the number of items in single column
                         return m_model->rowCount();
                     else
                         // data is in a row, so return the number of items in single row
                         return m_model->columnCount();
                 }
                 // model is not specified, return the number of points in the series internal data store
                 return m_x.size();
             }
             /*!
                 Returns the data points of the series.
             */
             QList<QPointF> QXYSeries::data()
             {
                 QList<QPointF> data;
                 for (int i(0); i < m_x.count() && i < m_y.count(); i++)
                     data.append(QPointF(m_x.at(i), m_y.at(i)));
                 return data;
             }
             /*!
                 Sets \a pen used for drawing points on the chart. If the pen is not defined, the
                 pen from chart theme is used.
                 \sa QChart::setChartTheme()
             */
             void QXYSeries::setPen(const QPen& pen)
             {
                 if(pen!=m_pen){
                     m_pen=pen;
                     emit updated();
                 }
             }
             /*!
                 Sets \a brush used for drawing points on the chart. If the brush is not defined, brush
                 from chart theme setting is used.
                 \sa QChart::setChartTheme()
             */
             void QXYSeries::setBrush(const QBrush& brush)
             {
                 if(brush!=m_brush){
                     m_brush=brush;
                     emit updated();
                 }
             }
             /*!
                 Stream operator for adding a data \a point to the series.
                 \sa add()
             */
             QXYSeries& QXYSeries::operator<< (const QPointF &point)
             {
                 add(point);
                 return *this;
             }
             /*!
                 Stream operator for adding a list of \a points to the series.
                 \sa add()
             */
             QXYSeries& QXYSeries::operator<< (const QList<QPointF> points)
             {
                 add(points);
                 return *this;
             }
             void QXYSeries::modelUpdated(QModelIndex topLeft, QModelIndex bottomRight)
             {
+                Q_UNUSED(bottomRight)
                 if (m_mapOrientation == Qt::Vertical)
                     emit pointReplaced(topLeft.row());
                 else
                     emit pointReplaced(topLeft.column());
             }
             void QXYSeries::modelDataAdded(QModelIndex parent, int start, int end)
             {
+                Q_UNUSED(parent)
+                Q_UNUSED(end)
                 emit pointAdded(start);
             }
             void QXYSeries::modelDataRemoved(QModelIndex parent, int start, int end)
             {
+                Q_UNUSED(parent)
+                Q_UNUSED(end)
                 emit pointRemoved(start);
             }
             bool QXYSeries::setModel(QAbstractItemModel* model) {
                 m_model = model;
                 //    for (int i = 0; i < m_model->rowCount(); i++)
                 //        emit pointAdded(i);
                 connect(m_model,SIGNAL(dataChanged(QModelIndex,QModelIndex)), this, SLOT(modelUpdated(QModelIndex, QModelIndex)));
                 connect(m_model,SIGNAL(rowsInserted(QModelIndex, int, int)), this, SLOT(modelDataAdded(QModelIndex,int,int)));
                 connect(m_model, SIGNAL(rowsRemoved(QModelIndex, int, int)), this, SLOT(modelDataRemoved(QModelIndex,int,int)));
                 return true;
             }
             void QXYSeries::setModelMapping(int modelX, int modelY, Qt::Orientation orientation)
             {
                 m_mapX = modelX;
                 m_mapY = modelY;
                 m_mapOrientation = orientation;
             }
             //void QXYSeries::setModelMappingY(int modelLineIndex, Qt::Orientation orientation)
             //{
             //    m_mapY = modelLineIndex;
             //    m_mapYOrientation = orientation;
             //}
             #include "moc_qxyseries.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