HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r86:84e7b4b4f9e0

Add gradient bacground support...

Michal Klocek -

r86:84e7b4b4f9e0

parent child

Context file:

r86:84e7b4b4f9e0

Collapse all files

example/colorlinechart/main.cpp +2 -1

             #include <QApplication>
             #include <QMainWindow>
             #include <qchartview.h>
             #include <qxychartseries.h>
             #include <qchart.h>
             #include <cmath>
             QTCOMMERCIALCHART_USE_NAMESPACE
             #define PI 3.14159265358979
             int main(int argc, char *argv[])
             {
                 QApplication a(argc, argv);
                 QMainWindow window;
                 QXYChartSeries* series0 = QXYChartSeries::create();
                 QPen blue(Qt::blue);
                 blue.setWidth(3);
                 series0->setPen(blue);
                 QXYChartSeries* series1 = QXYChartSeries::create();
                 QPen red(Qt::red);
                 red.setWidth(3);
                 series1->setPen(red);
                 int numPoints = 100;
                 for (int x = 0; x <= numPoints; ++x) {
                 	  series0->add(x, abs(sin(PI/50*x)*100));
                 	  series1->add(x, abs(cos(PI/50*x)*100));
                 }
                 QChartView* chartView =  new QChartView(&window);
+                chartView->setRenderHint(QPainter::Antialiasing);
                 chartView->addSeries(series0);
                 chartView->addSeries(series1);
-                //chartView->setBackgroundColor(Qt::yellow);
+                chartView->setBackground(Qt::blue,Qt::yellow,QChart::HorizonatlGradientOrientation);
                 window.setCentralWidget(chartView);
                 window.resize(400, 300);
                 window.show();
                 return a.exec();
             }

src/axisitem.cpp +2 -10

             #include "axisitem_p.h"
             #include <QPainter>
             #include <QDebug>
             #define LABEL_PADDING 5
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             AxisItem::AxisItem(AxisType type,QGraphicsItem* parent): ChartItem(parent),
             m_ticks(4),
             m_type(type)
             {
             }
             AxisItem::~AxisItem()
             {
             }
             void  AxisItem::setSize(const QSize& size)
             {
                 m_rect = QRectF(QPoint(0,0),size);
                 createItems();
             }
             void AxisItem::setLength(int length)
             {
                 QPainterPath path;
                 path.moveTo(QPointF(0,0));
                 path.lineTo(length,0);
                // path.lineTo(length-4,0);
                // path.lineTo(length,3);
                // path.lineTo(length-4,6);
                // path.lineTo(length-4,4);
                // path.lineTo(0,4);
                // path.lineTo(0,2);
                 m_path=path;
                 update();
             }
             QRectF AxisItem::boundingRect() const
             {
                 return m_rect;
             }
             void AxisItem::setPlotDomain(const PlotDomain& plotDomain)
             {
                 m_plotDomain = plotDomain;
                 createItems();
             }
             /*
             void AxisItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option,QWidget *widget)
             {
                 if (!m_rect.isValid())
                 return;
                 if(m_type==X_AXIS) {
                     const qreal deltaX = m_rect.width() / m_ticks;
                     for (int i = 0; i <= m_ticks; ++i) {
                         int x = i * deltaX + m_rect.left();
                         if(i==0) x--;
                         if(i==m_ticks) x++;
                         qreal label = m_plotDomain.m_minX + (i * m_plotDomain.spanX()
                             / m_ticks);
                         painter->drawLine(x, m_rect.top()-1, x, m_rect.bottom()+1);
                        // painter->drawLine(x, m_rect.bottom()-1, x, m_rect.bottom()-1 + 5);
                         painter->drawText(x - 50, m_rect.bottom() + 5, 100, 20,Qt::AlignHCenter | Qt::AlignTop, QString::number(label));
                     }
                 }
                 if(m_type==Y_AXIS) {
                     const qreal deltaY = (m_rect.height()) / m_ticks;
                     for (int j = 0; j <= m_ticks; ++j) {
                         int y = j * -deltaY + m_rect.bottom();
                         if(j==0) y++;
                         if(j==m_ticks) y--;
                         qreal label = m_plotDomain.m_minY + (j * m_plotDomain.spanY()
                             / m_ticks);
                         painter->drawLine(m_rect.left()-1, y, m_rect.right()+1, y);
                         //painter->drawLine(m_rect.left() - 5, y, m_rect.left(), y);
                         //TODO : margin = 50 ;
                         painter->drawText(m_rect.left() - 50, y - 10, 50 - 5, 20,
                             Qt::AlignRight | Qt::AlignVCenter,
                             QString::number(label));
                     }
                 }
                 //painter->drawRect(m_rect.adjusted(0, 0, -1, -1));
             }
             */
             void AxisItem::createItems()
             {
                 //TODO: this is very inefficient handling
                     qDeleteAll(m_shades);
                     m_shades.clear();
                     qDeleteAll(m_grid);
                     m_grid.clear();
                     qDeleteAll(m_labels);
                     m_labels.clear();
                    if(m_type==X_AXIS) {
                      const qreal deltaX = m_rect.width() / m_ticks;
                      for (int i = 0; i <= m_ticks; ++i) {
                          int x = i * deltaX + m_rect.left();
-                         //last grid outside chart rect
-                         if(i==0) x--;
-                         if(i==m_ticks) x++;
                          qreal label = m_plotDomain.m_minX + (i * m_plotDomain.spanX()/ m_ticks);
-                         m_grid<<new QGraphicsLineItem(x, m_rect.top()-1, x, m_rect.bottom()+1+LABEL_PADDING,this);
+                         m_grid<<new QGraphicsLineItem(x, m_rect.top(), x, m_rect.bottom(),this);
                          QGraphicsSimpleTextItem* text = new QGraphicsSimpleTextItem(QString::number(label),this);
                          QPointF center = text->boundingRect().center();
                          text->setPos(x - center.x(), m_rect.bottom() + LABEL_PADDING);
                          //text->rotate(-45);
                          m_labels<<text;
                      }
                    }
                    if(m_type==Y_AXIS) {
                      const qreal deltaY = m_rect.height()/ m_ticks;
                      for (int j = 0; j <= m_ticks; ++j) {
                          int y = j * -deltaY + m_rect.bottom();
-                         //last grid outside chart rect
-                         if(j==0) y++;
-                         if(j==m_ticks) y--;
                          qreal label = m_plotDomain.m_minY + (j * m_plotDomain.spanY()
                              / m_ticks);
-                         m_grid<<new QGraphicsLineItem(m_rect.left()- 1 - LABEL_PADDING , y, m_rect.right()+1, y,this);
+                         m_grid<<new QGraphicsLineItem(m_rect.left()  , y, m_rect.right(), y,this);
                          QGraphicsSimpleTextItem* text = new QGraphicsSimpleTextItem(QString::number(label),this);
                          QPointF center = text->boundingRect().center();
                          text->setPos(m_rect.left() - text->boundingRect().width() - LABEL_PADDING , y-center.y());
                          //text->rotate(-45);
                           m_labels<<text;
                      }
                    }
                    //painter->drawRect(m_rect.adjusted(0, 0, -1, -1));
             }
             //TODO "nice numbers algorithm"
             QTCOMMERCIALCHART_END_NAMESPACE

src/qchart.cpp +36 -10

             #include "qchart.h"
             #include "qchartseries.h"
             #include "qscatterseries.h"
             #include "qscatterseries_p.h"
             #include "qpieseries.h"
             #include "qxychartseries.h"
             #include "qchartaxis.h"
             #include "barchartseries.h"
             #include "bargroup.h"
             #include "xylinechartitem_p.h"
             #include "plotdomain_p.h"
             #include "axisitem_p.h"
             #include <QGraphicsScene>
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             QChart::QChart(QGraphicsObject* parent) : QGraphicsObject(parent),
-                m_background(new QGraphicsRectItem()),
+                m_background(0),
-                m_title(new QGraphicsTextItem(this)),
+                m_title(0),
                 m_axisX(new AxisItem(AxisItem::X_AXIS,this)),
                 m_plotDataIndex(0),
                 m_marginSize(0)
             {
                 // TODO: the default theme?
                 //setTheme(QChart::ChartThemeVanilla);
-                m_backgroundGradient.setColorAt(0.0, Qt::white);
                 PlotDomain domain;
                 m_plotDomainList<<domain;
                 m_axisY << new AxisItem(AxisItem::Y_AXIS,this);
                 m_chartItems<<m_axisX;
                 m_chartItems<<m_axisY.at(0);
             }
             QChart::~QChart(){}
             QRectF QChart::boundingRect() const
             {
                 return m_rect;
             }
             void QChart::addSeries(QChartSeries* series)
             {
                 // TODO: we should check the series not already added
                 m_chartSeries << series;
                 switch(series->type())
                 {
                 case QChartSeries::SeriesTypeLine: {
                     QXYChartSeries* xyseries = static_cast<QXYChartSeries*>(series);
                     // Use color defined by theme in case the series does not define a custom color
                     if (!xyseries->pen().color().isValid() && m_themeColors.count()) //TODO: wtf
                         xyseries->setPen(nextColor());
                     m_plotDataIndex = 0 ;
                     m_plotDomainList.resize(1);
                     PlotDomain& domain = m_plotDomainList[m_plotDataIndex];
                     for (int i = 0 ; i < xyseries->count() ; i++)
                     {
                         qreal x = xyseries->x(i);
                         qreal y = xyseries->y(i);
                         domain.m_minX = qMin(domain.m_minX,x);
                         domain.m_minY = qMin(domain.m_minY,y);
                         domain.m_maxX = qMax(domain.m_maxX,x);
                         domain.m_maxY = qMax(domain.m_maxY,y);
                     }
                     XYLineChartItem* item = new XYLineChartItem(xyseries,this);
                     m_chartItems<<item;
                     foreach(ChartItem* i ,m_chartItems)
                         i->setPlotDomain(m_plotDomainList.at(m_plotDataIndex));
                     break;
                 }
                 case QChartSeries::SeriesTypeBar: {
                     qDebug() << "barSeries added";
                     BarChartSeries* barSeries = static_cast<BarChartSeries*>(series);
                     BarGroup* barGroup = new BarGroup(*barSeries,this);
                     // Add some fugly colors for 5 fist series...
                     barGroup->addColor(QColor(255,0,0,128));
                     barGroup->addColor(QColor(255,255,0,128));
                     barGroup->addColor(QColor(0,255,0,128));
                     barGroup->addColor(QColor(0,0,255,128));
                     barGroup->addColor(QColor(255,128,0,128));
                     m_chartItems<<barGroup;
                     childItems().append(barGroup);
                     break;
                     }
                 case QChartSeries::SeriesTypeScatter: {
                     QScatterSeries *scatterSeries = qobject_cast<QScatterSeries *>(series);
                     scatterSeries->d->setParentItem(this);
                     // Set pre-defined colors in case the series has no colors defined
                     if (!scatterSeries->markerColor().isValid())
                         scatterSeries->setMarkerColor(nextColor());
                     connect(this, SIGNAL(sizeChanged(QRectF)),
                             scatterSeries, SLOT(chartSizeChanged(QRectF)));
             //        QColor nextColor = m_themeColors.takeFirst();
             //        nextColor.setAlpha(150); // TODO: default opacity?
             //        scatterSeries->setMarkerColor(nextColor);
                     break;
                     }
                 case QChartSeries::SeriesTypePie: {
                     QPieSeries *pieSeries = qobject_cast<QPieSeries *>(series);
                     for (int i(0); i < pieSeries->sliceCount(); i++) {
                         if (!pieSeries->sliceColor(i).isValid())
                             pieSeries->setSliceColor(i, nextColor());
                     }
                     connect(this, SIGNAL(sizeChanged(QRectF)),
                             pieSeries, SLOT(chartSizeChanged(QRectF)));
                     // Set pre-defined colors in case the series has no colors defined
                     // TODO: how to define the color for all the slices of a pie?
             //        for (int (i); i < pieSeries.sliceCount(); i++)
                     break;
                     }
                 }
             }
             QChartSeries* QChart::createSeries(QChartSeries::QChartSeriesType type)
             {
                 // TODO: support also other types; not only scatter and pie
                 QChartSeries *series(0);
                 switch (type) {
                 case QChartSeries::SeriesTypeLine: {
                     series = QXYChartSeries::create();
                     break;
                 }
                 case QChartSeries::SeriesTypeBar: {
                     series = new BarChartSeries(this);
                     break;
                 }
                 case QChartSeries::SeriesTypeScatter: {
                     series = new QScatterSeries(this);
                     break;
                 }
                 case QChartSeries::SeriesTypePie: {
                     series = new QPieSeries(this);
                     break;
                 }
                 default:
                     Q_ASSERT(false);
                     break;
                 }
                 addSeries(series);
                 return series;
             }
             void QChart::setSize(const QSize& size)
             {
                 m_rect = QRect(QPoint(0,0),size);
                 QRect rect = m_rect.adjusted(margin(),margin(), -margin(), -margin());
+                //recaculate title
+                if(m_title){
+                }
                 //recalculate background gradient
-                m_background->setRect(rect);
+                if(m_background){
-                m_backgroundGradient.setFinalStop(0,m_background->rect().height());
+                    m_background->setRect(rect);
-                m_background->setBrush(m_backgroundGradient);
+                    if(m_bacgroundOrinetation==HorizonatlGradientOrientation)
-                m_background->setPen(Qt::NoPen);
+                    m_backgroundGradient.setFinalStop(m_background->rect().width(),0);
+                    else
+                    m_backgroundGradient.setFinalStop(0,m_background->rect().height());
+                    m_background->setBrush(m_backgroundGradient);
+                }
                 //resize elements
                 foreach (ChartItem* item ,m_chartItems) {
                     item->setPos(rect.topLeft());
                     item->setSize(rect.size());
                 }
                 // TODO: TTD for setting scale
                 //emit scaleChanged(100, 100);
                 // TODO: calculate the origo
                 // TODO: not sure if emitting a signal here is the best from performance point of view
                 emit sizeChanged(QRectF(0, 0, size.width(), size.height()));
                 update();
             }
-            void QChart::setBackgroundColor(const QColor& color)
+            void QChart::setBackground(const QColor& startColor, const QColor& endColor, GradientOrientation orientation)
             {
-                m_backgroundGradient.setColorAt( 0.0, Qt::white);
-                m_backgroundGradient.setColorAt( 1.0, color);
+                if(!m_background){
+                    m_background = new QGraphicsRectItem(this);
+                    m_background->setZValue(-1);
+                }
+                m_bacgroundOrinetation = orientation;
+                m_backgroundGradient.setColorAt( 0.0, startColor);
+                m_backgroundGradient.setColorAt( 1.0, endColor);
+                m_backgroundGradient.setStart(0,0);
+                if(orientation == VerticalGradientOrientation){
+                    m_backgroundGradient.setFinalStop(0,m_rect.height());
+                }else{
+                    m_backgroundGradient.setFinalStop(m_rect.width(),0);
+                }
                 m_background->setBrush(m_backgroundGradient);
                 m_background->setPen(Qt::NoPen);
                 m_background->update();
             }
             void QChart::setTitle(const QString& title)
             {
+                if(!m_title) m_title = new QGraphicsTextItem(this);
                 m_title->setPlainText(title);
             }
             int QChart::margin() const
             {
                 return m_marginSize;
             }
             void QChart::setMargin(int margin)
             {
                 m_marginSize = margin;
             }
             void QChart::setTheme(QChart::ChartThemeId theme)
             {
             //    if (theme != m_currentTheme) {
                 m_themeColors.clear();
                 // TODO: define color themes
                 switch (theme) {
                 case QChart::ChartThemeDefault:
                     // TODO: define the default theme based on the OS
                     // For now we just fallthrough to "vanilla"
                 case QChart::ChartThemeVanilla:
                     m_themeColors.append(QColor(217, 197, 116));
                     m_themeColors.append(QColor(214, 168, 150));
                     m_themeColors.append(QColor(160, 160, 113));
                     m_themeColors.append(QColor(210, 210, 52));
                     m_themeColors.append(QColor(136, 114, 58));
                     m_backgroundGradient.setColorAt(0.0, QColor(QRgb(0xff9d844d)));
                     m_backgroundGradient.setColorAt(1.0, QColor(QRgb(0xffafafaf)));
                     break;
                 case QChart::ChartThemeIcy:
                     m_themeColors.append(QColor(0, 3, 165));
                     m_themeColors.append(QColor(49, 52, 123));
                     m_themeColors.append(QColor(71, 114, 187));
                     m_themeColors.append(QColor(48, 97, 87));
                     m_themeColors.append(QColor(19, 71, 90));
                     m_themeColors.append(QColor(110, 70, 228));
                     m_backgroundGradient.setColorAt(0.0, QColor(QRgb(0xffe4ffff)));
                     m_backgroundGradient.setColorAt(1.0, QColor(QRgb(0xffe4ffff)));
                     break;
                 case QChart::ChartThemeGrayscale:
                     m_themeColors.append(QColor(0, 0, 0));
                     m_themeColors.append(QColor(50, 50, 50));
                     m_themeColors.append(QColor(100, 100, 100));
                     m_themeColors.append(QColor(140, 140, 140));
                     m_themeColors.append(QColor(180, 180, 180));
                     m_backgroundGradient.setColorAt(0.0, QColor(QRgb(0xffffffff)));
                     m_backgroundGradient.setColorAt(1.0, QColor(QRgb(0xffafafaf)));
                     break;
                 case QChart::ChartThemeUnnamed1:
                     m_themeColors.append(QColor(QRgb(0xff3fa9f5)));
                     m_themeColors.append(QColor(QRgb(0xff7AC943)));
                     m_themeColors.append(QColor(QRgb(0xffFF931E)));
                     m_themeColors.append(QColor(QRgb(0xffFF1D25)));
                     m_themeColors.append(QColor(QRgb(0xffFF7BAC)));
                     m_backgroundGradient.setColorAt(0.0, QColor(QRgb(0xfff3dc9e)));
                     m_backgroundGradient.setColorAt(1.0, QColor(QRgb(0xffafafaf)));
                     break;
                 default:
                     Q_ASSERT(false);
                     break;
                 }
+                if(m_background){
                 m_background->setBrush(m_backgroundGradient);
                 m_background->setPen(Qt::NoPen);
+                }
                 foreach(QChartSeries* series, m_chartSeries) {
                     // TODO: other series interested on themes?
                     if (series->type() == QChartSeries::SeriesTypeLine) {
                         QXYChartSeries *lineseries = reinterpret_cast<QXYChartSeries *>(series);
                         lineseries->setPen(nextColor());
                     } else if (series->type() == QChartSeries::SeriesTypeScatter) {
                         QScatterSeries *scatter = qobject_cast<QScatterSeries *>(series);
                         scatter->setMarkerColor(nextColor());
                     } else if (series->type() == QChartSeries::SeriesTypePie) {
                         QPieSeries *pieSeries = qobject_cast<QPieSeries *>(series);
                         for (int i(0); i < pieSeries->sliceCount(); i++)
                             pieSeries->setSliceColor(i, nextColor());
                     }
                 }
                 update();
             }
             QColor QChart::nextColor()
             {
                 QColor nextColor = m_themeColors.first();
                 m_themeColors.move(0, m_themeColors.size() - 1);
                 return nextColor;
             }
             void QChart::zoomInToRect(const QRect& rectangle)
             {
                 if(!rectangle.isValid()) return;
                 qreal margin = this->margin();
                 QRect rect = rectangle.normalized();
                 rect.translate(-margin, -margin);
                 PlotDomain& oldDomain = m_plotDomainList[m_plotDataIndex];
                 PlotDomain domain = oldDomain.subDomain(rect,m_rect.width() - 2 * margin,m_rect.height() - 2 * margin);
                 m_plotDomainList.resize(m_plotDataIndex + 1);
                 m_plotDomainList<<domain;
                 m_plotDataIndex++;
                 foreach (ChartItem* item ,m_chartItems)
                     item->setPlotDomain(m_plotDomainList[m_plotDataIndex]);
                 update();
             }
             void QChart::zoomIn()
             {
                 if (m_plotDataIndex < m_plotDomainList.count() - 1) {
                     m_plotDataIndex++;
                     foreach (ChartItem* item ,m_chartItems)
                         item->setPlotDomain(m_plotDomainList[m_plotDataIndex]);
                     update();
                 }else{
                     QRect rect = m_rect.adjusted(margin(),margin(), -margin(), -margin());
                     rect.setWidth(rect.width()/2);
                     rect.setHeight(rect.height()/2);
                     rect.moveCenter(m_rect.center());
                     zoomInToRect(rect);
                 }
             }
             void QChart::zoomOut()
             {
                 if (m_plotDataIndex > 0) {
                     m_plotDataIndex--;
                     foreach (ChartItem* item ,m_chartItems)
                         item->setPlotDomain(m_plotDomainList[m_plotDataIndex]);
                     update();
                 }
             }
             void QChart::setAxisX(const QChartAxis& axis)
             {
                 setAxis(m_axisX,axis);
             }
             void QChart::setAxisY(const QChartAxis& axis)
             {
                 setAxis(m_axisY.at(0),axis);
             }
             void QChart::setAxisY(const QList<QChartAxis>& axis)
             {
                 //TODO not implemented
             }
             void QChart::setAxis(AxisItem *item, const QChartAxis& axis)
             {
                 item->setVisible(axis.isAxisVisible());
             }
             #include "moc_qchart.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/qchart.h +6 -1

             #ifndef CHART_H
             #define CHART_H
             #include <qchartglobal.h>
             #include <qchartseries.h>
             #include <QGraphicsObject>
             #include <QLinearGradient>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class AxisItem;
             class QChartSeries;
             class PlotDomain;
             class ChartItem;
             class BarGroup;
             class QChartAxis;
             // TODO: We don't need to have QChart tied to QGraphicsItem:
             //class QTCOMMERCIALCHART_EXPORT QChart
             //class QTCOMMERCIALCHART_EXPORT QChartGraphicsItem : public QGraphicsItem {
             // public: QChartGraphicsItem(QChart &chart);
             /*!
              * TODO: define the responsibilities
              */
             class QTCOMMERCIALCHART_EXPORT QChart : public QGraphicsObject
             {
                 Q_OBJECT
             public:
+                enum GradientOrientation {
+                    HorizonatlGradientOrientation,
+                    VerticalGradientOrientation
+                };
                 enum ChartThemeId {
                     /*! The default theme follows the GUI style of the Operating System */
                     ChartThemeDefault = 0,
                     ChartThemeVanilla,
                     ChartThemeIcy,
                     ChartThemeGrayscale,
                     //ChartThemeScientific,
                     ChartThemeUnnamed1
                 };
             public:
                 QChart(QGraphicsObject* parent = 0);
                 ~QChart();
                 //from QGraphicsItem
                 QRectF boundingRect() const;
                 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget){};
                 void addSeries(QChartSeries* series);
                 //TODO: QChartSeries* createSeries(QSeriesData *data, QChartSeries::QChartSeriesType type);
                 // TODO: who owns the series now? maybe owned by chart and returned a reference instead...
                 QChartSeries* createSeries(QChartSeries::QChartSeriesType type);
                 void setSize(const QSize& size);
                 void setMargin(int margin);
                 int margin() const;
                 void setTheme(QChart::ChartThemeId theme);
                 void setTitle(const QString& title);
-                void setBackgroundColor(const QColor& color);
+                void setBackground(const QColor& startColor, const QColor& endColor = Qt::white, GradientOrientation orientation = VerticalGradientOrientation);
                 void zoomInToRect(const QRect& rectangle);
                 void zoomIn();
                 void zoomOut();
                 void setAxisX(const QChartAxis& axis);
                 void setAxisY(const QChartAxis& axis);
                 void setAxisY(const QList<QChartAxis>& axis);
             private:
                 void setAxis(AxisItem *item, const QChartAxis& axis);
             signals:
                 //TODO chage to const QSize& size
                 void sizeChanged(QRectF rect);
                 void scaleChanged(qreal xscale, qreal yscale);
             private:
                 QColor nextColor();
                 Q_DISABLE_COPY(QChart)
                 QGraphicsRectItem* m_background;
                 QLinearGradient m_backgroundGradient;
+                GradientOrientation m_bacgroundOrinetation;
                 QGraphicsTextItem* m_title;
                 AxisItem* m_axisX;
                 QList<AxisItem*> m_axisY;
                 QRect m_rect;
                 QList<QChartSeries*> m_chartSeries;
                 QVector<PlotDomain> m_plotDomainList;
                 QList<ChartItem*> m_chartItems;
                 int m_plotDataIndex;
                 int m_marginSize;
                 QList<QColor> m_themeColors;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/qchartview.cpp +2 -2

             #include "qchartview.h"
             #include "qchart.h"
             #include <QGraphicsView>
             #include <QGraphicsScene>
             #include <QRubberBand>
             #include <QResizeEvent>
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             QChartView::QChartView(QWidget *parent) :
                 QGraphicsView(parent),
                 m_scene(new QGraphicsScene()),
                 m_chart(new QChart())
             {
             	setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
                 setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
                 setScene(m_scene);
                 m_chart->setMargin(50);
                 m_scene->addItem(m_chart);
                 setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
             }
             QChartView::~QChartView()
             {
             }
             void QChartView::resizeEvent(QResizeEvent *event)
             {
                 m_scene->setSceneRect(0,0,size().width(),size().height());
                 m_chart->setSize(size());
                 QWidget::resizeEvent(event);
             }
             void QChartView::addSeries(QChartSeries* series)
             {
                 m_chart->addSeries(series);
             }
             QChartSeries* QChartView::createSeries(QChartSeries::QChartSeriesType type)
             {
                 return m_chart->createSeries(type);
             }
             void QChartView::zoomInToRect(const QRect& rectangle)
             {
                 m_chart->zoomInToRect(rectangle);
             }
             void QChartView::zoomIn()
             {
                 m_chart->zoomIn();
             }
             void QChartView::zoomOut()
             {
                 m_chart->zoomOut();
             }
             int QChartView::margin() const
             {
                 return m_chart->margin();
             }
             void QChartView::setTitle(const QString& title)
             {
                 m_chart->setTitle(title);
             }
-            void QChartView::setBackgroundColor(const QColor& color)
+            void QChartView::setBackground(const QColor& startColor, const QColor& endColor, QChart::GradientOrientation orientation)
             {
-                m_chart->setBackgroundColor(color);
+                m_chart->setBackground(startColor,endColor,orientation);
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/qchartview.h +2 -1

             #ifndef QCHARTWIDGET_H
             #define QCHARTWIDGET_H
             #include "qchartglobal.h"
             #include "qchartseries.h"
+            #include "qchart.h"
             #include <QGraphicsView>
             class QGraphicsScene;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QChart;
             class QTCOMMERCIALCHART_EXPORT QChartView : public QGraphicsView
             {
             public:
                 explicit QChartView(QWidget *parent = 0);
                 ~QChartView();
                 //implement from QWidget
                 void resizeEvent(QResizeEvent *event);
                 void addSeries(QChartSeries* series);
                 // Convenience function
                 QChartSeries* createSeries(QChartSeries::QChartSeriesType type);
                 int margin() const;
                 void setTitle(const QString& title);
-                void setBackgroundColor(const QColor& color);
+                void setBackground(const QColor& startColor, const QColor& endColor = Qt::white, QChart::GradientOrientation orientation = QChart::VerticalGradientOrientation);
                 void zoomInToRect(const QRect& rectangle);
                 void zoomIn();
                 void zoomOut();
             private:
                 QGraphicsScene *m_scene;
                 QChart* m_chart;
                 QPoint m_origin;
                 Q_DISABLE_COPY(QChartView)
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QCHARTWIDGET_H

src/xylinechart/qxychartseries.cpp 0 -4

             #include "qxychartseries.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             QXYChartSeries::QXYChartSeries(QObject* parent):QChartSeries(parent)
             {
             }
             QXYChartSeries::~QXYChartSeries()
             {
             }
             QXYChartSeries* QXYChartSeries::create(QObject* parent)
             {
                 //TODO: here we take QChartData when it is ready
                 // return null if malformed;
                 return new QXYChartSeries(parent);
             }
             void QXYChartSeries::add(qreal x,qreal y)
             {
                 m_x<<x;
                 m_y<<y;
             }
             void QXYChartSeries::clear()
             {
                 m_x.clear();
                 m_y.clear();
             }
             qreal QXYChartSeries::x(int pos) const
             {
                return m_x.at(pos);
             }
             qreal QXYChartSeries::y(int pos) const
             {
                return m_y.at(pos);
             }
             int QXYChartSeries::count() const
             {
             	Q_ASSERT(m_x.size() == m_y.size());
             	return m_x.size();
             }
             void QXYChartSeries::setPen(const QPen& pen)
             {
                 m_pen=pen;
             }
-            void QXYChartSeries::setBrush(const QBrush& brush)
-                m_brush=brush;
             QDebug operator<< (QDebug debug, const QXYChartSeries series)
             {
             	Q_ASSERT(series.m_x.size() == series.m_y.size());
                 int size = series.m_x.size();
                 for (int i=0;i<size;i++) {
                 debug.nospace() << "(" << series.m_x.at(i) << ','<< series.m_y.at(i) << ") ";
                 }
                 return debug.space();
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/xylinechart/qxychartseries.h 0 -3

             #ifndef QXYSERIES_H_
             #define QXYSERIES_H_
             #include "qchartglobal.h"
             #include "qchartseries.h"
             #include <QDebug>
             #include <QPen>
             #include <QBrush>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QTCOMMERCIALCHART_EXPORT QXYChartSeries : public QChartSeries
             {
                 //TODO:
             //    Q_OBJECT
             private:
                 QXYChartSeries(QObject* parent=0);
             public:
                 virtual ~QXYChartSeries();
                 //implemented from QChartSeries
                 static QXYChartSeries* create(QObject* parent=0);
                 virtual QChartSeriesType type() const { return QChartSeries::SeriesTypeLine;}
                 void add(qreal x, qreal y);
                 void clear();
                 void setPen(const QPen& pen);
                 const QPen& pen() const { return m_pen;}
-                void setBrush(const QBrush& brush);
-                const QBrush& brush() const { return m_brush;}
                 int count() const;
                 qreal x(int pos) const;
                 qreal y(int pos) const;
                 friend QDebug operator<< (QDebug d, const QXYChartSeries series);
             private:
                 QList<qreal> m_x;
                 QList<qreal> m_y;
-                QBrush m_brush;
                 QPen m_pen;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/xylinechart/xylinechartitem.cpp +1 -1

             #include "xylinechartitem_p.h"
             #include "axisitem_p.h"
             #include "qxychartseries.h"
             #include <QPainter>
             #include <QStyleOptionGraphicsItem>
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             XYLineChartItem::XYLineChartItem(QXYChartSeries* series,QGraphicsItem *parent):ChartItem(parent),
             m_series(series),
             m_pathItem(new QGraphicsPathItem(this))
             {
                 setFlags(QGraphicsItem::ItemClipsChildrenToShape);
             }
             void XYLineChartItem::setSize(const QSize& size)
             {
                 m_rect=QRect(0,0,size.width(),size.height());
                 prepareGeometryChange();
                 updateGeometry();
             }
             void XYLineChartItem::setPlotDomain(const PlotDomain& data)
             {
                 m_plotDomain=data;
                 prepareGeometryChange();
                 updateGeometry();
             }
             QRectF XYLineChartItem::boundingRect() const
             {
             	return m_rect;
             }
             /*
             QPainterPath XYLineChartItem::shape() const
             {
                 return m_pathItem->shape();
             }
             */
             void XYLineChartItem::updateGeometry()
             {
                if (!m_rect.isValid()) return;
                const qreal deltaX = m_rect.width()/m_plotDomain.spanX();
                const qreal deltaY = m_rect.height()/m_plotDomain.spanY();
                QPainterPath path;
                for (int j = 0; j < m_series->count(); ++j) {
                    qreal dx = m_series->x(j) - m_plotDomain.m_minX;
                    qreal dy = m_series->y(j) - m_plotDomain.m_minY;
                    qreal x = (dx * deltaX) + m_rect.left();
                    qreal y = - (dy * deltaY) + m_rect.bottom();
                    if(j==0) path.moveTo(x,y);
                    else path.lineTo(x,y);
                }
                m_pathItem->setPath(path);
                m_pathItem->setPen(m_series->pen());
-               m_pathItem->setBrush(m_series->brush());
+               m_pathItem->setBrush(Qt::NoBrush);
             }
             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