HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r645:9b55fd85f9c4

Adds force option to chartTheme...

Michal Klocek -

r645:9b55fd85f9c4

parent child

Context file:

r645:9b55fd85f9c4

Collapse all files

examples/axischart/main.cpp +1 0

                 QChartAxis* axisY = chartView->axisY();
                 axisY->setLabelsAngle(45);
                 axisY->setShadesBrush(Qt::yellow);
+                axisY->setShadesVisible(true);
                 axisY->setGridLineVisible(false);
                 QChartAxisCategories* categoriesY = axisY->categories();

src/chartpresenter.cpp +18 -16

                 m_chartTheme(0),
                 m_zoomIndex(0),
                 m_rect(QRectF(QPoint(0,0),m_chart->size())),
-                m_options(QChart::NoAnimation)
+                m_options(QChart::NoAnimation),
+                m_themeForce(false)
             {
                 createConnections();
-                setChartTheme(QChart::ChartThemeDefault);
+                setChartTheme(QChart::ChartThemeDefault,false);
             }
             ChartPresenter::~ChartPresenter()
                 }
                 if(axis==m_dataset->axisX()){
-                    m_chartTheme->decorate(axis,true);
+                    m_chartTheme->decorate(axis,true,m_themeForce);
                     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);
+                    m_chartTheme->decorate(axis,false,m_themeForce);
                     QObject::connect(domain,SIGNAL(rangeYChanged(qreal,qreal,int)),item,SLOT(handleRangeChanged(qreal,qreal,int)));
                     //initialize
                     item->handleRangeChanged(domain->minY(),domain->maxY(),domain->tickYCount());
                     if(m_options.testFlag(QChart::SeriesAnimations)) {
                     	m_animator->addAnimation(line);
                     }
-                    m_chartTheme->decorate(lineSeries, m_dataset->seriesIndex(series));
+                    m_chartTheme->decorate(lineSeries, m_dataset->seriesIndex(series),m_themeForce);
                     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;
                        m_animator->addAnimation(area->upperLineItem());
                        if(areaSeries->lowerSeries())  m_animator->addAnimation(area->lowerLineItem());
                     }
-                    m_chartTheme->decorate(areaSeries, m_dataset->seriesIndex(series));
+                    m_chartTheme->decorate(areaSeries, m_dataset->seriesIndex(series),m_themeForce);
                     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;
                     if(m_options.testFlag(QChart::SeriesAnimations)) {
                      //  m_animator->addAnimation(bar);
                     }
-                    m_chartTheme->decorate(barSeries, m_dataset->seriesIndex(barSeries));
+                    m_chartTheme->decorate(barSeries, m_dataset->seriesIndex(barSeries),m_themeForce);
                     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;
                     if(m_options.testFlag(QChart::SeriesAnimations)) {
                      //  m_animator->addAnimation(bar);
                     }
-                    m_chartTheme->decorate(stackedBarSeries, m_dataset->seriesIndex(stackedBarSeries));
+                    m_chartTheme->decorate(stackedBarSeries, m_dataset->seriesIndex(stackedBarSeries),m_themeForce);
                     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;
                     if(m_options.testFlag(QChart::SeriesAnimations)) {
                      //  m_animator->addAnimation(bar);
                     }
-                    m_chartTheme->decorate(percentBarSeries, m_dataset->seriesIndex(percentBarSeries));
+                    m_chartTheme->decorate(percentBarSeries, m_dataset->seriesIndex(percentBarSeries),m_themeForce);
                     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;
                         if(m_options.testFlag(QChart::SeriesAnimations)) {
                             m_animator->addAnimation(scatter);
                         }
-                        m_chartTheme->decorate(scatterSeries, m_dataset->seriesIndex(series));
+                        m_chartTheme->decorate(scatterSeries, m_dataset->seriesIndex(series),m_themeForce);
                         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;
                     if(m_options.testFlag(QChart::SeriesAnimations)) {
                         m_animator->addAnimation(pie);
                     }
-                    m_chartTheme->decorate(pieSeries, m_dataset->seriesIndex(series));
+                    m_chartTheme->decorate(pieSeries, m_dataset->seriesIndex(series),m_themeForce);
                     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
                     if (m_chartItems.count() == 0) {
                         m_chart->axisX()->hide();
                         m_chart->axisY()->hide();
-                        m_chart->setChartBackgroundBrush(Qt::transparent);
+                        m_chart->setBackgroundVisible(false);
                     }
                     item=pie;
                     break;
                     if(m_options.testFlag(QChart::SeriesAnimations)) {
                         m_animator->addAnimation(spline);
                     }
-                    m_chartTheme->decorate(splineSeries, m_dataset->seriesIndex(series));
+                    m_chartTheme->decorate(splineSeries, m_dataset->seriesIndex(series),m_themeForce);
                     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;
                 delete item;
             }
-            void ChartPresenter::setChartTheme(QChart::ChartTheme theme)
+            void ChartPresenter::setChartTheme(QChart::ChartTheme theme,bool force)
             {
             	if(m_chartTheme && m_chartTheme->id() == theme) return;
                 delete m_chartTheme;
+                m_themeForce = force;
                 m_chartTheme = ChartTheme::createTheme(theme);
-                m_chartTheme->decorate(m_chart);
+                m_chartTheme->decorate(m_chart,m_themeForce);
-                m_chartTheme->decorate(m_chart->legend());
+                m_chartTheme->decorate(m_chart->legend(),m_themeForce);
                 resetAllElements();
             }

src/chartpresenter_p.h +2 -1

                 QRectF geometry() const;
                 ChartAnimator* animator() const {return m_animator;};
-                void setChartTheme(QChart::ChartTheme theme);
+                void setChartTheme(QChart::ChartTheme theme,bool force = true);
                 QChart::ChartTheme chartTheme();
                 void setAnimationOptions(QChart::AnimationOptions options);
                 QVector<QRectF> m_zoomStack;
                 QRectF m_rect;
                 QChart::AnimationOptions m_options;
+                bool m_themeForce;
             };

src/charttheme.cpp +109 -41

                 }
             }
-            void ChartTheme::decorate(QChart* chart)
+            void ChartTheme::decorate(QChart* chart,bool force)
             {
-                if (m_backgroundShades == BackgroundShadesNone) {
+                QPen pen;
-                    chart->setChartBackgroundBrush(m_chartBackgroundGradient);
+                QBrush brush;
-                } else {
-                    chart->setChartBackgroundBrush(Qt::NoBrush);
+                if(brush == chart->backgroundBrush() || force)
+                {
+                    if (m_backgroundShades == BackgroundShadesNone) {
+                        chart->setBackgroundBrush(m_chartBackgroundGradient);
+                    }
+                    else {
+                        chart->setBackgroundBrush(Qt::NoBrush);
+                    }
                 }
-                chart->setChartTitleFont(m_masterFont);
+                chart->setTitleFont(m_masterFont);
-                chart->setChartTitleBrush(m_titleBrush);
+                chart->setTitleBrush(m_titleBrush);
             }
-            void ChartTheme::decorate(QLegend* legend)
+            void ChartTheme::decorate(QLegend* legend,bool force)
             {
-                legend->setBackgroundBrush(m_chartBackgroundGradient);
+                QPen pen;
+                QBrush brush;
+                if (pen == legend->pen() || force){
+                    //TODO:: legend->setPen();
+                }
+                if (brush == legend->brush() || force) {
+                    legend->setBrush(m_chartBackgroundGradient);
+                }
             }
-            void ChartTheme::decorate(QAreaSeries* series, int index)
+            void ChartTheme::decorate(QAreaSeries* series, int index,bool force)
             {
                 QPen pen;
                 QBrush brush;
-                if (pen == series->pen()){
+                if (pen == series->pen() || force){
                     pen.setColor(colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), 1.0));
                     pen.setWidthF(2);
                     series->setPen(pen);
                 }
-                if (brush == series->brush()) {
+                if (brush == series->brush() || force) {
                    QBrush brush(m_seriesColors.at(index % m_seriesColors.size()));
                    series->setBrush(brush);
                 }
             }
-            void ChartTheme::decorate(QLineSeries* series,int index)
+            void ChartTheme::decorate(QLineSeries* series,int index,bool force)
             {
                 QPen pen;
-                if(pen == series->pen()){
+                if(pen == series->pen() || force ){
                     pen.setColor(m_seriesColors.at(index%m_seriesColors.size()));
                     pen.setWidthF(2);
                     series->setPen(pen);
                 }
             }
-            void ChartTheme::decorate(QBarSeries* series,int index)
+            void ChartTheme::decorate(QBarSeries* series,int index,bool force)
             {
+                QBrush brush;
                 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);
+                    if(brush == sets.at(i)->brush() || force ){
                     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?
+                    QColor 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(QStackedBarSeries* series,int index)
+            void ChartTheme::decorate(QStackedBarSeries* series,int index,bool force)
             {
+                QBrush brush;
                 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);
+                    if(brush == sets.at(i)->brush() || force){
                     QColor c = colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), pos);
                     sets.at(i)->setBrush(QBrush(c));
+                    }
+                    QColor c;
                     if (pos < 0.3) {
                         c = colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), 1);
                     } else {
                 }
             }
-            void ChartTheme::decorate(QPercentBarSeries* series,int index)
+            void ChartTheme::decorate(QPercentBarSeries* series,int index,bool force)
             {
+                QBrush brush;
                 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);
+                    if(brush == sets.at(i)->brush() || force){
                     QColor c = colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), pos);
                     sets.at(i)->setBrush(QBrush(c));
+                    }
+                    QColor c;
                     if (pos < 0.3) {
                         c = colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), 1);
                     } else {
                 }
             }
-            void ChartTheme::decorate(QScatterSeries* series, int index)
+            void ChartTheme::decorate(QScatterSeries* series, int index,bool force)
             {
                 QPen pen;
                 QBrush brush;
-                if (pen == series->pen()) {
+                if (pen == series->pen() || force) {
                     pen.setColor(colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), 1.0));
                     pen.setWidthF(2);
                     series->setPen(pen);
                 }
-                if (brush == series->brush()) {
+                if (brush == series->brush() || force) {
                     QBrush brush(m_seriesColors.at(index % m_seriesColors.size()));
                     series->setBrush(brush);
                 }
             }
-            void ChartTheme::decorate(QPieSeries* series, int index)
+            void ChartTheme::decorate(QPieSeries* series, int index, bool force)
             {
                 // Get color for a slice from a gradient linearly, beginning from the start of the gradient
+                QPen pen;
+                QBrush brush;
                 for (int i(0); i < series->slices().count(); i++) {
                     qreal pos = (qreal) i / (qreal) series->count();
+                    if( pen == series->slices().at(i)->slicePen() || force){
                     QColor penColor = colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), 0.1);
                     series->slices().at(i)->setSlicePen(penColor);
+                    }
+                    if( brush == series->slices().at(i)->sliceBrush() || force){
                     QColor brushColor = colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), pos);
                     series->slices().at(i)->setSliceBrush(brushColor);
+                    }
                 }
             }
-            void ChartTheme::decorate(QSplineSeries* series, int index)
+            void ChartTheme::decorate(QSplineSeries* series, int index, bool force)
             {
                 QPen pen;
-                if(pen == series->pen()){
+                if(pen == series->pen() || force){
                     pen.setColor(m_seriesColors.at(index%m_seriesColors.size()));
                     pen.setWidthF(2);
                     series->setPen(pen);
                 }
             }
-            void ChartTheme::decorate(QChartAxis* axis,bool axisX)
+            void ChartTheme::decorate(QChartAxis* axis,bool axisX, bool force)
             {
+                QPen pen;
+                QBrush brush;
+                QFont font;
                 if (axis->isAxisVisible()) {
-                    axis->setLabelsBrush(m_axisLabelBrush);
-                    axis->setLabelsPen(Qt::NoPen); // NoPen for performance reasons
+                    if(brush == axis->labelsBrush() || force){
-                    if (m_backgroundShades == BackgroundShadesBoth
+                        axis->setLabelsBrush(m_axisLabelBrush);
-                            || (m_backgroundShades == BackgroundShadesVertical && axisX)
-                            || (m_backgroundShades == BackgroundShadesHorizontal && !axisX)) {
+                    if(pen == axis->labelsPen() || force){
-                        axis->setShadesPen(m_backgroundShadesPen);
+                        axis->setLabelsPen(Qt::NoPen); // NoPen for performance reasons
-                        axis->setShadesBrush(m_backgroundShadesBrush);
-                    } else {
-                        // The shades not supposed to be shown for this axis, clear possible brush and pen
-                        axis->setShadesPen(Qt::NoPen);
+                   if (axis->shadesVisible() || force) {
-                        axis->setShadesBrush(Qt::NoBrush);
+                     if(brush == axis->shadesBrush() || force){
+                         axis->setShadesBrush(m_backgroundShadesBrush);
+                     }
+                     if(pen == axis->shadesPen() || force){
+                         axis->setShadesPen(m_backgroundShadesPen);
+                     }
+                     if(force && (m_backgroundShades == BackgroundShadesBoth
+                                     || (m_backgroundShades == BackgroundShadesVertical && axisX)
+                                     || (m_backgroundShades == BackgroundShadesHorizontal && !axisX))){
+                         axis->setShadesVisible(true);
+                     }
+                   }
+                    if(pen == axis->axisPen() || force){
+                        axis->setAxisPen(m_axisLinePen);
+                    }
+                    if(pen == axis->gridLinePen() || force){
+                        axis->setGridLinePen(m_gridLinePen);
+                    }
+                    if(font == axis->labelsFont() || force){
+                        axis->setLabelsFont(m_masterFont);
                     }
-                    axis->setAxisPen(m_axisLinePen);
-                    axis->setGridLinePen(m_gridLinePen);
-                    axis->setLabelsFont(m_masterFont);
                 }
             }

src/charttheme_p.h +11 -11

@@ -42,18 +42,18 protected:
42	public:	42	public:
43	static ChartTheme* createTheme(QChart::ChartTheme theme);	43	static ChartTheme* createTheme(QChart::ChartTheme theme);
44	QChart::ChartTheme id() const {return m_id;}	44	QChart::ChartTheme id() const {return m_id;}
45	void decorate(QChart* chart);	45	void decorate(QChart* chart,bool force = true);
46	void decorate(QLegend* legend);	46	void decorate(QLegend* legend,bool force = true);
47	//void decorate(ChartItem* item, QSeries* series,int index);	47	//void decorate(ChartItem* item, QSeries* series,int index);
48	void decorate(QBarSeries* series, int index);	48	void decorate(QBarSeries* series, int index,bool force = true);
49	void decorate(QStackedBarSeries* series, int index);	49	void decorate(QStackedBarSeries* series, int index,bool force = true);
50	void decorate(QPercentBarSeries* series, int index);	50	void decorate(QPercentBarSeries* series, int index,bool force = true);
51	void decorate(QLineSeries* series, int index);	51	void decorate(QLineSeries* series, int index,bool force = true);
52	void decorate(QAreaSeries* series, int index);	52	void decorate(QAreaSeries* series, int index,bool force = true);
53	void decorate(QScatterSeries* series, int index);	53	void decorate(QScatterSeries* series, int index,bool force = true);
54	void decorate(QPieSeries* series, int index);	54	void decorate(QPieSeries* series, int index,bool force = true);
55	void decorate(QSplineSeries* series, int index);	55	void decorate(QSplineSeries* series, int index,bool force = true);
56	void decorate(QChartAxis* axis, bool axisX);	56	void decorate(QChartAxis* axis, bool axisX,bool force = true);
57		57
58	public: // utils	58	public: // utils
59	void generateSeriesGradients();	59	void generateSeriesGradients();

src/qchart.cpp +33 -8

             /*!
                 Sets the \a brush that is used for painting the background of the chart area.
             */
-            void QChart::setChartBackgroundBrush(const QBrush& brush)
+            void QChart::setBackgroundBrush(const QBrush& brush)
             {
                 createChartBackgroundItem();
                 m_backgroundItem->setBrush(brush);
                 m_backgroundItem->update();
             }
+            QBrush QChart::backgroundBrush() const
+            {
+                if(!m_backgroundItem) return QBrush();
+                return m_backgroundItem->brush();
+            }
             /*!
                 Sets the \a pen that is used for painting the background of the chart area.
             */
-            void QChart::setChartBackgroundPen(const QPen& pen)
+            void QChart::setBackgroundPen(const QPen& pen)
             {
                 createChartBackgroundItem();
                 m_backgroundItem->setPen(pen);
                 m_backgroundItem->update();
             }
+            QPen QChart::backgroundPen() const
+            {
+                if(!m_backgroundItem) return QPen();
+                return m_backgroundItem->pen();
+            }
             /*!
                 Sets the chart \a title. The description text that is drawn above the chart.
             */
-            void QChart::setChartTitle(const QString& title)
+            void QChart::setTitle(const QString& title)
             {
                 createChartTitleItem();
                 m_titleItem->setText(title);
             /*!
                 Returns the chart title. The description text that is drawn above the chart.
             */
-            QString QChart::chartTitle() const
+            QString QChart::title() const
             {
                 if(m_titleItem)
                 return m_titleItem->text();
             /*!
                 Sets the \a font that is used for rendering the description text that is rendered above the chart.
             */
-            void QChart::setChartTitleFont(const QFont& font)
+            void QChart::setTitleFont(const QFont& font)
             {
                 createChartTitleItem();
                 m_titleItem->setFont(font);
             /*!
                 Sets the \a brush used for rendering the title text.
             */
-            void QChart::setChartTitleBrush(const QBrush &brush)
+            void QChart::setTitleBrush(const QBrush &brush)
             {
                 createChartTitleItem();
                 m_titleItem->setBrush(brush);
             /*!
                 Returns the brush used for rendering the title text.
             */
-            QBrush QChart::chartTitleBrush()
+            QBrush QChart::titleBrush() const
             {
-                createChartTitleItem();
+                if(!m_titleItem) return QBrush();
                 return m_titleItem->brush();
             }
                 m_backgroundItem->update();
             }
+            void QChart::setBackgroundVisible(bool visible)
+            {
+                createChartBackgroundItem();
+                m_backgroundItem->setVisible(visible);
+            }
+            bool QChart::isBackgroundVisible() const
+            {
+                if(!m_backgroundItem) return false;
+                return m_backgroundItem->isVisible();
+            }
             #include "moc_qchart.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/qchart.h +13 -7

@@ -58,13 +58,19 public:
58	void setChartTheme(QChart::ChartTheme theme);	58	void setChartTheme(QChart::ChartTheme theme);
59	QChart::ChartTheme chartTheme() const;	59	QChart::ChartTheme chartTheme() const;
60		60
61	void set~~Chart~~Title(const QString& title);	61	void setTitle(const QString& title);
62	QString ~~char~~tTitle() const;	62	QString title() const;
63	void set~~Chart~~TitleFont(const QFont& font);	63	void setTitleFont(const QFont& font);
64	void setChartTitleBrush(const QBrush &brush);	64	QFont titleFont() const;
65	QBrush chartTitleBrush();	65	void setTitleBrush(const QBrush &brush);
66	void setChartBackgroundBrush(const QBrush& brush);	66	QBrush titleBrush() const;
67	void set~~Chart~~Background~~Pen~~(const Q~~Pen~~& ~~pen~~);	67	void setBackgroundBrush(const QBrush& brush);
		68	QBrush backgroundBrush() const;
		69	void setBackgroundPen(const QPen& pen);
		70	QPen backgroundPen() const;
		71
		72	void setBackgroundVisible(bool visible);
		73	bool isBackgroundVisible() const;
68		74
69	void setAnimationOptions(AnimationOptions options);	75	void setAnimationOptions(AnimationOptions options);
70	AnimationOptions animationOptions() const;	76	AnimationOptions animationOptions() const;

src/qchartview.cpp +7 -7

             */
             void QChartView::setChartTitle(const QString& title)
             {
-                m_chart->setChartTitle(title);
+                m_chart->setTitle(title);
             }
             /*!
             */
             QString QChartView::chartTitle() const
             {
-                return m_chart->chartTitle();
+                return m_chart->title();
             }
             /*!
             */
             void QChartView::setChartTitleFont(const QFont& font)
             {
-                m_chart->setChartTitleFont(font);
+                m_chart->setTitleFont(font);
             }
             /*!
             */
             void QChartView::setChartTitleBrush(const QBrush &brush)
             {
-                m_chart->setChartTitleBrush(brush);
+                m_chart->setTitleBrush(brush);
             }
             /*!
             */
             QBrush QChartView::chartTitleBrush()
             {
-                return m_chart->chartTitleBrush();
+                return m_chart->titleBrush();
             }
             /*!
             */
             void QChartView::setChartBackgroundBrush(const QBrush& brush)
             {
-                m_chart->setChartBackgroundBrush(brush);
+                m_chart->setBackgroundBrush(brush);
             }
             /*!
             */
             void QChartView::setChartBackgroundPen(const QPen& pen)
             {
-                m_chart->setChartBackgroundPen(pen);
+                m_chart->setBackgroundPen(pen);
             }
             /*!

src/qlegend.cpp +23 -6

                 ,mSize(0,0)
                 ,mMinimumSize(50,20)                // TODO: magic numbers
                 ,mMaximumSize(150,100)
-                ,mBackgroundBrush(Qt::darkGray)     // TODO: from theme?
+                ,m_brush(Qt::darkGray)     // TODO: from theme?
                 ,mPreferredLayout(QLegend::PreferredLayoutVertical)
             {
             //    setVisible(false);
                 Q_UNUSED(widget)
                 painter->setOpacity(0.5);
-                painter->setBrush(mBackgroundBrush);
+                painter->setPen(m_pen);
+                painter->setBrush(m_brush);
                 painter->drawRect(boundingRect());
             }
                 return QRectF(mPos,mSize);
             }
-            void QLegend::setBackgroundBrush(const QBrush& brush)
+            void QLegend::setBrush(const QBrush& brush)
             {
-                mBackgroundBrush = brush;
+                if(m_brush!=brush){
+                    m_brush = brush;
+                    update();
+                }
+            }
+            QBrush QLegend::brush() const
+            {
+                return m_brush;
+            }
+            void QLegend::setPen(const QPen& pen)
+            {
+                if(m_pen!=pen){
+                    m_pen = pen;
+                    update();
+                }
             }
-            QBrush QLegend::backgroundBrush() const
+            QPen QLegend::pen() const
             {
-                return mBackgroundBrush;
+                return m_pen;
             }
             void QLegend::setPreferredLayout(QLegend::PreferredLayout preferred)

src/qlegend.h +7 -3

                 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = 0);
                 QRectF boundingRect() const;
-                void setBackgroundBrush(const QBrush& brush);
+                void setBrush(const QBrush& brush);
-                QBrush backgroundBrush() const;
+                QBrush brush() const;
+                void setPen(const QPen& pen);
+                QPen pen() const;
                 void setPreferredLayout(QLegend::PreferredLayout preferred);
             //    QList<QSeries*> mSeriesList;
                 QList<LegendMarker*> mMarkers;
-                QBrush mBackgroundBrush;
+                QBrush m_brush;
+                QPen m_pen;
                 QLegend::PreferredLayout mPreferredLayout;
             };

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