HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r183:45734e367adb

brush support for bargroups

sauimone -

r183:45734e367adb

parent child

Context file:

r183:45734e367adb

Collapse all files

src/barchart/bar.cpp +14 -2

             #include "bar_p.h"
             #include <QDebug>
             #include <QPainter>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             Bar::Bar(QGraphicsItem *parent)
                 : ChartItem(parent)
             {
             }
             void Bar::setSize(const QSizeF& size)
             {
                 mWidth = size.width();
                 mHeight = size.height();
             }
             void Bar::resize( qreal w, qreal h )
             {
             //    qDebug() << "bar::resize" << w << h;
                 mWidth = w;
                 mHeight = h;
             }
             void Bar::setColor( QColor col )
             {
                 mColor = col;
             }
             void Bar::setPos(qreal x, qreal y)
             {
              //   qDebug() << "Bar::setpos" << x << 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)
             {
                 if (0 == mHeight) {
                     return;
                 }
                 // TODO: accept brush instead of color
-                QBrush brush(mColor);
+                painter->setBrush(mBrush);
-                painter->setBrush(brush);
+            //    QBrush brush(mColor);
+            //    painter->setBrush(brush);
                 // 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, mXpos + mWidth, mYpos + mHeight);
                 return r;
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/bar_p.h +9 -2

             #ifndef BAR_H
             #define BAR_H
             #include "chartitem_p.h"
             #include "qchartglobal.h"
             #include <QGraphicsItem>
+            #include <QPen>
+            #include <QBrush>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             // Single bar item of chart
             class Bar : public ChartItem
             {
             public:
                 Bar(QGraphicsItem *parent=0);
             public: // from ChartItem
                 void setSize(const QSizeF &size);
                 // Layout Stuff
-                void resize( qreal w, qreal h );   // Size of bar.
+                void resize(qreal w, qreal h);   // Size of bar.
-                void setColor( QColor col );       // Color of bar
                 void setPos(qreal x, qreal y);
+                void setPen(QPen pen);
+                void setBrush(QBrush brush);
+                void setColor( QColor col);     // deprecated
             public:
                 // From QGraphicsItem
                 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = 0);
                 QRectF boundingRect() const;
             private:
                 qreal mHeight;
                 qreal mWidth;
                 qreal mXpos;
                 qreal mYpos;
                 QColor mColor;
+                QBrush mBrush;
+                QPen mPen;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // BAR_H

src/barchart/bargroup.cpp +12 -9

             #include "bargroup.h"
             #include "bar_p.h"
             #include "barlabel_p.h"
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             BarGroup::BarGroup(BarChartModel& model, QGraphicsItem *parent) :
                 BarGroupBase(model,parent)
             {
                 mBarDefaultWidth = 5;
             }
             void BarGroup::layoutChanged()
             {
             //    qDebug() << "BarGroup::layoutChanged";
                 // Scale bars to new layout
                 // Layout for bars:
                 if (mModel.countSets() <= 0) {
                     qDebug() << "No sets in model!";
                     return;
                 }
                 if (childItems().count() == 0) {
                     qDebug() << "WARNING: BarGroup::layoutChanged called before graphics items are created!";
                     return;
                 }
                 // TODO: better way to auto-layout?
                 // Use reals for accurancy (we might get some compiler warnings... :)
                 int itemCount = mModel.countCategories();
-                int seriesCount = mModel.countSets();
+                int setCount = mModel.countSets();
                 qreal tW = mWidth;
                 qreal tH = mHeight;
                 qreal tM = mModel.max();
                 qreal scale = (tH/tM);
                 qreal tC = itemCount+1;
-                qreal xStepPerSeries = (tW/tC);
+                qreal xStepPerSet = (tW/tC);
                 // Scaling.
                 int itemIndex(0);
-                int labelIndex = itemCount * seriesCount;
+                int labelIndex = itemCount * setCount;
                 for (int item=0; item < itemCount; item++) {
-                    qreal xPos = xStepPerSeries * item + ((tW + mBarDefaultWidth*seriesCount)/(itemCount*2));
+                    qreal xPos = xStepPerSet * item + ((tW + mBarDefaultWidth*setCount)/(itemCount*2));
                     qreal yPos = mHeight;
-                    for (int series = 0; series < seriesCount; series++) {
+                    for (int set = 0; set < setCount; set++) {
-                        qreal barHeight = mModel.valueAt(series, item) * scale;
+                        qreal barHeight = mModel.valueAt(set, item) * scale;
                         Bar* bar = reinterpret_cast<Bar*> (childItems().at(itemIndex));
                         // TODO: width settable per bar?
                         bar->resize(mBarDefaultWidth, barHeight);
-                        bar->setColor(mColors.at(series));
+                        bar->setBrush(mBrushes.at(set));
-                        bar->setPos(xPos, yPos-barHeight); // item*posStep+startPos + series * mBarDefaultWidth, mHeight);
+            //            bar->setPen(mModel.barSet(set).pen());
+            //            bar->setColor(mColors.at(set));
+            //            bar->setPen();
+                        bar->setPos(xPos, yPos-barHeight); // item*posStep+startPos + set * mBarDefaultWidth, mHeight);
                         itemIndex++;
                         xPos += mBarDefaultWidth;
                     }
                     // TODO: Layout for labels, remove magic number
-                    xPos = xStepPerSeries * item + ((tW + mBarDefaultWidth*seriesCount)/(itemCount*2));
+                    xPos = xStepPerSet * item + ((tW + mBarDefaultWidth*setCount)/(itemCount*2));
                     BarLabel* label = reinterpret_cast<BarLabel*> (childItems().at(labelIndex));
                     label->setPos(xPos, mHeight + 20);
                     labelIndex++;
                 }
                 mLayoutDirty = true;
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/bargroupbase.cpp +14 -2

             #include "bargroupbase.h"
             #include "bar_p.h"
             #include "barlabel_p.h"
             #include "separator_p.h"
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             BarGroupBase::BarGroupBase(BarChartModel& model, QGraphicsItem *parent)
                 : ChartItem(parent)
                 ,mBarDefaultWidth(20) // TODO: remove hard coding, when we have layout code ready
                 ,mLayoutSet(false)
                 ,mLayoutDirty(true)
                 ,mSeparatorsVisible(true)
                 ,mModel(model)
             {
                 dataChanged();
             }
             void BarGroupBase::setSeparatorsVisible(bool visible)
             {
                 mSeparatorsVisible = visible;
             }
             void BarGroupBase::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
             //    qDebug() << "BarGroupBase::paint" << childItems().count();
                 if (!mLayoutSet) {
                     qDebug() << "BarGroupBase::paint called without layout set. Aborting.";
                     return;
                 }
             //    if (mLayoutDirty) {
                     // Layout or data has changed. Need to redraw.
                     foreach(QGraphicsItem* i, childItems()) {
                         i->paint(painter,option,widget);
                     }
             //    }
             }
             QRectF BarGroupBase::boundingRect() const
             {
                 return QRectF(0,0,mWidth,mHeight);
             }
             void BarGroupBase::setBarWidth( int w )
             {
                 mBarDefaultWidth = w;
             }
+            /*
             int BarGroupBase::addColor( QColor color )
             {
             //    qDebug() << "BarGroupBase::addColor";
                 int colorIndex = mColors.count();
                 mColors.append(color);
                 return colorIndex;
             }
+            */
+            /*
             void BarGroupBase::resetColors()
             {
             //    qDebug() << "BarGroupBase::resetColors";
                 mColors.clear();
             }
+            */
+            void BarGroupBase::resetBrushes()
+            {
+                mBrushes.clear();
+            }
+            void BarGroupBase::addBrush(QBrush brush)
+            {
+                mBrushes.append(brush);
+            }
             void BarGroupBase::dataChanged()
             {
                 // TODO: performance optimizations. Do we really need to delete and create items every time data is changed or can we reuse them?
                 // Delete old bars
                 foreach (QGraphicsItem* item, childItems()) {
                     delete item;
                 }
                 // Create new graphic items for bars
                 int totalItems = mModel.countTotalItems();
                 for (int i=0; i<totalItems; i++) {
                     Bar *bar = new Bar(this);
                     childItems().append(bar);
                 }
                 int count = mModel.countCategories();
                 for (int i=0; i<count; i++) {
                     BarLabel* label = new BarLabel(this);
                     label->set(mModel.label(i));
                     childItems().append(label);
                 }
                 count = mModel.countCategories() - 1;   // There is one less separator than columns
                 for (int i=0; i<count; i++) {
                     Separator* sep = new Separator(this);
                     sep->setColor(QColor(255,0,0,255));     // TODO: color for separations from theme
                     childItems().append(sep);
                 }
                 // TODO: if (autolayout) { layoutChanged() } or something
                 mLayoutDirty = true;
             }
             //handlers
             void BarGroupBase::handleModelChanged(int index)
             {
             //    qDebug() << "BarGroupBase::handleModelChanged" << index;
                 dataChanged();
             }
             void BarGroupBase::handleDomainChanged(const Domain& domain)
             {
             //    qDebug() << "BarGroupBase::handleDomainChanged";
                 // TODO: Figure out the use case for this.
                 // Affects the size of visible item, so layout is changed.
             //    layoutChanged();
             }
             void BarGroupBase::handleGeometryChanged(const QRectF& rect)
             {
                 mWidth = rect.width();
                 mHeight = rect.height();
                 layoutChanged();
                 mLayoutSet = true;
                 setPos(rect.topLeft());
             }
             #include "moc_bargroupbase.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/bargroupbase.h +16 -2

             #ifndef BARGROUPBASE_H
             #define BARGROUPBASE_H
             #include "chartitem_p.h"
             #include "barchartmodel_p.h"
+            #include <QPen>
+            #include <QBrush>
             #include <QGraphicsItem>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             // Base Class for bar groups. Common implemantation of different groups. Not to be instantiated.
             class BarGroupBase : public QObject, public ChartItem
             {
                 Q_OBJECT
             public:
                 BarGroupBase(BarChartModel& model, QGraphicsItem *parent = 0);
                 void setSeparatorsVisible(bool visible = true);
             public:
                 // From QGraphicsItem
                 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
                 QRectF boundingRect() const;
                 // TODO: these may change with layout awarness.
                 void setBarWidth( int w );
-                int addColor( QColor color );
+            //    int addColor( QColor color );
-                void resetColors();
+            //    void resetColors();
+                void resetBrushes();
+                void addBrush(QBrush brush);
+                void setPen(QPen pen);
+                QPen pen();
+                void setBrush(QBrush brush);
+                QBrush brush();
                 // TODO: Consider the domain for layoutChanged. May be use case, may not be. If it is, then the derived classes need to implement it
                 virtual void dataChanged();     // data of series has changed -> need to recalculate bar sizes
                 virtual void layoutChanged() = 0;   // layout has changed -> need to recalculate bar sizes
             protected slots:
                 void handleModelChanged(int index);
                 void handleDomainChanged(const Domain& domain);
                 void handleGeometryChanged(const QRectF& size);
             protected:
                 // TODO: consider these.
                 int mHeight;        // Layout spesific
                 int mWidth;
                 int mBarDefaultWidth;
                 bool mLayoutSet;    // True, if component has been laid out.
                 bool mLayoutDirty;
                 QList<QColor> mColors;  // List of colors for series for now
                 bool mSeparatorsVisible;
                 BarChartModel& mModel;
+                QPen mPen;
+                QList<QBrush> mBrushes;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // BARGROUPBASE_H

src/barchart/percentbargroup.cpp +7 -5

             #include "percentbargroup.h"
             #include "bar_p.h"
             #include "barlabel_p.h"
             #include "separator_p.h"
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             PercentBarGroup::PercentBarGroup(BarChartModel& model, QGraphicsItem *parent) :
                 BarGroupBase(model, parent)
             {
             }
             void PercentBarGroup::layoutChanged()
             {
             //    qDebug() << "PercentBarGroup::layoutChanged";
                 // Scale bars to new layout
                 // Layout for bars:
                 if (mModel.countSets() <= 0) {
                     qDebug() << "No sets in model!";
                     // Nothing to do.
                     return;
                 }
                 if (childItems().count() == 0) {
                     qDebug() << "WARNING: PercentBarGroup::layoutChanged called before graphics items are created!";
                     return;
                 }
                 // TODO: better way to auto-layout
                 // Use reals for accurancy (we might get some compiler warnings... :)
                 int count = mModel.countCategories();
                 int itemIndex(0);
                 qreal tW = mWidth;
                 qreal tC = count+1;
                 qreal xStep = (tW/tC);
                 qreal xPos = ((tW/tC) - mBarDefaultWidth / 2);
                 int labelIndex = mModel.countCategories() * mModel.countSets();
-                for (int column = 0; column < mModel.countCategories(); column++) {
+                for (int category = 0; category < mModel.countCategories(); category++) {
-                    qreal colSum = mModel.categorySum(column);
+                    qreal colSum = mModel.categorySum(category);
                     qreal h = mHeight;
                     qreal scale = (h / colSum);
                     qreal yPos = h;
-                    for (int row=0; row < mModel.countSets(); row++) {
+                    for (int set=0; set < mModel.countSets(); set++) {
-                        qreal barHeight = mModel.valueAt(row, column) * scale;
+                        qreal barHeight = mModel.valueAt(set, category) * scale;
                         Bar* bar = reinterpret_cast<Bar*> (childItems().at(itemIndex));
                         // TODO: width settable per bar?
                         bar->resize(mBarDefaultWidth, barHeight);
-                        bar->setColor(mColors.at(row));
+                        bar->setBrush(mBrushes.at(set));
+            //            bar->setBrush(mBrush);
+            //            bar->setColor(mColors.at(set));
                         bar->setPos(xPos, yPos-barHeight);
                         itemIndex++;
                         yPos -= barHeight;
                     }
                     // TODO: Layout for labels, remove magic number
                     BarLabel* label = reinterpret_cast<BarLabel*> (childItems().at(labelIndex));
                     label->setPos(xPos, mHeight + 20);
                     labelIndex++;
                     xPos += xStep;
                 }
                 // Position separators
                 int separatorIndex = labelIndex;    // Separators are after labels in childItems(). TODO: better way to store these?
                 xPos = xStep + xStep/2;             // Initial position is between first and second group. ie one and half steps from left.
                 for (int s=0; s < mModel.countCategories() - 1; s++) {
                     Separator* sep = reinterpret_cast<Separator*> (childItems().at(separatorIndex));
                     sep->setPos(xPos,0);
                     sep->setSize(QSizeF(1,mHeight));
                     xPos += xStep;
                     separatorIndex++;
                 }
                 mLayoutDirty = true;
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/qbarset.cpp +5 0

             #include "qbarset.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             QBarSet::QBarSet()
             {
             }
             void QBarSet::setName(QString name)
             {
                 mName = name;
             }
             QString QBarSet::name()
             {
                 return mName;
             }
             QBarSet& QBarSet::operator << (const qreal &value)
             {
                 mValues.append(value);
                 return *this;
             }
             int QBarSet::count()
             {
                 return mValues.count();
             }
             qreal QBarSet::valueAt(int index)
             {
                 return mValues.at(index);
             }
+            void QBarSet::setValue(int index, qreal value)
+            {
+                mValues.replace(index,value);
+            }
             //TODO?:
             //#include "moc_qbarset.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/qbarset.h +6 -6

             #ifndef QBARSET_H
             #define QBARSET_H
             #include "qchartglobal.h"
+            #include <QPen>
+            #include <QBrush>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QTCOMMERCIALCHART_EXPORT QBarSet // TODO? : public QObject
             {
                 //Q_OBJECT;
             public:
                 QBarSet();
                 void setName(QString name);
                 QString name();
-                QBarSet& operator << (const qreal &value);
+                QBarSet& operator << (const qreal &value);  // appends new value to set
-                //TODO: What is the way to set a single value to n:th item? Is there need for such functionality?
+                int count();                                // count of values in set
+                qreal valueAt(int index);                   // for modifying individual values
-                int count();
+                void setValue(int index, qreal value);      //
-                qreal valueAt(int index);
             private:
                 QString mName;
                 QList<qreal> mValues;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QBARSET_H

src/barchart/stackedbargroup.cpp +7 -5

             #include "stackedbargroup.h"
             #include "bar_p.h"
             #include "barlabel_p.h"
             #include "separator_p.h"
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             StackedBarGroup::StackedBarGroup(BarChartModel& model, QGraphicsItem *parent) :
                 BarGroupBase(model,parent)
             {
             }
             void StackedBarGroup::layoutChanged()
             {
             //    qDebug() << "StackedBarGroup::layoutChanged";
                 // Scale bars to new layout
                 // Layout for bars:
                 if (mModel.countSets() <= 0) {
                     qDebug() << "No sets in model!";
                     // Nothing to do.
                     return;
                 }
                 if (mModel.countCategories() == 0) {
                     qDebug() << "No categories in model!";
                     // Nothing to do
                     return;
                 }
                 if (childItems().count() == 0) {
                     qDebug() << "WARNING: StackedBarGroup::layoutChanged called before graphics items are created!";
                     return;
                 }
                 // TODO: better way to auto-layout
                 // Use reals for accurancy (we might get some compiler warnings... :)
-                // TODO: use temp variable for column count...
+                // TODO: use temp variable for category count...
                 qreal maxSum = mModel.maxCategorySum();
                 qreal h = mHeight;
                 qreal scale = (h / maxSum);
                 int itemIndex(0);
                 qreal tW = mWidth;
                 qreal tC = mModel.countCategories() + 1;
                 qreal xStep = (tW/tC);
                 qreal xPos = ((tW/tC) - mBarDefaultWidth / 2);
                 int labelIndex = mModel.countSets() * mModel.countCategories();
-                for (int column = 0; column < mModel.countCategories(); column++) {
+                for (int category = 0; category < mModel.countCategories(); category++) {
                     qreal yPos = h;
-                    for (int row=0; row < mModel.countSets(); row++) {
+                    for (int set=0; set < mModel.countSets(); set++) {
-                        qreal barHeight = mModel.valueAt(row, column) * scale;
+                        qreal barHeight = mModel.valueAt(set, category) * scale;
                         Bar* bar = reinterpret_cast<Bar*> (childItems().at(itemIndex));
                         bar->resize(mBarDefaultWidth, barHeight);
-                        bar->setColor(mColors.at(row));
+                        bar->setBrush(mBrushes.at(set));
+            //            bar->setBrush(mBrush);
+            //            bar->setColor(mColors.at(set));
                         bar->setPos(xPos, yPos-barHeight);
                         itemIndex++;
                         yPos -= barHeight;
                     }
                     // TODO: Layout for labels, remove magic number
                     BarLabel* label = reinterpret_cast<BarLabel*> (childItems().at(labelIndex));
                     label->setPos(xPos, mHeight + 20);
                     labelIndex++;
                     xPos += xStep;
                 }
                 // Position separators
                 int separatorIndex = labelIndex;    // Separators are after labels in childItems(). TODO: better way to store these?
                 xPos = xStep + xStep/2;             // Initial position is between first and second group. ie one and half steps from left.
                 for (int s=0; s < mModel.countCategories() - 1; s++) {
                     Separator* sep = reinterpret_cast<Separator*> (childItems().at(separatorIndex));
                     sep->setPos(xPos,0);
                     sep->setSize(QSizeF(1,mHeight));
                     xPos += xStep;
                     separatorIndex++;
                 }
                 mLayoutDirty = true;
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/charttheme.cpp +29 -23

             #include "charttheme_p.h"
             #include "qchart.h"
             #include "qchartaxis.h"
             //series
             #include "barchartseries.h"
             #include "stackedbarchartseries.h"
             #include "percentbarchartseries.h"
             #include "qlinechartseries.h"
             #include "qscatterseries.h"
             #include "qpieseries.h"
             //items
             #include "axisitem_p.h"
             #include "bargroup.h"
             #include "stackedbargroup.h"
             #include "linechartitem_p.h"
             #include "percentbargroup.h"
             #include "scatterpresenter.h"
             #include "piepresenter.h"
             //themes
             #include "chartthemevanilla_p.h"
             #include "chartthemeicy_p.h"
             #include "chartthemegrayscale_p.h"
             #include "chartthemescientific_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /* TODO
                 case QChart::ChartThemeUnnamed1:
                     m_seriesThemes.append(SeriesTheme(QColor(QRgb(0xff3fa9f5)), 2));
                     m_seriesThemes.append(SeriesTheme(QColor(QRgb(0xff7AC943)), 2));
                     m_seriesThemes.append(SeriesTheme(QColor(QRgb(0xffFF931E)), 2));
                     m_seriesThemes.append(SeriesTheme(QColor(QRgb(0xffFF1D25)), 2));
                     m_seriesThemes.append(SeriesTheme(QColor(QRgb(0xffFF7BAC)), 2));
                     m_gradientStartColor = QColor(QRgb(0xfff3dc9e));
                     m_gradientEndColor = QColor(QRgb(0xffafafaf));
             */
             ChartTheme::ChartTheme(QChart::ChartTheme id)
             {
                 m_id = id;
                 m_seriesColor.append(QRgb(0xff000000));
                 m_seriesColor.append(QRgb(0xff707070));
                 m_gradientStartColor = QColor(QRgb(0xffffffff));
                 m_gradientEndColor = QColor(QRgb(0xffafafaf));
             }
             ChartTheme* ChartTheme::createTheme(QChart::ChartTheme theme)
             {
                 switch(theme) {
                     case QChart::ChartThemeDefault:
                         return new ChartTheme();
                     case QChart::ChartThemeVanilla:
                         return new ChartThemeVanilla();
                     case QChart::ChartThemeIcy:
                         return new ChartThemeIcy();
                     case QChart::ChartThemeGrayscale:
                         return new ChartThemeGrayscale();
                     case QChart::ChartThemeScientific:
                         return new ChartThemeScientific();
                 }
             }
             void ChartTheme::decorate(QChart* chart)
             {
                 QLinearGradient backgroundGradient;
                 backgroundGradient.setColorAt(0.0, m_gradientStartColor);
                 backgroundGradient.setColorAt(1.0, m_gradientEndColor);
                 backgroundGradient.setCoordinateMode(QGradient::ObjectBoundingMode);
                 chart->setChartBackgroundBrush(backgroundGradient);
             }
             //TODO helper to by removed later
             void ChartTheme::decorate(ChartItem* item, QChartSeries* series,int count)
             {
                 switch(series->type())
                 {
                     case QChartSeries::SeriesTypeLine: {
                         QLineChartSeries* s = static_cast<QLineChartSeries*>(series);
                         LineChartItem* i = static_cast<LineChartItem*>(item);
                         decorate(i,s,count);
                         break;
                     }
                     case QChartSeries::SeriesTypeBar: {
                         BarChartSeries* b = static_cast<BarChartSeries*>(series);
                         BarGroup* i = static_cast<BarGroup*>(item);
                         decorate(i,b,count);
                         break;
                     }
                     case QChartSeries::SeriesTypeStackedBar: {
                         StackedBarChartSeries* s = static_cast<StackedBarChartSeries*>(series);
                         StackedBarGroup* i = static_cast<StackedBarGroup*>(item);
                         decorate(i,s,count);
                         break;
                     }
                     case QChartSeries::SeriesTypePercentBar: {
                         PercentBarChartSeries* s = static_cast<PercentBarChartSeries*>(series);
                         PercentBarGroup* i = static_cast<PercentBarGroup*>(item);
                         decorate(i,s,count);
                         break;
                     }
                     case QChartSeries::SeriesTypePie: {
                         QPieSeries* s = static_cast<QPieSeries*>(series);
                         PiePresenter* i = static_cast<PiePresenter*>(item);
                         decorate(i,s,count);
                         break;
                     }
                     default:
                     qDebug()<<"Wrong item to be decorated by theme";
                     break;
                 }
             }
             void ChartTheme::decorate(LineChartItem* item, QLineChartSeries* series,int count)
             {
                 QPen pen;
                 if(pen != series->pen()){
                     item->setPen(series->pen());
                     return;
                 }
                 pen.setColor(m_seriesColor.at(count%m_seriesColor.size()));
                 pen.setWidthF(2);
                 item->setPen(pen);
             }
             void ChartTheme::decorate(BarGroup* item, BarChartSeries* series,int count)
             {
-                item->resetColors();
+                // TODO: better way to descide series color and remove hard coded colors.
+                item->resetBrushes();
                 for (int i=0; i<m_seriesColor.count(); i++) {
-                    item->addColor(m_seriesColor.at(i));
+                    QBrush brush(m_seriesColor.at(i));
+                    item->addBrush(brush);
                 }
-                item->addColor(QColor(255,0,0,128));
+                item->addBrush(QBrush(QColor(255,0,0,128)));
-                item->addColor(QColor(255,255,0,128));
+                item->addBrush(QBrush(QColor(255,255,0,128)));
-                item->addColor(QColor(0,255,0,128));
+                item->addBrush(QBrush(QColor(0,255,0,128)));
-                item->addColor(QColor(0,0,255,128));
+                item->addBrush(QBrush(QColor(0,0,255,128)));
-                item->addColor(QColor(255,128,0,128));
+                item->addBrush(QBrush(QColor(255,128,0,128)));
             }
             void ChartTheme::decorate(StackedBarGroup* item, StackedBarChartSeries* series,int count)
             {
-                item->resetColors();
+                // TODO: better way to descide series color and remove hard coded colors.
-                for (int i=0; i< m_seriesColor.count(); i++) {
+                item->resetBrushes();
-                    item->addColor(m_seriesColor.at(i));
+                for (int i=0; i<m_seriesColor.count(); i++) {
+                    QBrush brush(m_seriesColor.at(i));
+                    item->addBrush(brush);
                 }
-                item->addColor(QColor(255,0,0,128));
+                item->addBrush(QBrush(QColor(255,0,0,128)));
-                item->addColor(QColor(255,255,0,128));
+                item->addBrush(QBrush(QColor(255,255,0,128)));
-                item->addColor(QColor(0,255,0,128));
+                item->addBrush(QBrush(QColor(0,255,0,128)));
-                item->addColor(QColor(0,0,255,128));
+                item->addBrush(QBrush(QColor(0,0,255,128)));
-                item->addColor(QColor(255,128,0,128));
+                item->addBrush(QBrush(QColor(255,128,0,128)));
             }
             void ChartTheme::decorate(PercentBarGroup* item, PercentBarChartSeries* series,int count)
             {
-                item->resetColors();
+                // TODO: better way to descide series color and remove hard coded colors.
-                for (int i=0; i< m_seriesColor.count(); i++) {
+                item->resetBrushes();
-                    item->addColor(m_seriesColor.at(i));
+                for (int i=0; i<m_seriesColor.count(); i++) {
+                    QBrush brush(m_seriesColor.at(i));
+                    item->addBrush(brush);
                 }
-                item->addColor(QColor(255,0,0,128));
+                item->addBrush(QBrush(QColor(255,0,0,128)));
-                item->addColor(QColor(255,255,0,128));
+                item->addBrush(QBrush(QColor(255,255,0,128)));
-                item->addColor(QColor(0,255,0,128));
+                item->addBrush(QBrush(QColor(0,255,0,128)));
-                item->addColor(QColor(0,0,255,128));
+                item->addBrush(QBrush(QColor(0,0,255,128)));
-                item->addColor(QColor(255,128,0,128));
+                item->addBrush(QBrush(QColor(255,128,0,128)));
             }
             void ChartTheme::decorate(ScatterPresenter* presenter, QScatterSeries* series, int count)
             {
                 Q_ASSERT(presenter);
                 Q_ASSERT(series);
                 presenter->m_markerPen.setColor(m_seriesColor.at(count % m_seriesColor.size()));
             //    QPen pen;
             //    if(pen != series->pen()){
             //        item->setPen(series->pen());
             //        return;
             //    }
             //    pen.setColor(m_seriesColor.at(count%m_seriesColor.size()));
             //    pen.setWidthF(2);
             //    item->setPen(pen);
             }
             void ChartTheme::decorate(PiePresenter* item, QPieSeries* series, int /*count*/)
             {
                 // create a list of slice colors based on current theme
                 int i = 0;
                 QList<QColor> colors;
                 while (colors.count() < series->count()) {
                     // get base color
                     QColor c = m_seriesColor[i++];
                     i = i % m_seriesColor.count();
                     // -1 means achromatic color -> cannot manipulate lightness
                     // TODO: find a better way to randomize lightness
                     if (c.toHsv().hue() == -1)
                         qWarning() << "ChartTheme::decorate() warning: achromatic theme color";
                     // randomize lightness
                     qreal f = 50 + (qrand() % 100); // 50 is 50% darker, 100 is the same, 150 is 50% lighter
                     c = c.lighter(f);
                     // find duplicates
                     bool isUnique = true;
                     foreach (QColor color, colors) {
                         if (c == color)
                             isUnique = false;
                     }
                     // add to array if unique
                     //if (isUnique)
                         colors << c;
                 }
                 // finally update colors
                 foreach (QPieSliceId id, series->ids()) {
                     QPieSlice s = series->slice(id);
                     s.setPen(QPen(Qt::black)); // TODO: get from theme
                     s.setBrush(colors.takeFirst());
                     series->update(s);
                 }
             }
             void ChartTheme::decorate(QChartAxis& axis,AxisItem* item)
             {
                 //TODO: dummy defults for now
                 axis.setLabelsBrush(Qt::black);
                 axis.setLabelsPen(Qt::NoPen);
                 item->handleAxisChanged(axis);
             }
             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