HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r653:f4e416c6727f

Use light outline color instead of dark for bar, area and scatter

Tero Ahola -

r653:f4e416c6727f

parent child

Context file:

r653:f4e416c6727f

Collapse all files

src/barchart/bar.cpp +3 0

             #include "bar_p.h"
             #include <QDebug>
             #include <QPainter>
             #include <QGraphicsSceneEvent>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             Bar::Bar(QString category, QGraphicsItem *parent)
                 : QGraphicsObject(parent),
                 mXpos(0),
                 mYpos(0),
                 mWidth(0),
                 mHeight(0),
+                mBrush(QBrush()),
+                mPen(QPen()),
                 mCategory(category)
             {
                 setAcceptedMouseButtons(Qt::LeftButton|Qt::RightButton);
                 setAcceptHoverEvents(true);
             }
             void Bar::setSize(const QSizeF& size)
             {
                 mWidth = size.width();
                 mHeight = size.height();
             }
             void Bar::resize( qreal w, qreal h )
             {
                 mWidth = w;
                 mHeight = h;
             }
             void Bar::setPos(qreal x, qreal y)
             {
                 mXpos = x;
                 mYpos = y;
             }
             void Bar::setPen(QPen pen)
             {
                 mPen = pen;
             }
             void Bar::setBrush(QBrush brush)
             {
                 mBrush = brush;
             }
             void Bar::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 Q_UNUSED(option)
                 Q_UNUSED(widget)
                 if (0 == mHeight) {
                     return;
                 }
+                painter->setPen(mPen);
                 painter->setBrush(mBrush);
                 // This compensates for rounding errors. drawRect takes ints and cumulative error of pos + size may be over 1.
                 int x0 = mXpos;
                 int x1 = (mXpos + mWidth);
                 int w = x1-x0;
                 int y0 = mYpos;
                 int y1 = (mYpos + mHeight);
                 int h = y1-y0;
                 painter->drawRect(x0, y0 ,w ,h);
             }
             QRectF Bar::boundingRect() const
             {
                 QRectF r(mXpos, mYpos, mWidth, mHeight);
                 return r;
             }
             void Bar::mousePressEvent(QGraphicsSceneMouseEvent* event)
             {
                 if (event->button() == Qt::LeftButton) {
                     emit clicked(mCategory);
                 } else if (event->button() == Qt::RightButton) {
                     emit rightClicked(mCategory);
                 }
             }
             void Bar::hoverEnterEvent(QGraphicsSceneHoverEvent* event)
             {
                 emit hoverEntered(event->lastScreenPos());
             }
             void Bar::hoverLeaveEvent(QGraphicsSceneHoverEvent* /*event*/)
             {
                 emit hoverLeaved();
             }
             #include "moc_bar_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/percentbarpresenter.cpp +1 0

             #include "percentbarpresenter_p.h"
             #include "bar_p.h"
             #include "barvalue_p.h"
             #include "separator_p.h"
             #include "qbarset.h"
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             PercentBarPresenter::PercentBarPresenter(QBarSeries *series, QChart *parent) :
                 BarPresenterBase(series, parent)
             {
             }
             void PercentBarPresenter::layoutChanged()
             {
                 // Scale bars to new layout
                 // Layout for bars:
                 if (mSeries->barsetCount() <= 0) {
                     qDebug() << "No sets in model!";
                     // Nothing to do.
                     return;
                 }
                 if (childItems().count() == 0) {
                     qDebug() << "WARNING: PercentBarPresenter::layoutChanged called before graphics items are created!";
                     return;
                 }
                 // Use temporary qreals for accurancy (we might get some compiler warnings... :)
                 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);
                 qreal h = mHeight;
                 int itemIndex(0);
                 for (int category = 0; category < mSeries->categoryCount(); category++) {
                     qreal colSum = mSeries->categorySum(category);
                     qreal scale = (h / colSum);
                     qreal yPos = h;
                     for (int set=0; set < mSeries->barsetCount(); 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++;
                         yPos -= barHeight;
                     }
                     xPos += xStep;
                 }
             /*
                 // Position separators
                 xPos = xStep + xStep/2;
                 for (int s=0; s < mSeries->categoryCount() - 1; s++) {
                     Separator* sep = mSeparators.at(s);
                     sep->setPos(xPos,0);
                     sep->setSize(QSizeF(1,mHeight));
                     xPos += xStep;
                 }
             */
                 // Position floating values
                 itemIndex = 0;
                 xPos = (tW/tC);
                 for (int category=0; category < mSeries->categoryCount(); category++) {
                     qreal yPos = h;
                     qreal colSum = mSeries->categorySum(category);
                     qreal scale = (h / colSum);
                     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) {
                             int p = mSeries->percentageAt(set,category) * 100;
                             QString vString(QString::number(p));
                             vString.truncate(3);
                             vString.append("%");
                             value->setValueString(vString);
                         } else {
                             value->setValueString(QString(""));
                         }
                         itemIndex++;
                         yPos -= barHeight;
                     }
                     xPos += xStep;
                 }
             }
             #include "moc_percentbarpresenter_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/charttheme.cpp +26 -73

             #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()), 1.0));
+                    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)
+            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++) {
+                for (int i(0); i < sets.count(); i++) {
                     qreal pos = 0.5;
                     if (sets.count() > 1)
                         pos = (qreal) i / (qreal) (sets.count() - 1);
-                    if(brush == sets.at(i)->brush() || force ){
+                    if (brush == sets.at(i)->brush() || force ) {
-                    QColor c = colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), pos);
+                        QColor c = colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), pos);
-                    sets.at(i)->setBrush(QBrush(c));
+                        sets.at(i)->setBrush(QBrush(c));
-                    // Pick label color as far as possible from bar color (within gradient).
-                    // 0.3 is magic number that was picked as value that gave enough contrast with icy theme gradient :)
-                    // TODO: better picking of label color?
-                    QColor c;
-                    if (pos < 0.3) {
-                        c = colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), 1);
-                    } else {
-                        c = colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), 0);
-                    sets.at(i)->setFloatingValuePen(QPen(c));
-            void ChartTheme::decorate(QStackedBarSeries* series,int index,bool force)
-                QBrush brush;
-                QList<QBarSet*> sets = series->barSets();
-                for (int i=0; i<sets.count(); i++) {
-                    qreal pos = 0.5;
-                    if (sets.count() > 1)
-                        pos = (qreal) i / (qreal) (sets.count() - 1);
-                    if(brush == sets.at(i)->brush() || force){
-                    QColor c = colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), pos);
-                    sets.at(i)->setBrush(QBrush(c));
-                    QColor c;
-                    if (pos < 0.3) {
-                        c = colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), 1);
-                    } else {
-                        c = colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), 0);
                     }
-                    sets.at(i)->setFloatingValuePen(QPen(c));
-            void ChartTheme::decorate(QPercentBarSeries* series,int index,bool force)
+                    // Pick label color from the opposite end of the gradient.
+                    // 0.3 as a boundary seems to work well.
-                QBrush brush;
+                    if (pos < 0.3)
-                QList<QBarSet*> sets = series->barSets();
+                        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));
-                for (int i=0; i<sets.count(); i++) {
+                    if (pen == sets.at(i)->pen() || force) {
-                    qreal pos = 0.5;
+                        QColor c = colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), 0.0);
-                    if (sets.count() > 1)
+                        sets.at(i)->setPen(c);
-                        pos = (qreal) i / (qreal) (sets.count() - 1);
-                    if(brush == sets.at(i)->brush() || force){
-                    QColor c = colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), pos);
-                    sets.at(i)->setBrush(QBrush(c));
-                    QColor c;
-                    if (pos < 0.3) {
-                        c = colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), 1);
-                    } else {
-                        c = colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), 0);
                     }
-                    sets.at(i)->setFloatingValuePen(QPen(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()), 1.0));
+                    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)
             {
-                // Get color for a slice from a gradient linearly, beginning from the start of the gradient
                 QPen pen;
                 QBrush brush;
                 for (int i(0); i < series->slices().count(); i++) {
-                    qreal pos = (qreal) i / (qreal) series->count();
+                    if (pen == series->slices().at(i)->slicePen() || force) {
-                    if( pen == series->slices().at(i)->slicePen() || force){
+                        QColor penColor = colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), 0.0);
-                    QColor penColor = colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), 0.1);
+                        series->slices().at(i)->setSlicePen(penColor);
-                    series->slices().at(i)->setSlicePen(penColor);
                     }
-                    if( brush == series->slices().at(i)->sliceBrush() || force){
-                    QColor brushColor = colorAt(m_seriesGradients.at(index % m_seriesGradients.size()), pos);
+                    // Get color for a slice from a gradient linearly, beginning from the start of the gradient
-                    series->slices().at(i)->setSliceBrush(brushColor);
+                    qreal pos = (qreal) i / (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.05, 0.95);
                     g.setColorAt(0.0, start);
                     g.setColorAt(0.5, color);
                     QColor end = color;
                     end.setHsvF(h, s, 0.25);
                     g.setColorAt(1.0, end);
                     m_seriesGradients << g;
                 }
             }
             QColor ChartTheme::colorAt(const QColor &start, const QColor &end, qreal pos)
             {
                 Q_ASSERT(pos >=0.0 && pos <= 1.0);
                 qreal r = start.redF() + ((end.redF() - start.redF()) * pos);
                 qreal g = start.greenF() + ((end.greenF() - start.greenF()) * pos);
                 qreal b = start.blueF() + ((end.blueF() - start.blueF()) * pos);
                 QColor c;
                 c.setRgbF(r, g, b);
                 return c;
             }
             QColor ChartTheme::colorAt(const QGradient &gradient, qreal pos)
             {
                 Q_ASSERT(pos >=0 && pos <= 1.0);
                 // another possibility:
                 // http://stackoverflow.com/questions/3306786/get-intermediate-color-from-a-gradient
                 QGradientStops stops = gradient.stops();
                 int count = stops.count();
                 // find previous stop relative to position
                 QGradientStop prev = stops.first();
                 for (int i=0; i<count; i++) {
                     QGradientStop stop = stops.at(i);
                     if (pos > stop.first)
                         prev = stop;
                     // given position is actually a stop position?
                     if (pos == stop.first) {
                         //qDebug() << "stop color" << pos;
                         return stop.second;
                     }
                 }
                 // find next stop relative to position
                 QGradientStop next = stops.last();
                 for (int i=count-1; i>=0; i--) {
                     QGradientStop stop = stops.at(i);
                     if (pos < stop.first)
                         next = stop;
                 }
                 //qDebug() << "prev" << prev.first << "pos" << pos << "next" << next.first;
                 qreal range = next.first - prev.first;
                 qreal posDelta = pos - prev.first;
                 qreal relativePos = posDelta / range;
                 //qDebug() << "range" << range << "posDelta" << posDelta << "relativePos" << relativePos;
                 return colorAt(prev.second, next.second, relativePos);
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/charttheme_p.h 0 -3

             #ifndef CHARTTHEME_H
             #define CHARTTHEME_H
             #include "qchartglobal.h"
             #include "qchart.h"
             #include <QColor>
             #include <QGradientStops>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class ChartItem;
             class QSeries;
             class LineChartItem;
             class QLineSeries;
             class BarPresenter;
             class QBarSeries;
             class StackedBarPresenter;
             class QStackedBarSeries;
             class QPercentBarSeries;
             class PercentBarPresenter;
             class QScatterSeries;
             class ScatterChartItem;
             class 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(ChartItem* item, QSeries* series,int index);
                 void decorate(QBarSeries* series, int index,bool force = true);
-                void decorate(QStackedBarSeries* series, int index,bool force = true);
-                void decorate(QPercentBarSeries* 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;
                 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/scatterseries/scatterchartitem.cpp +1 -7

             #include "scatterchartitem_p.h"
             #include "qscatterseries.h"
             #include "chartpresenter_p.h"
             #include <QPainter>
             #include <QGraphicsScene>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ScatterChartItem::ScatterChartItem(QScatterSeries *series, QGraphicsItem *parent) :
                 XYChartItem(series,parent),
                 m_series(series),
                 m_items(this),
                 m_shape(QScatterSeries::MarkerShapeRectangle),
-                m_size(10)
+                m_size(15)
             {
                 Q_ASSERT(parent);
                 Q_ASSERT(series);
                 QObject::connect(m_series,SIGNAL(updated()), this, SLOT(handleUpdated()));
                 setZValue(ChartPresenter::ScatterSeriesZValue);
                 setFlags(QGraphicsItem::ItemHasNoContents);
                 setFlags(QGraphicsItem::ItemClipsChildrenToShape);
                 handleUpdated();
                 m_items.setHandlesChildEvents(false);
                 // TODO: how to draw a drop shadow?
             //    QGraphicsDropShadowEffect *dropShadow = new QGraphicsDropShadowEffect();
             //    dropShadow->setOffset(2.0);
             //    dropShadow->setBlurRadius(2.0);
             //    setGraphicsEffect(dropShadow);
             }
             QRectF ScatterChartItem::boundingRect() const
             {
                 return m_rect;
             }
             void ScatterChartItem::createPoints(int count)
             {
                 for (int i = 0; i < count; ++i) {
                     QGraphicsItem *item;
                     switch (m_shape) {
                                case QScatterSeries::MarkerShapeCircle:{
                                    QGraphicsEllipseItem* i = new QGraphicsEllipseItem(0,0,m_size,m_size);
                                    const QRectF& rect = i->boundingRect();
                                    i->setPos(-rect.width()/2,-rect.height()/2);
                                    item = new Marker(i,this);
                                    break;
                                }
                                case QScatterSeries::MarkerShapeRectangle:{
                                    QGraphicsRectItem* i = new QGraphicsRectItem(0,0,m_size,m_size);
                                    i->setPos(-m_size/2,-m_size/2);
                                    item = new Marker(i,this);
                                    break;
                                }
                                default:
                                    qWarning()<<"Unsupported marker type";
                                    break;
                     }
                     m_items.addToGroup(item);
                 }
             }
             void ScatterChartItem::deletePoints(int count)
             {
                 QList<QGraphicsItem *> items = m_items.childItems();
                 for (int i = 0; i < count; ++i) {
                     delete(items.takeLast());
                 }
             }
             void ScatterChartItem::markerSelected(Marker* marker)
             {
                 emit XYChartItem::clicked(QPointF(m_series->x(marker->index()), m_series->y(marker->index())));
             }
             void ScatterChartItem::setLayout(QVector<QPointF>& points)
             {
                 if(points.size()==0)
                 {
                     XYChartItem::setLayout(points);
                     return;
                 }
                 int diff = XYChartItem::points().size() - points.size();
                 if(diff>0) {
                     deletePoints(diff);
                 }
                 else if(diff<0) {
                     createPoints(-diff);
                 }
                 if(diff!=0) handleUpdated();
                 QList<QGraphicsItem*> items = m_items.childItems();
                 for(int i=0; i< points.size();i++) {
                     Marker* item = static_cast<Marker*>(items.at(i));
                     const QPointF& point = points.at(i);
                     const QRectF& rect = item->boundingRect();
                     item->setIndex(i);
                     item->setPos(point.x()-rect.width()/2,point.y()-rect.height()/2);
                     if(!clipRect().contains(point)) {
                         item->setVisible(false);
                     }
                     else {
                         item->setVisible(true);
                     }
                 }
                 prepareGeometryChange();
                 m_rect = clipRect();
                 XYChartItem::setLayout(points);
             }
             void ScatterChartItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 Q_UNUSED(painter)
                 Q_UNUSED(option)
                 Q_UNUSED(widget)
             }
             void ScatterChartItem::setPen(const QPen& pen)
             {
                 foreach(QGraphicsItem* item , m_items.childItems()) {
                        static_cast<Marker*>(item)->setPen(pen);
                 }
             }
             void ScatterChartItem::setBrush(const QBrush& brush)
             {
                 foreach(QGraphicsItem* item , m_items.childItems()) {
                         static_cast<Marker*>(item)->setBrush(brush);
                  }
             }
             void ScatterChartItem::handleUpdated()
             {
                 int count = m_items.childItems().count();
                 if(count==0) return;
                 bool recreate = m_size != m_series->size() || m_shape != m_series->shape();
                 //TODO: only rewrite on size change
                 m_size = m_series->size();
                 m_shape = m_series->shape();
                 if(recreate){
                     deletePoints(count);
                     createPoints(count);
                 }
                 setPen(m_series->pen());
                 setBrush(m_series->brush());
             }
             #include "moc_scatterchartitem_p.cpp"
             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