HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r717:a566cfd317a8

Defined point sizes for fonts

Tero Ahola -

r717:a566cfd317a8

parent child

Context file:

r717:a566cfd317a8

Collapse all files

src/charttheme.cpp +4 -3

             #include "charttheme_p.h"
             #include "qchart.h"
             #include "qchartview.h"
             #include "qlegend.h"
             #include "qchartaxis.h"
             #include <QTime>
             //series
             #include "qbarset.h"
             #include "qbarseries.h"
             #include "qstackedbarseries.h"
             #include "qpercentbarseries.h"
             #include "qlineseries.h"
             #include "qareaseries.h"
             #include "qscatterseries.h"
             #include "qpieseries.h"
             #include "qpieslice.h"
             #include "qsplineseries.h"
             //items
             #include "axisitem_p.h"
             #include "barchartitem_p.h"
             #include "stackedbarchartitem_p.h"
             #include "percentbarchartitem_p.h"
             #include "linechartitem_p.h"
             #include "areachartitem_p.h"
             #include "scatterchartitem_p.h"
             #include "piechartitem_p.h"
             #include "splinechartitem_p.h"
             //themes
             #include "chartthemedefault_p.h"
             #include "chartthemelight_p.h"
             #include "chartthemebluecerulean_p.h"
             #include "chartthemedark_p.h"
             #include "chartthemebrownsand_p.h"
             #include "chartthemebluencs_p.h"
             #include "chartthemeicy_p.h"
             #include "chartthemescientific_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartTheme::ChartTheme(QChart::ChartTheme id) :
-                m_masterFont(QFont()),
+                m_masterFont(QFont("arial", 12)),
+                m_labelFont(QFont("arial", 10)),
                 m_titleBrush(QColor(QRgb(0x000000))),
                 m_axisLinePen(QPen(QRgb(0x000000))),
                 m_axisLabelBrush(QColor(QRgb(0x000000))),
                 m_backgroundShadesPen(Qt::NoPen),
                 m_backgroundShadesBrush(Qt::NoBrush),
                 m_backgroundShades(BackgroundShadesNone),
                 m_gridLinePen(QPen(QRgb(0x000000)))
             {
                 m_id = id;
                 qsrand(QTime(0,0,0).secsTo(QTime::currentTime()));
             }
             ChartTheme* ChartTheme::createTheme(QChart::ChartTheme theme)
             {
                 switch(theme) {
                     case QChart::ChartThemeLight:
                         return new ChartThemeLight();
                     case QChart::ChartThemeBlueCerulean:
                         return new ChartThemeBlueCerulean();
                     case QChart::ChartThemeDark:
                         return new ChartThemeDark();
                     case QChart::ChartThemeBrownSand:
                         return new ChartThemeBrownSand();
                     case QChart::ChartThemeBlueNcs:
                         return new ChartThemeBlueNcs();
                     case QChart::ChartThemeIcy:
                         return new ChartThemeIcy();
                     case QChart::ChartThemeScientific:
                         return new ChartThemeScientific();
                     default:
                         return new ChartThemeDefault();
                 }
             }
             void ChartTheme::decorate(QChart* chart,bool force)
             {
                 QPen pen;
                 QBrush brush;
                 if(brush == chart->backgroundBrush() || force)
                 {
                     if (m_backgroundShades == BackgroundShadesNone) {
                         chart->setBackgroundBrush(m_chartBackgroundGradient);
                     }
                     else {
                         chart->setBackgroundBrush(Qt::NoBrush);
                     }
                 }
                 chart->setTitleFont(m_masterFont);
                 chart->setTitleBrush(m_titleBrush);
             }
             void ChartTheme::decorate(QLegend* legend,bool force)
             {
                 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,bool force)
             {
                 QPen pen;
                 QBrush brush;
                 if (pen == series->pen() || force){
                     pen.setColor(colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), 0.0));
                     pen.setWidthF(2);
                     series->setPen(pen);
                 }
                 if (brush == series->brush() || force) {
                    QBrush brush(m_seriesColors.at(index % m_seriesColors.size()));
                    series->setBrush(brush);
                 }
             }
             void ChartTheme::decorate(QLineSeries* series,int index,bool force)
             {
                 QPen 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, bool force)
             {
                 QBrush brush;
                 QPen pen;
                 QList<QBarSet*> sets = series->barSets();
                 qreal takeAtPos = 0.5;
                 qreal step = 0.2;
                 if (sets.count() > 1 ) {
                     step = 1.0 / (qreal) sets.count();
                     if (sets.count() % m_seriesGradients.count())
                         step *= m_seriesGradients.count();
                     else
                         step *= (m_seriesGradients.count() - 1);
                 }
                 for (int i(0); i < sets.count(); i++) {
                     int colorIndex = (index + i) % m_seriesGradients.count();
                     if (i > 0 && i % m_seriesGradients.count() == 0) {
                         // There is no dedicated base color for each sets, generate more colors
                         takeAtPos += step;
                         if (takeAtPos == 1.0)
                             takeAtPos += step;
                         takeAtPos -= (int) takeAtPos;
                     }
                     qDebug() << "pos:" << takeAtPos;
                     if (brush == sets.at(i)->brush() || force )
                         sets.at(i)->setBrush(colorAt(m_seriesGradients.at(colorIndex), takeAtPos));
                     // Pick label color from the opposite end of the gradient.
                     // 0.3 as a boundary seems to work well.
                     if (takeAtPos < 0.3)
                         sets.at(i)->setFloatingValuePen(colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), 1));
                     else
                         sets.at(i)->setFloatingValuePen(colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), 0));
                     if (pen == sets.at(i)->pen() || force) {
                         QColor c = colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), 0.0);
                         sets.at(i)->setPen(c);
                     }
                 }
             }
             void ChartTheme::decorate(QScatterSeries* series, int index,bool force)
             {
                 QPen pen;
                 QBrush brush;
                 if (pen == series->pen() || force) {
                     pen.setColor(colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), 0.0));
                     pen.setWidthF(2);
                     series->setPen(pen);
                 }
                 if (brush == series->brush() || force) {
                     QBrush brush(m_seriesColors.at(index % m_seriesColors.size()));
                     series->setBrush(brush);
                 }
             }
             void ChartTheme::decorate(QPieSeries* series, int index, bool force)
             {
                 for (int i(0); i < series->slices().count(); i++) {
                     QColor penColor = colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), 0.0);
                     // Get color for a slice from a gradient linearly, beginning from the start of the gradient
                     qreal pos = (qreal) (i + 1) / (qreal) series->count();
                     QColor brushColor = colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), pos);
                     QPieSlice::DataPtr s = series->slices().at(i)->data_ptr();
                     PieSliceData data = s->m_data;
                     if (data.m_slicePen.isThemed() || force) {
                         data.m_slicePen = penColor;
                         data.m_slicePen.setThemed(true);
                     }
                     if (data.m_sliceBrush.isThemed() || force) {
                         data.m_sliceBrush = brushColor;
                         data.m_sliceBrush.setThemed(true);
                     }
                     if (data.m_labelPen.isThemed() || force) {
                         data.m_labelPen = QPen(m_titleBrush.color());
                         data.m_labelPen.setThemed(true);
                     }
                     if (data.m_labelFont.isThemed() || force) {
-                        data.m_labelFont = m_masterFont;
+                        data.m_labelFont = m_labelFont;
                         data.m_labelFont.setThemed(true);
                     }
                     if (s->m_data != data) {
                         s->m_data = data;
                         emit s->changed();
                     }
                 }
             }
             void ChartTheme::decorate(QSplineSeries* series, int index, bool force)
             {
                 QPen 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, bool force)
             {
                 QPen pen;
                 QBrush brush;
                 QFont font;
                 if (axis->isAxisVisible()) {
                     if(brush == axis->labelsBrush() || force){
                         axis->setLabelsBrush(m_axisLabelBrush);
                     }
                     if(pen == axis->labelsPen() || force){
                         axis->setLabelsPen(Qt::NoPen); // NoPen for performance reasons
                     }
                    if (axis->shadesVisible() || force) {
                      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->setLabelsFont(m_labelFont);
                     }
                 }
             }
             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.0, 1.0);
                     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 +1 0

             #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 BarChartItem;
             class QBarSeries;
             class StackedBarChartItem;
             class QStackedBarSeries;
             class QPercentBarSeries;
             class PercentBarChartItem;
             class QScatterSeries;
             class ScatterChartItem;
             class PieChartItem;
             class QPieSeries;
             class SplineChartItem;
             class QSplineSeries;
             class AreaChartItem;
             class QAreaSeries;
             class ChartTheme
             {
             public:
                 enum BackgroundShadesMode {
                     BackgroundShadesNone = 0,
                     BackgroundShadesVertical,
                     BackgroundShadesHorizontal,
                     BackgroundShadesBoth
                 };
             protected:
                 explicit ChartTheme(QChart::ChartTheme id =  QChart::ChartThemeDefault);
             public:
                 static ChartTheme* createTheme(QChart::ChartTheme theme);
                 QChart::ChartTheme id() const {return m_id;}
                 void decorate(QChart* chart,bool force = true);
                 void decorate(QLegend* legend,bool force = true);
                 void decorate(QBarSeries* series, int index,bool force = true);
                 void decorate(QLineSeries* series, int index,bool force = true);
                 void decorate(QAreaSeries* series, int index,bool force = true);
                 void decorate(QScatterSeries* series, int index,bool force = true);
                 void decorate(QPieSeries* series, int index,bool force = true);
                 void decorate(QSplineSeries* series, int index,bool force = true);
                 void decorate(QChartAxis* axis, bool axisX,bool force = true);
             public: // utils
                 void generateSeriesGradients();
                 static QColor colorAt(const QColor &start, const QColor &end, qreal pos);
                 static QColor colorAt(const QGradient &gradient, qreal pos);
             protected:
                 QChart::ChartTheme m_id;
                 QList<QColor> m_seriesColors;
                 QList<QGradient> m_seriesGradients;
                 QLinearGradient m_chartBackgroundGradient;
                 QFont m_masterFont;
+                QFont m_labelFont;
                 QBrush m_titleBrush;
                 QPen m_axisLinePen;
                 QBrush m_axisLabelBrush;
                 QPen m_backgroundShadesPen;
                 QBrush m_backgroundShadesBrush;
                 BackgroundShadesMode m_backgroundShades;
                 QPen m_gridLinePen;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // CHARTTHEME_H

src/themes/chartthemebluecerulean_p.h 0 -1

             #include "charttheme_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class ChartThemeBlueCerulean: public ChartTheme
             {
             public:
                 ChartThemeBlueCerulean() : ChartTheme(QChart::ChartThemeBlueCerulean)
                 {
                     // Series colors
                     m_seriesColors << QRgb(0xc7e85b);
                     m_seriesColors << QRgb(0x1cb54f);
                     m_seriesColors << QRgb(0x5cbf9b);
                     m_seriesColors << QRgb(0x009fbf);
                     m_seriesColors << QRgb(0xee7392);
                     generateSeriesGradients();
                     // Background
                     QLinearGradient backgroundGradient(0.5, 0.0, 0.5, 1.0);
                     backgroundGradient.setColorAt(0.0, QRgb(0x056189));
                     backgroundGradient.setColorAt(1.0, QRgb(0x101a31));
                     backgroundGradient.setCoordinateMode(QGradient::ObjectBoundingMode);
                     m_chartBackgroundGradient = backgroundGradient;
                     // Axes and other
-                    m_masterFont = QFont("arial");
                     m_titleBrush = QBrush(QRgb(0xffffff));
                     m_axisLinePen = QPen(QRgb(0xd6d6d6));
                     m_axisLinePen.setWidth(2);
                     m_axisLabelBrush = QBrush(QRgb(0xffffff));
                     m_gridLinePen = QPen(QRgb(0x84a2b0));
                     m_gridLinePen.setWidth(1);
                     m_backgroundShades = BackgroundShadesNone;
                 }
             };
             QTCOMMERCIALCHART_END_NAMESPACE

src/themes/chartthemebluencs_p.h 0 -1

             #include "charttheme_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class ChartThemeBlueNcs: public ChartTheme
             {
             public:
                 ChartThemeBlueNcs() : ChartTheme(QChart::ChartThemeBlueNcs)
                 {
                     // Series colors
                     m_seriesColors << QRgb(0x1db0da);
                     m_seriesColors << QRgb(0x1341a6);
                     m_seriesColors << QRgb(0x88d41e);
                     m_seriesColors << QRgb(0xff8e1a);
                     m_seriesColors << QRgb(0x398ca3);
                     generateSeriesGradients();
                     // Background
                     QLinearGradient backgroundGradient;
                     backgroundGradient.setColorAt(0.0, QRgb(0xffffff));
                     backgroundGradient.setColorAt(1.0, QRgb(0xffffff));
                     backgroundGradient.setCoordinateMode(QGradient::ObjectBoundingMode);
                     m_chartBackgroundGradient = backgroundGradient;
                     // Axes and other
-                    m_masterFont = QFont("arial");
                     m_titleBrush = QBrush(QRgb(0x404044));
                     m_axisLinePen = QPen(QRgb(0xd6d6d6));
                     m_axisLinePen.setWidth(2);
                     m_axisLabelBrush = QBrush(QRgb(0x404044));
                     m_gridLinePen = QPen(QRgb(0xe2e2e2));
                     m_gridLinePen.setWidth(1);
                     m_backgroundShades = BackgroundShadesNone;
                 }
             };
             QTCOMMERCIALCHART_END_NAMESPACE

src/themes/chartthemebrownsand_p.h 0 -1

             #include "charttheme_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class ChartThemeBrownSand: public ChartTheme
             {
             public:
                 ChartThemeBrownSand() : ChartTheme(QChart::ChartThemeBrownSand)
                 {
                     // Series colors
                     m_seriesColors << QRgb(0xb39b72);
                     m_seriesColors << QRgb(0xb3b376);
                     m_seriesColors << QRgb(0xc35660);
                     m_seriesColors << QRgb(0x536780);
                     m_seriesColors << QRgb(0x494345);
                     generateSeriesGradients();
                     // Background
                     QLinearGradient backgroundGradient;
                     backgroundGradient.setColorAt(0.0, QRgb(0xf3ece0));
                     backgroundGradient.setColorAt(1.0, QRgb(0xf3ece0));
                     backgroundGradient.setCoordinateMode(QGradient::ObjectBoundingMode);
                     m_chartBackgroundGradient = backgroundGradient;
                     // Axes and other
-                    m_masterFont = QFont("arial");
                     m_titleBrush = QBrush(QRgb(0x404044));
                     m_axisLinePen = QPen(QRgb(0xb5b0a7));
                     m_axisLinePen.setWidth(2);
                     m_axisLabelBrush = QBrush(QRgb(0x404044));
                     m_gridLinePen = QPen(QRgb(0xd4cec3));
                     m_gridLinePen.setWidth(1);
                     m_backgroundShades = BackgroundShadesNone;
                 }
             };
             QTCOMMERCIALCHART_END_NAMESPACE

src/themes/chartthemedark_p.h 0 -1

             #include "charttheme_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class ChartThemeDark : public ChartTheme
             {
             public:
                 ChartThemeDark() : ChartTheme(QChart::ChartThemeDark)
                 {
                     // Series colors
                     m_seriesColors << QRgb(0x38ad6b);
                     m_seriesColors << QRgb(0x3c84a7);
                     m_seriesColors << QRgb(0xeb8817);
                     m_seriesColors << QRgb(0x7b7f8c);
                     m_seriesColors << QRgb(0xbf593e);
                     generateSeriesGradients();
                     // Background
                     QLinearGradient backgroundGradient(0.5, 0.0, 0.5, 1.0);
                     backgroundGradient.setColorAt(0.0, QRgb(0x2e303a));
                     backgroundGradient.setColorAt(1.0, QRgb(0x121218));
                     backgroundGradient.setCoordinateMode(QGradient::ObjectBoundingMode);
                     m_chartBackgroundGradient = backgroundGradient;
                     // Axes and other
-                    m_masterFont = QFont("arial");
                     m_titleBrush = QBrush(QRgb(0xffffff));
                     m_axisLinePen = QPen(QRgb(0x86878c));
                     m_axisLinePen.setWidth(2);
                     m_axisLabelBrush = QBrush(QRgb(0xffffff));
                     m_gridLinePen = QPen(QRgb(0x86878c));
                     m_gridLinePen.setWidth(1);
                     m_backgroundShades = BackgroundShadesNone;
                 }
             };
             QTCOMMERCIALCHART_END_NAMESPACE

src/themes/chartthemedefault_p.h 0 -4

             #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
                     // TODO: use theme specific window frame color as a series base color (it would give more
                     // variation to the base colors in addition to the blue and black used now)
                     // TODO: COLOR_WINDOWTEXT for text color?
                     // TODO: COLOR_INFOTEXT for tooltip text color?
                     // TODO: COLOR_INFOBK for tooltip background color?
                     // First series base color from COLOR_HIGHLIGHT
                     DWORD colorHighlight;
                     colorHighlight = GetSysColor(COLOR_HIGHLIGHT);
                     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)));
                     // 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("arial");
                     m_axisLinePen = QPen(0xd6d6d6);
                     m_axisLinePen.setWidth(1);
                     m_axisLabelBrush = QBrush(QRgb(0x404044));
                     m_gridLinePen = QPen(QRgb(0xe2e2e2));
                     m_gridLinePen.setWidth(1);
                     m_backgroundShades = BackgroundShadesNone;
             #elif defined(Q_OS_LINUX)
                     // TODO: replace this dummy theme with linux specific theme
                     m_seriesColors << QRgb(0x60a6e6);
                     m_seriesColors << QRgb(0x92ca66);
                     m_seriesColors << QRgb(0xeba85f);
                     m_seriesColors << QRgb(0xfc5751);
                     generateSeriesGradients();
                     // Background
                     QLinearGradient backgroundGradient;
                     backgroundGradient.setColorAt(0.0, QRgb(0xffffff));
                     backgroundGradient.setColorAt(1.0, QRgb(0xffffff));
                     backgroundGradient.setCoordinateMode(QGradient::ObjectBoundingMode);
                     m_chartBackgroundGradient = backgroundGradient;
                     // Axes and other
-                    m_masterFont = QFont("arial");
                     m_axisLinePen = QPen(0xd6d6d6);
                     m_axisLinePen.setWidth(1);
                     m_axisLabelBrush = QBrush(QRgb(0x404044));
                     m_gridLinePen = QPen(QRgb(0xe2e2e2));
                     m_gridLinePen.setWidth(1);
                     m_backgroundShades = BackgroundShadesNone;
             #elif defined(Q_OS_MAC)
                     // TODO: replace this dummy theme with OSX specific theme
                     m_seriesColors << QRgb(0x60a6e6);
                     m_seriesColors << QRgb(0x92ca66);
                     m_seriesColors << QRgb(0xeba85f);
                     m_seriesColors << QRgb(0xfc5751);
                     generateSeriesGradients();
                     // Background
                     QLinearGradient backgroundGradient;
                     backgroundGradient.setColorAt(0.0, QRgb(0xffffff));
                     backgroundGradient.setColorAt(1.0, QRgb(0xffffff));
                     backgroundGradient.setCoordinateMode(QGradient::ObjectBoundingMode);
                     m_chartBackgroundGradient = backgroundGradient;
                     // Axes and other
-                    m_masterFont = QFont("arial");
                     m_axisLinePen = QPen(0xd6d6d6);
                     m_axisLinePen.setWidth(1);
                     m_axisLabelBrush = QBrush(QRgb(0x404044));
                     m_gridLinePen = QPen(QRgb(0xe2e2e2));
                     m_gridLinePen.setWidth(1);
                     m_backgroundShades = BackgroundShadesNone;
             #else
                     // TODO: replace this dummy theme with generic (not OS specific) theme
                     m_seriesColors << QRgb(0x60a6e6);
                     m_seriesColors << QRgb(0x92ca66);
                     m_seriesColors << QRgb(0xeba85f);
                     m_seriesColors << QRgb(0xfc5751);
                     generateSeriesGradients();
                     // Background
                     QLinearGradient backgroundGradient;
                     backgroundGradient.setColorAt(0.0, QRgb(0xffffff));
                     backgroundGradient.setColorAt(1.0, QRgb(0xffffff));
                     backgroundGradient.setCoordinateMode(QGradient::ObjectBoundingMode);
                     m_chartBackgroundGradient = backgroundGradient;
                     // Axes and other
-                    m_masterFont = QFont("arial");
                     m_axisLinePen = QPen(0xd6d6d6);
                     m_axisLinePen.setWidth(1);
                     m_axisLabelBrush = QBrush(QRgb(0x404044));
                     m_gridLinePen = QPen(QRgb(0xe2e2e2));
                     m_gridLinePen.setWidth(1);
                     m_backgroundShades = BackgroundShadesNone;
             #endif
                 }
             };
             QTCOMMERCIALCHART_END_NAMESPACE

src/themes/chartthemelight_p.h 0 -1

             #include "charttheme_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class ChartThemeLight: public ChartTheme
             {
             public:
                 ChartThemeLight() : ChartTheme(QChart::ChartThemeLight)
                 {
                     // Series colors
                     m_seriesColors << QRgb(0x209fdf);
                     m_seriesColors << QRgb(0x99ca53);
                     m_seriesColors << QRgb(0xf6a625);
                     m_seriesColors << QRgb(0x6d5fd5);
                     m_seriesColors << QRgb(0xbf593e);
                     generateSeriesGradients();
                     // Background
                     QLinearGradient backgroundGradient;
                     backgroundGradient.setColorAt(0.0, QRgb(0xffffff));
                     backgroundGradient.setColorAt(1.0, QRgb(0xffffff));
                     backgroundGradient.setCoordinateMode(QGradient::ObjectBoundingMode);
                     m_chartBackgroundGradient = backgroundGradient;
                     // Axes and other
-                    m_masterFont = QFont("arial");
                     m_axisLinePen = QPen(0xd6d6d6);
                     m_axisLinePen.setWidth(1);
                     m_axisLabelBrush = QBrush(QRgb(0x404044));
                     m_gridLinePen = QPen(QRgb(0xe2e2e2));
                     m_gridLinePen.setWidth(1);
                     m_backgroundShades = BackgroundShadesNone;
                 }
             };
             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