HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r581:02cfabdc2003

Added draft of dark blue theme

Tero Ahola -

r581:02cfabdc2003

parent child

Context file:

r581:02cfabdc2003

Collapse all files

src/themes/chartthemebluecerulean_p.h created 644 +36 0

@@ -0,0 +1,36
	1	#include "charttheme_p.h"
	2
	3	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	4
	5	class ChartThemeBlueCerulean: public ChartTheme
	6	{
	7	public:
	8	ChartThemeBlueCerulean() : ChartTheme(QChart::ChartThemeBlueCerulean)
	9	{
	10	// Series colors
	11	m_seriesColors << QRgb(0xc7e85b);
	12	m_seriesColors << QRgb(0x5dbe9b);
	13	m_seriesColors << QRgb(0x4fbef3);
	14	generateSeriesGradients();
	15
	16	// Background
	17	QLinearGradient backgroundGradient;
	18	backgroundGradient.setColorAt(0.0, QRgb(0x056188));
	19	backgroundGradient.setColorAt(1.0, QRgb(0x101a33));
	20	backgroundGradient.setCoordinateMode(QGradient::ObjectBoundingMode);
	21	m_backgroundGradient = backgroundGradient;
	22
	23	// Axes and other
	24	m_masterFont = QFont();
	25	m_axisLinePen = QPen(QRgb(0x0f0f0f));
	26	m_axisLinePen.setWidth(2);
	27	m_axisLabelBrush = QBrush(QRgb(0x3f3f3f));
	28	m_axisLabelPen = Qt::NoPen; // NoPen for performance reasons
	29	m_backgroundShadesPen = Qt::NoPen;
	30	m_backgroundShades = BackgroundShadesNone;
	31	m_gridLinePen = QPen(QRgb(0x0f0f0f));
	32	m_gridLinePen.setWidth(2);
	33	}
	34	};
	35
	36	QTCOMMERCIALCHART_END_NAMESPACE

demos/chartthemes/main.cpp +1 0

             #include <QtGui/QApplication>
             #include <QMainWindow>
             #include <qchartglobal.h>
             #include <qchartview.h>
             #include <qpieseries.h>
             #include <qpieslice.h>
             #include <qpercentbarseries.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 = 21;
                     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();
                     // theme combo
                     m_themeComboBox = new QComboBox();
                     m_themeComboBox->addItem("Default", QChart::ChartThemeDefault);
                     m_themeComboBox->addItem("Vanilla", QChart::ChartThemeVanilla);
                     m_themeComboBox->addItem("Icy", QChart::ChartThemeIcy);
                     m_themeComboBox->addItem("Grayscale", QChart::ChartThemeGrayscale);
                     m_themeComboBox->addItem("Scientific", QChart::ChartThemeScientific);
+                    m_themeComboBox->addItem("Blue Cerulean", QChart::ChartThemeBlueCerulean);
                     connect(m_themeComboBox, SIGNAL(currentIndexChanged(int)), this ,SLOT(updateTheme()));
                     baseLayout->addWidget(new QLabel("Theme:"), 0, 0);
                     baseLayout->addWidget(m_themeComboBox, 0, 1);
                     // area chart
                     QChartView *chart = new QChartView();
                     chart->setChartTitle("Area chart");
                     chart->setRenderHint(QPainter::Antialiasing);
                     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");
                     chart->setRenderHint(QPainter::Antialiasing);
                     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);
                         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");
                     chart->setRenderHint(QPainter::Antialiasing);
                     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");
                     chart->setRenderHint(QPainter::Antialiasing);
                     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");
                     chart->setRenderHint(QPainter::Antialiasing);
                     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");
                     chart->setRenderHint(QPainter::Antialiasing);
                     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);
                 }
             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/charttheme.cpp +7 -1

             #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 "piechartitem_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"
+            #include "chartthemebluecerulean_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();
+                    case QChart::ChartThemeBlueCerulean:
+                        return new ChartThemeBlueCerulean();
                     default:
                         return new ChartThemeDefault();
                 }
             }
             void ChartTheme::decorate(QChart* chart)
             {
-                chart->setChartBackgroundBrush(m_backgroundGradient);
+                if (m_backgroundShades == BackgroundShadesNone)
+                    chart->setChartBackgroundBrush(m_backgroundGradient);
+                else
+                    chart->setChartBackgroundBrush(Qt::NoBrush);
                 chart->setChartTitleFont(m_masterFont);
             }
             void ChartTheme::decorate(QLegend* legend)
             {
                 legend->setBackgroundBrush(m_backgroundGradient);
             }
             void ChartTheme::decorate(QAreaSeries* series, int index)
             {
                 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(QLineSeries* series,int index)
             {
                 QPen pen;
                 if(pen == series->pen()){
                     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(QScatterSeries* series, int index)
             {
                 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(PieChartItem* 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(QSplineSeries* series, int index)
             {
                 QPen pen;
                 if(pen == series->pen()){
                     pen.setColor(m_seriesColors.at(index%m_seriesColors.size()));
                     pen.setWidthF(2);
                     series->setPen(pen);
                 }
             }
             void ChartTheme::decorate(QChartAxis* axis,bool axisX)
             {
                 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 && axisX)
                             || (m_backgroundShades == BackgroundShadesHorizontal && !axisX)) {
                         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/qchart.cpp +3 -1

             #include "qchart.h"
             #include "qchartaxis.h"
             #include "qlegend.h"
             #include "chartpresenter_p.h"
             #include "chartdataset_p.h"
             #include <QGraphicsScene>
             #include <QGraphicsSceneResizeEvent>
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \enum QChart::ChartTheme
                 This enum describes the theme used by the chart.
-                \value ChartThemeDefault
+                \value ChartThemeDefault Follows the GUI style of the Operating System
                 \value ChartThemeVanilla
                 \value ChartThemeIcy
                 \value ChartThemeGrayscale
                 \value ChartThemeScientific
+                \value ChartThemeBlueCerulean
+                \value ChartThemeCount Not really a theme; the total count of themes.
             */
             /*!
                 \enum QChart::AnimationOption
                 For enabling/disabling animations. Defaults to NoAnimation.
                 \value NoAnimation
                 \value GridAxisAnimations
                 \value SeriesAnimations
                 \value AllAnimations
             */
             /*!
                 \class QChart
                 \brief QtCommercial chart API.
                 QChart is a QGraphicsWidget that you can show in a QGraphicsScene. It manages the graphical
                 representation of different types of QChartSeries and other chart related objects like
                 QChartAxis and QChartLegend. If you simply want to show a chart in a layout, you can use the
                 convenience class QChartView instead of QChart.
                 \sa QChartView
             */
             /*!
                 Constructs a chart object which is a child of a\a parent. Parameter \a wFlags is passed to the QGraphicsWidget constructor.
             */
             QChart::QChart(QGraphicsItem *parent, Qt::WindowFlags wFlags) : QGraphicsWidget(parent,wFlags),
                 m_backgroundItem(0),
                 m_titleItem(0),
                 m_legend(new QLegend(this)),
                 m_dataset(new ChartDataSet(this)),
                 m_presenter(new ChartPresenter(this,m_dataset))
             {
                 connect(m_dataset,SIGNAL(seriesAdded(QSeries*,Domain*)),m_legend,SLOT(handleSeriesAdded(QSeries*,Domain*)));
                 connect(m_dataset,SIGNAL(seriesRemoved(QSeries*)),m_legend,SLOT(handleSeriesRemoved(QSeries*)));
             }
             /*!
                 Destroys the object and it's children, like QChartSeries and QChartAxis object added to it.
             */
             QChart::~QChart()
             {
                 disconnect(m_dataset,SIGNAL(seriesAdded(QSeries*,Domain*)),m_legend,SLOT(handleSeriesAdded(QSeries*,Domain*)));
                 disconnect(m_dataset,SIGNAL(seriesRemoved(QSeries*)),m_legend,SLOT(handleSeriesRemoved(QSeries*)));
             }
             /*!
                 Adds the \a series and optional \a axisY onto the chart and takes the ownership of the objects.
                 If auto scaling is enabled, re-scales the axes the series is bound to (both the x axis and
                 the y axis).
             */
             void QChart::addSeries(QSeries* series, QChartAxis* axisY)
             {
                 m_dataset->addSeries(series, axisY);
             }
             /*!
                 Removes the \a series specified in a perameter from the QChartView.
                 It releses its ownership of the specified QChartSeries object.
                 It does not delete the pointed QChartSeries data object
                 \sa addSeries(), removeAllSeries()
             */
             void QChart::removeSeries(QSeries* series)
             {
                 m_dataset->removeSeries(series);
             }
             /*!
                 Removes all the QChartSeries that have been added to the QChartView
                 It also deletes the pointed QChartSeries data objects
                 \sa addSeries(), removeSeries()
             */
             void QChart::removeAllSeries()
             {
                 m_dataset->removeAllSeries();
             }
             /*!
                 Sets the \a brush that is used for painting the background of the chart area.
             */
             void QChart::setChartBackgroundBrush(const QBrush& brush)
             {
                 createChartBackgroundItem();
                 m_backgroundItem->setBrush(brush);
                 m_backgroundItem->update();
             }
             /*!
                 Sets the \a pen that is used for painting the background of the chart area.
             */
             void QChart::setChartBackgroundPen(const QPen& pen)
             {
                 createChartBackgroundItem();
                 m_backgroundItem->setPen(pen);
                 m_backgroundItem->update();
             }
             /*!
                 Sets the chart \a title. The description text that is drawn above the chart.
             */
             void QChart::setChartTitle(const QString& title)
             {
                 createChartTitleItem();
                 m_titleItem->setText(title);
                 updateLayout();
             }
             /*!
                 Returns the chart title. The description text that is drawn above the chart.
             */
             QString QChart::chartTitle() const
             {
                 if(m_titleItem)
                 return m_titleItem->text();
                 else
                 return QString();
             }
             /*!
                 Sets the \a font that is used for rendering the description text that is rendered above the chart.
             */
             void QChart::setChartTitleFont(const QFont& font)
             {
                 createChartTitleItem();
                 m_titleItem->setFont(font);
                 updateLayout();
             }
             /*!
                 Sets the \a brush used for rendering the title text.
             */
             void QChart::setChartTitleBrush(const QBrush &brush)
             {
                 createChartTitleItem();
                 m_titleItem->setBrush(brush);
                 updateLayout();
             }
             /*!
                 Returns the brush used for rendering the title text.
             */
             QBrush QChart::chartTitleBrush()
             {
                 createChartTitleItem();
                 return m_titleItem->brush();
             }
             void QChart::createChartBackgroundItem()
             {
                 if(!m_backgroundItem) {
                     m_backgroundItem = new QGraphicsRectItem(this);
                     m_backgroundItem->setPen(Qt::NoPen);
                     m_backgroundItem->setZValue(ChartPresenter::BackgroundZValue);
                 }
             }
             void QChart::createChartTitleItem()
             {
                 if(!m_titleItem) {
                     m_titleItem = new QGraphicsSimpleTextItem(this);
                     m_titleItem->setZValue(ChartPresenter::BackgroundZValue);
                 }
             }
             /*!
                 Returns the chart margin, which is the distance between the widget edge and the part of the chart where the actual data can be displayed.
                 \sa setMargin()
             */
             int QChart::margin() const
             {
                 return m_presenter->margin();
             }
             /*!
                 Sets the chart \a margin, which is the distance between the widget edge and the part of the chart where the actual data can be displayed.
                 \sa margin()
             */
             void QChart::setMargin(int margin)
             {
                 m_presenter->setMargin(margin);
                 updateLayout();
             }
             /*!
                 Sets the \a theme used by the chart for rendering the graphical representation of the data
                 \sa ChartTheme, chartTheme()
             */
             void QChart::setChartTheme(QChart::ChartTheme theme)
             {
                 m_presenter->setChartTheme(theme);
             }
             /*!
                 Returns the theme enum used by the chart.
                 \sa ChartTheme, setChartTheme()
             */
             QChart::ChartTheme QChart::chartTheme() const
             {
                 return m_presenter->chartTheme();
             }
             /*!
                 Zooms in the view by a factor of 2
             */
             void QChart::zoomIn()
             {
                 m_presenter->zoomIn();
             }
             /*!
                 Zooms in the view to a maximum level at which \a rect is still fully visible.
             */
             void QChart::zoomIn(const QRectF& rect)
             {
                 if(!rect.isValid()) return;
                 m_presenter->zoomIn(rect);
             }
             /*!
                 Restores the view zoom level to the previous one.
             */
             void QChart::zoomOut()
             {
                 m_presenter->zoomOut();
             }
             /*!
                 Resets to the default view.
             */
             void QChart::zoomReset()
             {
                 m_presenter->zoomReset();
             }
             /*!
                 Returns the pointer to the x axis object of the chart
             */
             QChartAxis* QChart::axisX() const
             {
                 return m_dataset->axisX();
             }
             /*!
                 Returns the pointer to the y axis object of the chart
             */
             QChartAxis* QChart::axisY() const
             {
                 return m_dataset->axisY();
             }
             /*!
                 Returns the legend object of the chart
             */
             QLegend* QChart::legend()
             {
                 return m_legend;
             }
             /*!
                 Resizes and updates the chart area using the \a event data
             */
             void QChart::resizeEvent(QGraphicsSceneResizeEvent *event)
             {
                 m_rect = QRectF(QPoint(0,0),event->newSize());
                 updateLayout();
                 QGraphicsWidget::resizeEvent(event);
                 update();
             }
             /*!
                 Sets animation \a options for the chart
             */
             void QChart::setAnimationOptions(AnimationOptions options)
             {
                 m_presenter->setAnimationOptions(options);
             }
             /*!
                 Returns animation options for the chart
             */
             QChart::AnimationOptions QChart::animationOptions() const
             {
                 return m_presenter->animationOptions();
             }
             void QChart::scroll(int dx,int dy)
             {
             	//temporary
             	if(dx>0)
             	 m_presenter->scroll(m_presenter->geometry().width()/(axisX()->ticksCount()-1),0);
             	if(dx<0)
             	 m_presenter->scroll(-m_presenter->geometry().width()/(axisX()->ticksCount()-1),0);
             	if(dy>0)
             	 m_presenter->scroll(0,m_presenter->geometry().width()/(axisY()->ticksCount()-1));
             	if(dy<0)
             	 m_presenter->scroll(0,-m_presenter->geometry().width()/(axisY()->ticksCount()-1));
             }
             void QChart::updateLayout()
             {
                 if(!m_rect.isValid()) return;
                 QRectF rect = m_rect.adjusted(margin(),margin(), -margin(), -margin());
                 // recalculate title position
                 if (m_titleItem) {
                     QPointF center = m_rect.center() -m_titleItem->boundingRect().center();
                     m_titleItem->setPos(center.x(),m_rect.top()/2 + margin()/2);
                 }
                 //recalculate background gradient
                 if (m_backgroundItem) {
                     m_backgroundItem->setRect(rect);
                 }
             }
             #include "moc_qchart.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/qchart.h +3 -3

             #ifndef QCHART_H
             #define QCHART_H
             #include <qchartglobal.h>
             #include <qseries.h>
             #include <QGraphicsWidget>
             #include <QLinearGradient>
             #include <QFont>
             class QGraphicsSceneResizeEvent;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class AxisItem;
             class QSeries;
             class PlotDomain;
             class BarPresenter;
             class QChartAxis;
             class ChartTheme;
             class ChartItem;
             class ChartDataSet;
             class ChartPresenter;
             class QLegend;
             class QTCOMMERCIALCHART_EXPORT QChart : public QGraphicsWidget
             {
                 Q_OBJECT
             public:
                 enum ChartTheme {
                     ChartThemeDefault,
                     ChartThemeVanilla,
                     ChartThemeIcy,
                     ChartThemeGrayscale,
-                    ChartThemeScientific
+                    ChartThemeScientific,
-                    //ChartThemeUnnamed1
+                    ChartThemeBlueCerulean,
-                    /*! The default theme follows the GUI style of the Operating System */
+                    ChartThemeCount
                 };
                 enum  AnimationOption {
                     NoAnimation = 0x0,
                     GridAxisAnimations = 0x1,
                     SeriesAnimations =0x2,
                     AllAnimations = 0x3
                     };
                     Q_DECLARE_FLAGS(AnimationOptions, AnimationOption)
             public:
                 QChart(QGraphicsItem *parent = 0, Qt::WindowFlags wFlags = 0);
                 ~QChart();
                 void addSeries(QSeries* series, QChartAxis* axisY = 0);
                 void removeSeries(QSeries* series); //returns ownership , deletes axis if no series attached
                 void removeAllSeries(); // deletes series and axis
                 void setMargin(int margin);
                 int margin() const;
                 void setChartTheme(QChart::ChartTheme theme);
                 QChart::ChartTheme chartTheme() const;
                 void setChartTitle(const QString& title);
                 QString chartTitle() const;
                 void setChartTitleFont(const QFont& font);
                 void setChartTitleBrush(const QBrush &brush);
                 QBrush chartTitleBrush();
                 void setChartBackgroundBrush(const QBrush& brush);
                 void setChartBackgroundPen(const QPen& pen);
                 void setAnimationOptions(AnimationOptions options);
                 AnimationOptions animationOptions() const;
                 void zoomIn();
                 void zoomIn(const QRectF& rect);
                 void zoomOut();
                 void zoomReset();
                 void scroll(int dx,int dy);
                 QChartAxis* axisX() const;
                 QChartAxis* axisY() const;
                 QLegend* legend();
             protected:
                 void resizeEvent(QGraphicsSceneResizeEvent *event);
             private:
                 inline void createChartBackgroundItem();
                 inline void createChartTitleItem();
                 void updateLayout();
             private:
                 Q_DISABLE_COPY(QChart)
                 QGraphicsRectItem* m_backgroundItem;
                 QGraphicsSimpleTextItem* m_titleItem;
                 QRectF m_rect;
                 QLegend* m_legend;
                 ChartDataSet *m_dataset;
                 ChartPresenter *m_presenter;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             Q_DECLARE_OPERATORS_FOR_FLAGS(QTCOMMERCIALCHART_NAMESPACE::QChart::AnimationOptions)
             #endif

src/src.pro +2 -1

             !include( ../common.pri ):error( Couldn't find the common.pri file! )
             TARGET = QtCommercialChart
             DESTDIR = $$CHART_BUILD_LIB_DIR
             TEMPLATE = lib
             QT += core \
                 gui
             CONFIG += debug_and_release
             CONFIG(debug, debug|release):TARGET = QtCommercialChartd
             SOURCES += \
                 chartdataset.cpp \
                 chartpresenter.cpp \
                 charttheme.cpp \
                 domain.cpp \
                 qchart.cpp \
                 qchartview.cpp \
                 qseries.cpp \
                 qlegend.cpp \
                 legendmarker.cpp
             PRIVATE_HEADERS += \
                 chartdataset_p.h \
                 chartitem_p.h \
                 chartpresenter_p.h \
                 charttheme_p.h \
                 domain_p.h \
                 legendmarker_p.h
             PUBLIC_HEADERS += \
                 qchart.h \
                 qchartglobal.h \
                 qseries.h \
                 qchartview.h \
                 qlegend.h
             include(animations/animations.pri)
             include(axis/axis.pri)
             include(xychart/xychart.pri)
             include(linechart/linechart.pri)
             include(areachart/areachart.pri)
             include(barchart/barchart.pri)
             include(piechart/piechart.pri)
             include(scatterseries/scatter.pri)
             include(splinechart/splinechart.pri)
             THEMES += themes/chartthemedefault_p.h \
                 themes/chartthemeicy_p.h \
                 themes/chartthemegrayscale_p.h \
                 themes/chartthemescientific_p.h \
-                themes/chartthemevanilla_p.h
+                themes/chartthemevanilla_p.h \
+                themes/chartthemebluecerulean_p.h
             HEADERS += $$PUBLIC_HEADERS
             HEADERS += $$PRIVATE_HEADERS
             HEADERS += $$THEMES
             INCLUDEPATH += linechart \
                 barchart \
                 themes \
                 .
             OBJECTS_DIR = $$CHART_BUILD_DIR/lib
             MOC_DIR = $$CHART_BUILD_DIR/lib
             UI_DIR = $$CHART_BUILD_DIR/lib
             RCC_DIR = $$CHART_BUILD_DIR/lib
             DEFINES += QTCOMMERCIALCHART_LIBRARY
             public_headers.path = $$[QT_INSTALL_HEADERS]/QtCommercialChart
             public_headers.files = $$PUBLIC_HEADERS
             target.path = $$[QT_INSTALL_LIBS]
             INSTALLS += target \
                 public_headers
             install_build_public_headers.name = bild_public_headers
             install_build_public_headers.output = $$CHART_BUILD_PUBLIC_HEADER_DIR/${QMAKE_FILE_BASE}.h
             install_build_public_headers.input = PUBLIC_HEADERS
             install_build_public_headers.commands = $$QMAKE_COPY \
                 ${QMAKE_FILE_NAME} \
                 $$CHART_BUILD_PUBLIC_HEADER_DIR
             install_build_public_headers.CONFIG += target_predeps \
                 no_link
             install_build_private_headers.name = bild_private_headers
             install_build_private_headers.output = $$CHART_BUILD_PRIVATE_HEADER_DIR/${QMAKE_FILE_BASE}.h
             install_build_private_headers.input = PRIVATE_HEADERS
             install_build_private_headers.commands = $$QMAKE_COPY \
                 ${QMAKE_FILE_NAME} \
                 $$CHART_BUILD_PRIVATE_HEADER_DIR
             install_build_private_headers.CONFIG += target_predeps \
                 no_link
             QMAKE_EXTRA_COMPILERS += install_build_public_headers \
                 install_build_private_headers
             chartversion.target = qchartversion_p.h
             chartversion.commands = @echo \
                 "build_time" \
                 > \
                 $$chartversion.target;
             chartversion.depends = $$HEADERS \
                 $$SOURCES
             PRE_TARGETDEPS += qchartversion_p.h
             QMAKE_CLEAN += qchartversion_p.h
             QMAKE_EXTRA_TARGETS += chartversion
             unix:QMAKE_DISTCLEAN += -r \
                 $$CHART_BUILD_HEADER_DIR \
                 $$CHART_BUILD_LIB_DIR
             win32:QMAKE_DISTCLEAN += /Q \
                 $$CHART_BUILD_HEADER_DIR \
                 $$CHART_BUILD_LIB_DIR

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