HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r661:4756f59398b8

Bar series to use theme base colors. Pie brush minor fix....

Tero Ahola -

r661:4756f59398b8

parent child

Context file:

r661:4756f59398b8

Collapse all files

demos/chartthemes/main.cpp +5 -1

             #include <QtGui/QApplication>
             #include <QMainWindow>
             #include <qchartglobal.h>
             #include <qchartview.h>
             #include <qpieseries.h>
             #include <qpieslice.h>
+            #include <qbarseries.h>
             #include <qpercentbarseries.h>
+            #include <qstackedbarseries.h>
             #include <qbarset.h>
             #include <QGridLayout>
             #include <QFormLayout>
             #include <QComboBox>
             #include <QSpinBox>
             #include <QCheckBox>
             #include <QGroupBox>
             #include <QLabel>
             #include <QTime>
             #include <qlineseries.h>
             #include <qsplineseries.h>
             #include <qscatterseries.h>
             #include <qareaseries.h>
             QTCOMMERCIALCHART_USE_NAMESPACE
             typedef QPair<QPointF, QString> Data;
             typedef QList<Data> DataList;
             typedef QList<DataList> DataTable;
             class MainWidget : public QWidget
             {
                 Q_OBJECT
             public:
                 explicit MainWidget(QWidget* parent = 0)
                     :QWidget(parent)
                 {
                     // set seed for random stuff
                     qsrand(QTime(0,0,0).secsTo(QTime::currentTime()));
                     // generate random data
                     int listCount = 3;
                     int valueMax = 100;
                     int valueCount = 11;
                     for (int i(0); i < listCount; i++) {
                         DataList dataList;
                         for (int j(0); j < valueCount; j++) {
                             QPointF value(j + (qreal) rand() / (qreal) RAND_MAX, qrand() % valueMax);
                             QString label = QString::number(i) + ":" + QString::number(j);
                             dataList << Data(value, label);
                         }
                         m_dataTable << dataList;
                     }
                     // create layout
                     QGridLayout* baseLayout = new QGridLayout();
                     // settings layout
                     m_themeComboBox = new QComboBox();
                     m_themeComboBox->addItem("Default", QChart::ChartThemeDefault);
                     m_themeComboBox->addItem("Light", QChart::ChartThemeLight);
                     m_themeComboBox->addItem("Blue Cerulean", QChart::ChartThemeBlueCerulean);
                     m_themeComboBox->addItem("Dark", QChart::ChartThemeDark);
                     m_themeComboBox->addItem("Brown Sand", QChart::ChartThemeBrownSand);
                     m_themeComboBox->addItem("Blue NCS", QChart::ChartThemeBlueNcs);
                     m_themeComboBox->addItem("Vanilla", QChart::ChartThemeVanilla);
                     m_themeComboBox->addItem("Icy", QChart::ChartThemeIcy);
                     m_themeComboBox->addItem("Grayscale", QChart::ChartThemeGrayscale);
                     m_themeComboBox->addItem("Scientific", QChart::ChartThemeScientific);
                     connect(m_themeComboBox, SIGNAL(currentIndexChanged(int)), this ,SLOT(updateTheme()));
                     QCheckBox *antialiasCheckBox = new QCheckBox("Anti aliasing");
                     connect(antialiasCheckBox, SIGNAL(toggled(bool)), this ,SLOT(updateAntialiasing(bool)));
                     QCheckBox *animatedCheckBox = new QCheckBox("Animated");
                     connect(animatedCheckBox, SIGNAL(toggled(bool)), this ,SLOT(updateAnimations(bool)));
                     QHBoxLayout *settingsLayout = new QHBoxLayout();
                     settingsLayout->addWidget(new QLabel("Theme:"));
                     settingsLayout->addWidget(m_themeComboBox);
                     settingsLayout->addWidget(antialiasCheckBox);
                     settingsLayout->addWidget(animatedCheckBox);
                     settingsLayout->addStretch();
                     baseLayout->addLayout(settingsLayout, 0, 0, 1, 3);
                     // area chart
                     QChartView *chart = new QChartView();
                     chart->setChartTitle("Area chart");
                     baseLayout->addWidget(chart, 1, 0);
                     {
                         for (int i(0); i < m_dataTable.count(); i++) {
                             QLineSeries *series1 = new QLineSeries(chart);
                             QLineSeries *series2 = new QLineSeries(chart);
                             foreach (Data data, m_dataTable[i]) {
                                 series1->add(data.first);
                                 series2->add(QPointF(data.first.x(), 0.0));
                             }
                             QAreaSeries *area = new QAreaSeries(series1, series2);
                             chart->addSeries(area);
                         }
                     }
                     m_charts << chart;
                     // bar chart
                     chart = new QChartView();
                     chart->setChartTitle("bar chart");
                     baseLayout->addWidget(chart, 1, 1);
                     {
                         QStringList categories;
                         // TODO: categories
                         for (int i(0); i < valueCount; i++)
                             categories << QString::number(i);
-                        QPercentBarSeries* series = new QPercentBarSeries(categories, chart);
+            //            QBarSeries* series = new QBarSeries(categories, chart);
+            //            QPercentBarSeries* series = new QPercentBarSeries(categories, chart);
+                        QStackedBarSeries* series = new QStackedBarSeries(categories, chart);
                         for (int i(0); i < m_dataTable.count(); i++) {
                             QBarSet *set = new QBarSet("Set" + QString::number(i));
                             foreach (Data data, m_dataTable[i])
                                 *set << data.first.y();
                             series->addBarSet(set);
                         }
                         chart->addSeries(series);
                     }
                     m_charts << chart;
                     // line chart
                     chart = new QChartView();
                     chart->setChartTitle("line chart");
                     baseLayout->addWidget(chart, 1, 2);
                     foreach (DataList list, m_dataTable) {
                         QLineSeries *series = new QLineSeries(chart);
                         foreach (Data data, list)
                             series->add(data.first);
                         chart->addSeries(series);
                     }
                     m_charts << chart;
                     // pie chart
                     chart = new QChartView();
                     chart->setChartTitle("pie chart");
                     baseLayout->addWidget(chart, 2, 0);
                     qreal pieSize = 1.0 / m_dataTable.count();
                     for (int i=0; i<m_dataTable.count(); i++) {
                         QPieSeries *series = new QPieSeries(chart);
                         foreach (Data data, m_dataTable[i])
                             series->add(data.first.y(), data.second);
                         qreal hPos = (pieSize / 2) + (i / (qreal) m_dataTable.count());
                         series->setPieSize(pieSize);
                         series->setPiePosition(hPos, 0.5);
                         chart->addSeries(series);
                     }
                     m_charts << chart;
                     // spine chart
                     chart = new QChartView();
                     chart->setChartTitle("spline chart");
                     baseLayout->addWidget(chart, 2, 1);
                     foreach (DataList list, m_dataTable) {
                         QSplineSeries *series = new QSplineSeries(chart);
                         foreach (Data data, list)
                             series->add(data.first);
                         chart->addSeries(series);
                     }
                     m_charts << chart;
                     // scatter chart
                     chart = new QChartView();
                     chart->setChartTitle("scatter chart");
                     baseLayout->addWidget(chart, 2, 2);
                     foreach (DataList list, m_dataTable) {
                         QScatterSeries *series = new QScatterSeries(chart);
                         foreach (Data data, list)
                             series->add(data.first);
                         chart->addSeries(series);
                     }
                     m_charts << chart;
                     setLayout(baseLayout);
                 }
             public Q_SLOTS:
                 void updateTheme()
                 {
                     QChart::ChartTheme theme = (QChart::ChartTheme) m_themeComboBox->itemData(m_themeComboBox->currentIndex()).toInt();
                     foreach (QChartView *chart, m_charts)
                         chart->setChartTheme(theme);
                     QPalette pal = window()->palette();
                     if (theme == QChart::ChartThemeLight) {
                         pal.setColor(QPalette::Window, QRgb(0xf0f0f0));
                         pal.setColor(QPalette::WindowText, QRgb(0x404044));
                     } else if (theme == QChart::ChartThemeDark) {
                         pal.setColor(QPalette::Window, QRgb(0x121218));
                         pal.setColor(QPalette::WindowText, QRgb(0xd6d6d6));
                     } else if (theme == QChart::ChartThemeBlueCerulean) {
                         pal.setColor(QPalette::Window, QRgb(0x40434a));
                         pal.setColor(QPalette::WindowText, QRgb(0xd6d6d6));
                     } else if (theme == QChart::ChartThemeBrownSand) {
                         pal.setColor(QPalette::Window, QRgb(0x9e8965));
                         pal.setColor(QPalette::WindowText, QRgb(0x404044));
                     } else if (theme == QChart::ChartThemeBlueNcs) {
                         pal.setColor(QPalette::Window, QRgb(0x018bba));
                         pal.setColor(QPalette::WindowText, QRgb(0x404044));
                     } else {
                         pal.setColor(QPalette::Window, QRgb(0xf0f0f0));
                         pal.setColor(QPalette::WindowText, QRgb(0x404044));
                     }
                     window()->setPalette(pal);
                 }
                 void updateAntialiasing(bool enabled)
                 {
                     foreach (QChartView *chart, m_charts)
                         chart->setRenderHint(QPainter::Antialiasing, enabled);
                 }
                 void updateAnimations(bool animated)
                 {
                     QChart::AnimationOptions options = QChart::NoAnimation;
                     if (animated)
                         options = QChart::AllAnimations;
                     foreach (QChartView *chart, m_charts)
                         chart->setAnimationOptions(options);
                 }
             private:
                 QList<QChartView*> m_charts;
                 QComboBox *m_themeComboBox;
                 DataTable m_dataTable;
             };
             int main(int argc, char *argv[])
             {
                 QApplication a(argc, argv);
                 QMainWindow window;
                 MainWidget* widget = new MainWidget();
                 window.setCentralWidget(widget);
                 window.resize(900, 600);
                 window.show();
                 return a.exec();
             }
             #include "main.moc"

src/barchart/barpresenter.cpp +1 0

             #include "barpresenter_p.h"
             #include "bar_p.h"
             #include "barvalue_p.h"
             #include "qbarset.h"
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             BarPresenter::BarPresenter(QBarSeries *series, QChart *parent) :
                 BarPresenterBase(series, parent)
             {
                 connect(series, SIGNAL(updatedBars()), this, SLOT(layoutChanged()));
             }
             void BarPresenter::layoutChanged()
             {
                 // Scale bars to new layout
                 // Layout for bars:
                 if (mSeries->barsetCount() <= 0) {
                     qDebug() << "No sets in model!";
                     return;
                 }
                 if (childItems().count() == 0) {
                     qDebug() << "WARNING: BarPresenter::layoutChanged called before graphics items are created!";
                     return;
                 }
                 // Use temporary qreals for accurancy (we might get some compiler warnings... :)
                 int categoryCount = mSeries->categoryCount();
                 int setCount = mSeries->barsetCount();
                 qreal tW = mWidth;
                 qreal tH = mHeight;
                 qreal tM = mSeries->max();
                 qreal scale = (tH/tM);
                 qreal tC = categoryCount + 1;
                 qreal categoryWidth = tW/tC;
                 mBarWidth = categoryWidth / (setCount+1);
                 int itemIndex(0);
                 for (int category=0; category < categoryCount; category++) {
                     qreal xPos = categoryWidth * category + categoryWidth /2 + mBarWidth/2;
                     qreal yPos = mHeight;
                     for (int set = 0; set < setCount; set++) {
                         qreal barHeight = mSeries->valueAt(set,category) * scale;
                         Bar* bar = mBars.at(itemIndex);
                         // TODO: width settable per bar?
                         bar->resize(mBarWidth, barHeight);
+                        bar->setPen(mSeries->barsetAt(set)->pen());
                         bar->setBrush(mSeries->barsetAt(set)->brush());
                         bar->setPos(xPos, yPos-barHeight);
                         itemIndex++;
                         xPos += mBarWidth;
                     }
                 }
                 // Position floating values
                 itemIndex = 0;
                 for (int category=0; category < mSeries->categoryCount(); category++) {
                     qreal xPos = categoryWidth * category + categoryWidth/2 + mBarWidth;
                     qreal yPos = mHeight;
                     for (int set=0; set < mSeries->barsetCount(); set++) {
                         qreal barHeight = mSeries->valueAt(set,category) * scale;
                         BarValue* value = mFloatingValues.at(itemIndex);
                         QBarSet* barSet = mSeries->barsetAt(set);
                         value->resize(100,50);  // TODO: proper layout for this.
                         value->setPos(xPos, yPos-barHeight/2);
                         value->setPen(barSet->floatingValuePen());
                         if (mSeries->valueAt(set,category) != 0) {
                             value->setValueString(QString::number(mSeries->valueAt(set,category)));
                         } else {
                             value->setValueString(QString(""));
                         }
                         itemIndex++;
                         xPos += mBarWidth;
                     }
                 }
                 update();
             }
             #include "moc_barpresenter_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/stackedbarpresenter.cpp +1 0

             #include "stackedbarpresenter_p.h"
             #include "bar_p.h"
             #include "barvalue_p.h"
             #include "qbarset.h"
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             StackedBarPresenter::StackedBarPresenter(QBarSeries *series, QChart *parent) :
                 BarPresenterBase(series,parent)
             {
             }
             StackedBarPresenter::~StackedBarPresenter()
             {
             }
             void StackedBarPresenter::layoutChanged()
             {
                 // Scale bars to new layout
                 // Layout for bars:
                 if (mSeries->barsetCount() <= 0) {
                     qDebug() << "No sets in model!";
                     // Nothing to do.
                     return;
                 }
                 if (mSeries->categoryCount() == 0) {
                     qDebug() << "No categories in model!";
                     // Nothing to do
                     return;
                 }
                 if (childItems().count() == 0) {
                     qDebug() << "WARNING: StackedBarPresenter::layoutChanged called before graphics items are created!";
                     return;
                 }
                 // Use temporary qreals for accurancy (we might get some compiler warnings... :)
                 qreal maxSum = mSeries->maxCategorySum();
                 qreal h = mHeight;
                 qreal scale = (h / maxSum);
                 qreal tW = mWidth;
                 qreal tC = mSeries->categoryCount() + 1;
                 qreal cC = mSeries->categoryCount() * 2 + 1;
                 mBarWidth = tW / cC;
                 qreal xStep = (tW/tC);
                 qreal xPos = ((tW/tC) - mBarWidth / 2);
                 int itemIndex(0);
                 for (int category = 0; category < mSeries->categoryCount(); category++) {
                     qreal yPos = h;
                     for (int set=0; set < mSeries->barsetCount(); set++) {
                         qreal barHeight = mSeries->valueAt(set, category) * scale;
                         Bar* bar = mBars.at(itemIndex);
                         bar->resize(mBarWidth, barHeight);
+                        bar->setPen(mSeries->barsetAt(set)->pen());
                         bar->setBrush(mSeries->barsetAt(set)->brush());
                         bar->setPos(xPos, yPos-barHeight);
                         itemIndex++;
                         yPos -= barHeight;
                     }
                     xPos += xStep;
                 }
                 // Position floating values
                 itemIndex = 0;
                 xPos = (tW/tC);
                 for (int category=0; category < mSeries->categoryCount(); category++) {
                     qreal yPos = h;
                     for (int set=0; set < mSeries->barsetCount(); set++) {
                         qreal barHeight = mSeries->valueAt(set,category) * scale;
                         BarValue* value = mFloatingValues.at(itemIndex);
                         QBarSet* barSet = mSeries->barsetAt(set);
                         value->resize(100,50);  // TODO: proper layout for this.
                         value->setPos(xPos, yPos-barHeight/2);
                         value->setPen(barSet->floatingValuePen());
                         if (mSeries->valueAt(set,category) != 0) {
                             value->setValueString(QString::number(mSeries->valueAt(set,category)));
                         } else {
                             value->setValueString(QString(""));
                         }
                         itemIndex++;
                         yPos -= barHeight;
                     }
                     xPos += xStep;
                 }
             }
             #include "moc_stackedbarpresenter_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/charttheme.cpp +22 -9

             #include "charttheme_p.h"
             #include "qchart.h"
             #include "qchartview.h"
             #include "qlegend.h"
             #include "qchartaxis.h"
             #include <QTime>
             //series
             #include "qbarset.h"
             #include "qbarseries.h"
             #include "qstackedbarseries.h"
             #include "qpercentbarseries.h"
             #include "qlineseries.h"
             #include "qareaseries.h"
             #include "qscatterseries.h"
             #include "qpieseries.h"
             #include "qpieslice.h"
             #include "qsplineseries.h"
             //items
             #include "axisitem_p.h"
             #include "barpresenter_p.h"
             #include "stackedbarpresenter_p.h"
             #include "percentbarpresenter_p.h"
             #include "linechartitem_p.h"
             #include "areachartitem_p.h"
             #include "scatterchartitem_p.h"
             #include "piechartitem_p.h"
             #include "splinechartitem_p.h"
             //themes
             #include "chartthemedefault_p.h"
             #include "chartthemelight_p.h"
             #include "chartthemebluecerulean_p.h"
             #include "chartthemedark_p.h"
             #include "chartthemebrownsand_p.h"
             #include "chartthemebluencs_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_masterFont(QFont()),
                 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::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,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();
-                for (int i(0); i < sets.count(); i++) {
+                qreal takeAtPos = 0.5;
-                    qreal pos = 0.5;
+                qreal step = 0.2;
-                    if (sets.count() > 1)
+                if (sets.count() > 1 ) {
-                        pos = (qreal) i / (qreal) (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);
+                }
-                    if (brush == sets.at(i)->brush() || force ) {
+                for (int i(0); i < sets.count(); i++) {
-                        QColor c = colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), pos);
+                    int colorIndex = (index + i) % m_seriesGradients.count();
-                        sets.at(i)->setBrush(QBrush(c));
+                    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 (pos < 0.3)
+                    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)
             {
                 QPen pen;
                 QBrush brush;
                 for (int i(0); i < series->slices().count(); i++) {
                     if (pen == series->slices().at(i)->slicePen() || force) {
                         QColor penColor = colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), 0.0);
                         series->slices().at(i)->setSlicePen(penColor);
                     }
                     // Get color for a slice from a gradient linearly, beginning from the start of the gradient
-                    qreal pos = (qreal) i / (qreal) series->count();
+                    qreal pos = (qreal) (i + 1) / (qreal) series->count();
                     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, 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);
                     }
                 }
             }
             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

test/chartwidgettest/dataseriedialog.cpp +3 0

             #include "dataseriedialog.h"
             #include <QDialogButtonBox>
             #include <QGridLayout>
             #include <QCheckBox>
             #include <QPushButton>
             #include <QGroupBox>
             #include <QRadioButton>
             #include <QLabel>
             #include <QDebug>
             DataSerieDialog::DataSerieDialog(QWidget *parent) :
                 QDialog(parent)
             {
                 QDialogButtonBox *addSeriesBox = new QDialogButtonBox(Qt::Horizontal);
                 QPushButton *b = addSeriesBox->addButton(QDialogButtonBox::Ok);
                 connect(b, SIGNAL(clicked()), this, SLOT(accept()));
                 b = addSeriesBox->addButton(QDialogButtonBox::Cancel);
                 connect(b, SIGNAL(clicked()), this, SLOT(reject()));
                 QGridLayout *grid = new QGridLayout();
                 m_seriesTypeSelector = seriesTypeSelector();
                 m_columnCountSelector = columnCountSelector();
                 m_rowCountSelector = rowCountSelector();
                 m_dataCharacteristicsSelector = dataCharacteristicsSelector();
                 grid->addWidget(m_seriesTypeSelector, 0, 0);
                 grid->addWidget(m_columnCountSelector, 0, 1);
                 grid->addWidget(m_rowCountSelector, 1, 1);
                 grid->addWidget(m_dataCharacteristicsSelector, 1, 0);
                 m_labelsSelector = new QCheckBox("Labels defined");
                 m_labelsSelector->setChecked(true);
                 grid->addWidget(m_labelsSelector, 2, 0);
                 grid->addWidget(addSeriesBox, 3, 1);
                 setLayout(grid);
             }
             QGroupBox *DataSerieDialog::seriesTypeSelector()
             {
                 QVBoxLayout *layout = new QVBoxLayout();
                 QRadioButton *line = new QRadioButton("Line");
                 line->setChecked(true);
                 layout->addWidget(line);
                 layout->addWidget(new QRadioButton("Area"));
                 layout->addWidget(new QRadioButton("Pie"));
                 layout->addWidget(new QRadioButton("Bar"));
                 layout->addWidget(new QRadioButton("Stacked bar"));
                 layout->addWidget(new QRadioButton("Percent bar"));
                 layout->addWidget(new QRadioButton("Scatter"));
                 layout->addWidget(new QRadioButton("Spline"));
                 QGroupBox *groupBox = new QGroupBox("Series type");
                 groupBox->setLayout(layout);
                 selectRadio(groupBox, 0);
                 return groupBox;
             }
             QGroupBox *DataSerieDialog::columnCountSelector()
             {
                 QVBoxLayout *layout = new QVBoxLayout();
                 QRadioButton *radio = new QRadioButton("1");
                 radio->setChecked(true);
                 layout->addWidget(radio);
                 layout->addWidget(new QRadioButton("2"));
                 layout->addWidget(new QRadioButton("3"));
+                layout->addWidget(new QRadioButton("4"));
                 layout->addWidget(new QRadioButton("5"));
+                layout->addWidget(new QRadioButton("8"));
                 layout->addWidget(new QRadioButton("10"));
                 layout->addWidget(new QRadioButton("100"));
                 QGroupBox *groupBox = new QGroupBox("Column count");
                 groupBox->setLayout(layout);
                 selectRadio(groupBox, 0);
                 return groupBox;
             }
             QGroupBox *DataSerieDialog::rowCountSelector()
             {
                 QVBoxLayout *layout = new QVBoxLayout();
                 layout->addWidget(new QRadioButton("1"));
                 QRadioButton *radio = new QRadioButton("10");
                 radio->setChecked(true);
                 layout->addWidget(radio);
                 layout->addWidget(new QRadioButton("50"));
                 layout->addWidget(new QRadioButton("100"));
                 layout->addWidget(new QRadioButton("10000"));
+                layout->addWidget(new QRadioButton("100000"));
                 layout->addWidget(new QRadioButton("1000000"));
                 QGroupBox *groupBox = new QGroupBox("Row count");
                 groupBox->setLayout(layout);
                 selectRadio(groupBox, 0);
                 return groupBox;
             }
             QGroupBox *DataSerieDialog::dataCharacteristicsSelector()
             {
                 QVBoxLayout *layout = new QVBoxLayout();
                 layout->addWidget(new QRadioButton("Linear"));
                 layout->addWidget(new QRadioButton("Constant"));
                 layout->addWidget(new QRadioButton("Random"));
                 layout->addWidget(new QRadioButton("Sin"));
                 layout->addWidget(new QRadioButton("Sin + random"));
                 QGroupBox *groupBox = new QGroupBox("Data Characteristics");
                 groupBox->setLayout(layout);
                 selectRadio(groupBox, 0);
                 return groupBox;
             }
             void DataSerieDialog::accept()
             {
                 accepted(radioSelection(m_seriesTypeSelector),
                          radioSelection(m_columnCountSelector).toInt(),
                          radioSelection(m_rowCountSelector).toInt(),
                          radioSelection(m_dataCharacteristicsSelector),
                          m_labelsSelector->isChecked());
                 QDialog::accept();
             }
             void DataSerieDialog::selectRadio(QGroupBox *groupBox, int defaultSelection)
             {
                 QVBoxLayout *layout = qobject_cast<QVBoxLayout *>(groupBox->layout());
                 Q_ASSERT(layout);
                 Q_ASSERT(layout->count());
                 QLayoutItem *item = 0;
                 if (defaultSelection == -1) {
                     item = layout->itemAt(0);
                 } else if (layout->count() > defaultSelection) {
                     item = layout->itemAt(defaultSelection);
                 }
                 Q_ASSERT(item);
                 QRadioButton *radio = qobject_cast<QRadioButton *>(item->widget());
                 Q_ASSERT(radio);
                 radio->setChecked(true);
             }
             QString DataSerieDialog::radioSelection(QGroupBox *groupBox)
             {
                 QString selection;
                 QVBoxLayout *layout = qobject_cast<QVBoxLayout *>(groupBox->layout());
                 Q_ASSERT(layout);
                 for (int i(0); i < layout->count(); i++) {
                     QLayoutItem *item = layout->itemAt(i);
                     Q_ASSERT(item);
                     QRadioButton *radio = qobject_cast<QRadioButton *>(item->widget());
                     Q_ASSERT(radio);
                     if (radio->isChecked()) {
                         selection = radio->text();
                         break;
                     }
                 }
                 qDebug() << "radioSelection: " << selection;
                 return selection;
             }

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