HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r548:426b0f7a9c96

Added axis related modifiers to theme

Tero Ahola -

r548:426b0f7a9c96

parent child

Context file:

r548:426b0f7a9c96

Collapse all files

src/charttheme.cpp +25 -10

             #include "charttheme_p.h"
             #include "qchart.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 "piepresenter_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"
             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();
                     default:
                         return new ChartThemeDefault();
                 }
             }
             void ChartTheme::decorate(QChart* chart)
             {
                 chart->setChartBackgroundBrush(m_backgroundGradient);
             }
             void ChartTheme::decorate(QLegend* legend)
             {
                 legend->setBackgroundBrush(m_backgroundGradient);
             }
             void ChartTheme::decorate(AreaChartItem* item, QAreaSeries* series, int index)
             {
                 QPen pen;
                 QBrush brush;
                 if (pen != series->pen()){
                    item->setPen(series->pen());
                 } else {
                     pen.setColor(colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), 1.0));
                     pen.setWidthF(2);
                     item->setPen(pen);
                 }
                 if (brush != series->brush()) {
                    item->setBrush(series->brush());
                 } else {
                    QBrush brush(m_seriesColors.at(index % m_seriesColors.size()));
                    item->setBrush(brush);
                 }
             }
             void ChartTheme::decorate(LineChartItem* item, QLineSeries* series,int index)
             {
                 QPen pen;
                 if(pen != series->pen()){
                     series->setPen(series->pen());
                     return;
                 }else{
                     pen.setColor(m_seriesColors.at(index%m_seriesColors.size()));
                     pen.setWidthF(2);
                     series->setPen(pen);
                 }
             }
             void ChartTheme::decorate(BarPresenter* item, 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)
             {
                 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)
             {
                 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(ScatterChartItem* item, QScatterSeries* series, int index)
             {
                 Q_ASSERT(item);
                 Q_ASSERT(series);
                 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(PiePresenter* item, 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(QChartAxis* axis, AxisItem* item)
-                //TODO: dummy defults for now
-                axis->setLabelsBrush(Qt::black);
-                axis->setLabelsPen(Qt::NoPen);
-                axis->setShadesPen(Qt::NoPen);
-                axis->setShadesOpacity(0.5);
             void ChartTheme::decorate(SplineChartItem* item, QSplineSeries* series, int index)
             {
                 Q_ASSERT(item);
                 Q_ASSERT(series);
                 QPen pen;
                 if(pen != series->pen()){
                     item->setLinePen(series->pen());
                 }else{
                     pen.setColor(m_seriesColors.at(index%m_seriesColors.size()));
                     pen.setWidthF(series->pen().widthF());
                     item->setLinePen(series->pen());
                 }
             //    QColor color = m_seriesColors.at(index % m_seriesColors.size());
                 // TODO: define alpha in the theme? or in the series?
                 //color.setAlpha(120);
             //    QBrush brush(color, Qt::SolidPattern);
             //    presenter->m_markerBrush = brush;
             //    QPen pen(brush, 3);
             //    pen.setColor(color);
             //    presenter->m_markerPen = pen;
             }
+            void ChartTheme::decorate(QChartAxis* axis, AxisItem* item)
+            {
+                Q_ASSERT(axis);
+                Q_ASSERT(item);
+                if (axis->isAxisVisible()) {
+                    axis->setLabelsBrush(m_axisLabelBrush);
+                    axis->setLabelsPen(m_axisLabelPen);
+                    // TODO: check the axis type (x or y) should define whether to show the shades or not
+                    if (m_backgroundShades == BackgroundShadesBoth
+                            || m_backgroundShades == BackgroundShadesVertical /*&& x axis ?*/
+                            || m_backgroundShades == BackgroundShadesHorizontal /* && y axis*/) {
+                        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 +17 -8

             #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 PiePresenter;
             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(StackedBarPresenter* item, QStackedBarSeries* series, int index);
                 void decorate(PercentBarPresenter* item, QPercentBarSeries* series, int index);
                 void decorate(LineChartItem* item, QLineSeries* series, int index);
                 void decorate(AreaChartItem* item, QAreaSeries* series, int index);
                 void decorate(ScatterChartItem* presenter, QScatterSeries* series, int index);
                 void decorate(PiePresenter* item, QPieSeries* series, int index);
-                void decorate(QChartAxis* axis,AxisItem* item);
                 void decorate(SplineChartItem* presenter, QSplineSeries* series, int index);
+                void decorate(QChartAxis* axis, AxisItem* item);
             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_backgroundGradient;
-                // TODO: Add something like the following to themes:
+                QFont m_masterFont;
-            //    QPen axisLinePen;
+                QPen m_axisLinePen;
-            //    QPen backgroundHorizontalGridPen;
+                QBrush m_axisLabelBrush;
-            //    QPen backgroundVerticalGridPen;
+                QPen m_axisLabelPen;
-            //    // FillAll, FillEverySecondRow, FillEverySecondColumn, FillEverySecondRowAndColumn, FillNone
+                QPen m_backgroundShadesPen;
-            //    int backgroundType;
+                QBrush m_backgroundShadesBrush;
-            //    QFont masterFont;
+                BackgroundShadesMode m_backgroundShades;
+                QPen m_gridLinePen;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // CHARTTHEME_H

src/themes/chartthemedefault_p.h +81 -23

             #include "charttheme_p.h"
             #ifdef Q_OS_WIN
             #include <windows.h>
             #include <stdio.h>
             #endif
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class ChartThemeDefault: public ChartTheme
             {
             public:
                 ChartThemeDefault():ChartTheme(QChart::ChartThemeDefault)
                 {
             #ifdef Q_OS_WIN
-                    // First series base color from COLOR_WINDOWFRAME
+                    // TODO: use theme specific window frame color as a series base color (it would give more
-                    DWORD colorWindowFrame;
+                    // variation to the base colors in addition to the blue and black used now)
-                    colorWindowFrame = GetSysColor(COLOR_WINDOWFRAME);
+                    // TODO: COLOR_WINDOWTEXT for text color?
-                    m_seriesColors.append(QColor(GetRValue(colorWindowFrame), GetGValue(colorWindowFrame),GetBValue(colorWindowFrame)));
+                    // TODO: COLOR_INFOTEXT for tooltip text color?
+                    // TODO: COLOR_INFOBK for tooltip background color?
-                    // Second series base color from COLOR_HIGHLIGHT
+                    // First series base color from COLOR_HIGHLIGHT
                     DWORD colorHighlight;
                     colorHighlight = GetSysColor(COLOR_HIGHLIGHT);
-                    m_seriesColors.append(QColor(GetRValue(colorHighlight), GetGValue(colorHighlight),GetBValue(colorHighlight)));
+                    m_seriesColors.append(QColor(GetRValue(colorHighlight),
+                                                 GetGValue(colorHighlight),
+                                                 GetBValue(colorHighlight)));
+                    // Second series base color from COLOR_WINDOWFRAME
+                    DWORD colorWindowFrame;
+                    colorWindowFrame = GetSysColor(COLOR_WINDOWFRAME);
+                    m_seriesColors.append(QColor(GetRValue(colorWindowFrame),
+                                                 GetGValue(colorWindowFrame),
+                                                 GetBValue(colorWindowFrame)));
-                    // Thirs series base color from the middle of the COLOR_ACTIVECAPTION /
+                    // Third series base color from the middle of the COLOR_ACTIVECAPTION /
                     // COLOR_GRADIENTACTIVECAPTION gradient
                     DWORD colorGradientActiveCaptionLeft;
                     colorGradientActiveCaptionLeft = GetSysColor(COLOR_ACTIVECAPTION);
                     DWORD colorGradientActiveCaptionRight;
                     colorGradientActiveCaptionRight = GetSysColor(COLOR_GRADIENTACTIVECAPTION);
                     QLinearGradient g;
                     QColor start = QColor(GetRValue(colorGradientActiveCaptionLeft),
                                           GetGValue(colorGradientActiveCaptionLeft),
                                           GetBValue(colorGradientActiveCaptionLeft));
                     g.setColorAt(0.0, start);
                     QColor end = QColor(GetRValue(colorGradientActiveCaptionRight),
                                           GetGValue(colorGradientActiveCaptionRight),
                                           GetBValue(colorGradientActiveCaptionRight));
                     g.setColorAt(1.0, end);
                     m_seriesColors.append(colorAt(g, 0.5));
                     // Generate gradients from the base colors
                     generateSeriesGradients();
                     // Background fill color from COLOR_WINDOW
                     QLinearGradient backgroundGradient;
                     DWORD colorWindow;
                     colorWindow = GetSysColor(COLOR_WINDOW);
                     backgroundGradient.setColorAt(0.0, QColor(GetRValue(colorWindow),
                                                               GetGValue(colorWindow),
                                                               GetBValue(colorWindow)));
                     backgroundGradient.setColorAt(1.0, QColor(GetRValue(colorWindow),
                                                               GetGValue(colorWindow),
                                                               GetBValue(colorWindow)));
+                    // Axes and other
+                    m_masterFont = QFont();
+                    m_masterFont.setPointSizeF(10.0);
+                    m_axisLinePen = QPen(Qt::black);
+                    m_axisLinePen.setWidth(2);
+                    m_axisLabelBrush = QBrush(Qt::black);
+                    m_axisLabelPen = Qt::NoPen; // NoPen for performance reasons
+                    m_backgroundShadesPen = Qt::NoPen;
+                    m_backgroundShadesBrush = QBrush(QColor(0xaf, 0xaf, 0xaf, 0x50));
+                    m_backgroundShades = BackgroundShadesVertical;
-                    // TODO: COLOR_WINDOWTEXT for text color?
-                    // TODO: COLOR_INFOTEXT for tooltip text color?
-                    // TODO: COLOR_INFOBK for tooltip background color?
             #elif defined(Q_OS_LINUX)
                     // TODO: replace this dummy theme with linux specific theme
-                    m_seriesColors << QRgb(0xff707070);
+                    m_seriesColors << QRgb(0x60a6e6);
-                    m_seriesColors << QRgb(0xffA0A0A0);
+                    m_seriesColors << QRgb(0x92ca66);
+                    m_seriesColors << QRgb(0xeba85f);
+                    m_seriesColors << QRgb(0xfc5751);
                     generateSeriesGradients();
                     QLinearGradient backgroundGradient;
-                    backgroundGradient.setColorAt(0.0, QRgb(0xffffffff));
+                    backgroundGradient.setColorAt(0.0, QRgb(0xffffff));
-                    backgroundGradient.setColorAt(1.0, QRgb(0xffafafaf));
+                    backgroundGradient.setColorAt(1.0, QRgb(0xe9e9e9));
                     backgroundGradient.setCoordinateMode(QGradient::ObjectBoundingMode);
                     m_backgroundGradient = backgroundGradient;
-            #elif Q_OS_MAC
+                    // Axes and other
+                    m_masterFont = QFont();
+                    m_masterFont.setPointSizeF(10.0);
+                    m_axisLinePen = QPen(Qt::black);
+                    m_axisLinePen.setWidth(2);
+                    m_axisLabelBrush = QBrush(Qt::black);
+                    m_axisLabelPen = Qt::NoPen; // NoPen for performance reasons
+                    m_backgroundShadesPen = Qt::NoPen;
+                    m_backgroundShadesBrush = QBrush(QColor(0xaf, 0xaf, 0xaf, 0x50));
+                    m_backgroundShades = BackgroundShadesVertical;
+            #elif defined(Q_OS_MAC)
                     // TODO: replace this dummy theme with OSX specific theme
-                    m_seriesColors << QRgb(0xff707070);
+                    m_seriesColors << QRgb(0x60a6e6);
-                    m_seriesColors << QRgb(0xffA0A0A0);
+                    m_seriesColors << QRgb(0x92ca66);
+                    m_seriesColors << QRgb(0xeba85f);
+                    m_seriesColors << QRgb(0xfc5751);
                     generateSeriesGradients();
                     QLinearGradient backgroundGradient;
-                    backgroundGradient.setColorAt(0.0, QRgb(0xffffffff));
+                    backgroundGradient.setColorAt(0.0, QRgb(0xffffff));
-                    backgroundGradient.setColorAt(1.0, QRgb(0xffafafaf));
+                    backgroundGradient.setColorAt(1.0, QRgb(0xe9e9e9));
                     backgroundGradient.setCoordinateMode(QGradient::ObjectBoundingMode);
                     m_backgroundGradient = backgroundGradient;
+                    // Axes and other
+                    m_masterFont = QFont();
+                    m_masterFont.setPointSizeF(10.0);
+                    m_axisLinePen = QPen(Qt::black);
+                    m_axisLinePen.setWidth(2);
+                    m_axisLabelBrush = QBrush(Qt::black);
+                    m_axisLabelPen = Qt::NoPen; // NoPen for performance reasons
+                    m_backgroundShadesPen = Qt::NoPen;
+                    m_backgroundShadesBrush = QBrush(QColor(0xaf, 0xaf, 0xaf, 0x50));
+                    m_backgroundShades = BackgroundShadesVertical;
             #else
                     // TODO: replace this dummy theme with generic (not OS specific) theme
-                    m_seriesColors << QRgb(0xff707070);
+                    m_seriesColors << QRgb(0x60a6e6);
-                    m_seriesColors << QRgb(0xffA0A0A0);
+                    m_seriesColors << QRgb(0x92ca66);
+                    m_seriesColors << QRgb(0xeba85f);
+                    m_seriesColors << QRgb(0xfc5751);
                     generateSeriesGradients();
                     QLinearGradient backgroundGradient;
-                    backgroundGradient.setColorAt(0.0, QRgb(0xffffffff));
+                    backgroundGradient.setColorAt(0.0, QRgb(0xffffff));
-                    backgroundGradient.setColorAt(1.0, QRgb(0xffafafaf));
+                    backgroundGradient.setColorAt(1.0, QRgb(0xafafaf));
                     backgroundGradient.setCoordinateMode(QGradient::ObjectBoundingMode);
                     m_backgroundGradient = backgroundGradient;
+                    // Axes and other
+                    m_masterFont = QFont();
+                    m_masterFont.setPointSizeF(10.0);
+                    m_axisLinePen = QPen(Qt::black);
+                    m_axisLinePen.setWidth(2);
+                    m_axisLabelBrush = QBrush(Qt::black);
+                    m_axisLabelPen = Qt::NoPen; // NoPen for performance reasons
+                    m_backgroundShadesPen = Qt::NoPen;
+                    m_backgroundShadesBrush = QBrush(QColor(0xaf, 0xaf, 0xaf, 0x50));
+                    m_backgroundShades = BackgroundShadesVertical;
             #endif
                 }
             };
             QTCOMMERCIALCHART_END_NAMESPACE

src/themes/chartthemegrayscale_p.h +18 -7

             #include "charttheme_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class ChartThemeGrayscale: public ChartTheme
             {
             public:
                 ChartThemeGrayscale():ChartTheme(QChart::ChartThemeGrayscale)
                 {
-                    m_seriesColors << QRgb(0xff869299);
+                    // Series colors
-                    m_seriesColors << QRgb(0xffa5bdcc);
+                    m_seriesColors << QRgb(0x869299);
-                    m_seriesColors << QRgb(0xffe8fffc);
+                    m_seriesColors << QRgb(0xa5bdcc);
-                    m_seriesColors << QRgb(0xffccc2c2);
+                    m_seriesColors << QRgb(0xe8fffc);
+                    m_seriesColors << QRgb(0xccc2c2);
                     generateSeriesGradients();
+                    // Background
                     QLinearGradient backgroundGradient;
-                    backgroundGradient.setColorAt(0.0, QRgb(0xffffffff));
+                    backgroundGradient.setColorAt(0.0, QRgb(0xffffff));
-                    backgroundGradient.setColorAt(1.0, QRgb(0xffe0e3e5));
+                    backgroundGradient.setColorAt(1.0, QRgb(0xe0e3e5));
                     backgroundGradient.setCoordinateMode(QGradient::ObjectBoundingMode);
                     m_backgroundGradient = backgroundGradient;
+                    // Axes and other
+                    m_masterFont = QFont();
+                    m_axisLinePen = QPen(QRgb(0x0f0f0f));
+                    m_axisLinePen.setWidth(2);
+                    m_axisLabelBrush = QBrush(QRgb(0x3f3f3f));
+                    m_axisLabelPen = Qt::NoPen; // NoPen for performance reasons
+                    m_backgroundShadesPen = Qt::NoPen;
+                    m_gridLinePen = QPen(QRgb(0x0f0f0f));
+                    m_gridLinePen.setWidth(2);
                 }
             };
             QTCOMMERCIALCHART_END_NAMESPACE

src/themes/chartthemeicy_p.h +18 -7

             #include "charttheme_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class ChartThemeIcy: public ChartTheme
             {
             public:
                 ChartThemeIcy():ChartTheme(QChart::ChartThemeIcy)
                 {
-                    m_seriesColors << QRgb(0xff0d2673);
+                    // Series
-                    m_seriesColors << QRgb(0xff2685bf);
+                    m_seriesColors << QRgb(0x0d2673);
-                    m_seriesColors << QRgb(0xff3dadd9);
+                    m_seriesColors << QRgb(0x2685bf);
-                    m_seriesColors << QRgb(0xff62c3d9);
+                    m_seriesColors << QRgb(0x3dadd9);
+                    m_seriesColors << QRgb(0x62c3d9);
                     generateSeriesGradients();
+                    // Background
                     QLinearGradient backgroundGradient;
-                    backgroundGradient.setColorAt(0.0, QRgb(0xffebebeb));
+                    backgroundGradient.setColorAt(0.0, QRgb(0xebebeb));
-                    backgroundGradient.setColorAt(1.0, QRgb(0xfff8f9fb));
+                    backgroundGradient.setColorAt(1.0, QRgb(0xf8f9fb));
                     backgroundGradient.setCoordinateMode(QGradient::ObjectBoundingMode);
                     m_backgroundGradient = backgroundGradient;
+                    // Axes and other
+                    m_masterFont = QFont();
+                    m_axisLinePen = QPen(QRgb(0x0f0f0f));
+                    m_axisLinePen.setWidth(2);
+                    m_axisLabelBrush = QBrush(QRgb(0x3f3f3f));
+                    m_axisLabelPen = Qt::NoPen; // NoPen for performance reasons
+                    m_backgroundShadesPen = Qt::NoPen;
+                    m_gridLinePen = QPen(QRgb(0x0f0f0f));
+                    m_gridLinePen.setWidth(2);
                 }
             };
             QTCOMMERCIALCHART_END_NAMESPACE

src/themes/chartthemescientific_p.h +18 -7

             #include "charttheme_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class ChartThemeScientific: public ChartTheme
             {
             public:
                 ChartThemeScientific():ChartTheme(QChart::ChartThemeScientific)
                 {
-                    m_seriesColors << QRgb(0xFFFFAD00);
+                    // Series
-                    m_seriesColors << QRgb(0xFF596A75);
+                    m_seriesColors << QRgb(0xFFAD00);
-                    m_seriesColors << QRgb(0xFF202020);
+                    m_seriesColors << QRgb(0x596A75);
-                    m_seriesColors << QRgb(0xFF474747);
+                    m_seriesColors << QRgb(0x202020);
+                    m_seriesColors << QRgb(0x474747);
                     generateSeriesGradients();
+                    // Background
                     QLinearGradient backgroundGradient;
-                    backgroundGradient.setColorAt(0.0, QRgb(0xfffffefc));
+                    backgroundGradient.setColorAt(0.0, QRgb(0xfffefc));
-                    backgroundGradient.setColorAt(1.0, QRgb(0xfffffefc));
+                    backgroundGradient.setColorAt(1.0, QRgb(0xfffefc));
                     backgroundGradient.setCoordinateMode(QGradient::ObjectBoundingMode);
                     m_backgroundGradient = backgroundGradient;
+                    // Axes and other
+                    m_masterFont = QFont();
+                    m_axisLinePen = QPen(QRgb(0x0f0f0f));
+                    m_axisLinePen.setWidth(2);
+                    m_axisLabelBrush = QBrush(QRgb(0x3f3f3f));
+                    m_axisLabelPen = Qt::NoPen; // NoPen for performance reasons
+                    m_backgroundShadesPen = Qt::NoPen;
+                    m_gridLinePen = QPen(QRgb(0x0f0f0f));
+                    m_gridLinePen.setWidth(2);
                 }
             };
             QTCOMMERCIALCHART_END_NAMESPACE

src/themes/chartthemevanilla_p.h +19 -8

             #include "charttheme_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class ChartThemeVanilla: public ChartTheme
             {
             public:
                 ChartThemeVanilla():ChartTheme(QChart::ChartThemeVanilla)
                 {
-                    m_seriesColors << QRgb(0xffd9c574);
+                    // Series
-                    m_seriesColors << QRgb(0xffd6a896);
+                    m_seriesColors << QRgb(0xd9c574);
-                    m_seriesColors << QRgb(0xffa0a071);
+                    m_seriesColors << QRgb(0xd6a896);
-                    m_seriesColors << QRgb(0xffd2d234);
+                    m_seriesColors << QRgb(0xa0a071);
-                    m_seriesColors << QRgb(0xff88723a);
+                    m_seriesColors << QRgb(0xd2d234);
+                    m_seriesColors << QRgb(0x88723a);
                     generateSeriesGradients();
+                    // Background
                     QLinearGradient backgroundGradient;
-                    backgroundGradient.setColorAt(0.0, QRgb(0xfffbf9f1));
+                    backgroundGradient.setColorAt(0.0, QRgb(0xfbf9f1));
-                    backgroundGradient.setColorAt(1.0, QRgb(0xfff5f0dc));
+                    backgroundGradient.setColorAt(1.0, QRgb(0xf5f0dc));
                     backgroundGradient.setCoordinateMode(QGradient::ObjectBoundingMode);
                     m_backgroundGradient = backgroundGradient;
+                    // Axes and other
+                    m_masterFont = QFont();
+                    m_axisLinePen = QPen(QRgb(0x0f0f0f));
+                    m_axisLinePen.setWidth(2);
+                    m_axisLabelBrush = QBrush(QRgb(0xa0a071));
+                    m_axisLabelPen = Qt::NoPen; // NoPen for performance reasons
+                    m_backgroundShadesPen = Qt::NoPen;
+                    m_gridLinePen = QPen(QRgb(0x0f0f0f));
+                    m_gridLinePen.setWidth(2);
                 }
             };
             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