HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r512:db1a02a52a65

better use of gradients in barcharts

sauimone -

r512:db1a02a52a65

parent child

Context file:

r512:db1a02a52a65

Collapse all files

examples/percentbarchart/main.cpp +1 0

             #include <QApplication>
             #include <QMainWindow>
             #include <QStandardItemModel>
             #include <qpercentbarseries.h>
             #include <qchartview.h>
             #include <qbarset.h>
             #include <qchartaxis.h>
             #include <QStringList>
             QTCOMMERCIALCHART_USE_NAMESPACE
             int main(int argc, char *argv[])
             {
                 QApplication a(argc, argv);
                 QMainWindow window;
                 //! [1]
                 // Define categories
                 QStringList categories;
                 categories << "Jan" << "Feb" << "Mar" << "Apr" << "May" << "Jun";
                 //! [1]
                 //! [2]
                 // Create some test sets for chat
                 QBarSet *set0 = new QBarSet("Bub");
                 QBarSet *set1 = new QBarSet("Bob");
                 QBarSet *set2 = new QBarSet("Guybrush");
                 QBarSet *set3 = new QBarSet("Larry");
                 QBarSet *set4 = new QBarSet("Zak");
                 *set0 << 1 << 2 << 3 << 4 << 5 << 6;
                 *set1 << 5 << 0 << 0 << 4 << 0 << 7;
                 *set2 << 3 << 5 << 8 << 13 << 8 << 5;
                 *set3 << 5 << 6 << 7 << 3 << 4 << 5;
                 *set4 << 9 << 7 << 5 << 3 << 1 << 2;
                 //! [2]
                 //! [3]
                 // Create series and add sets to it
                 QPercentBarSeries* series = new QPercentBarSeries(categories);
                 series->addBarSet(set0);
                 series->addBarSet(set1);
                 series->addBarSet(set2);
                 series->addBarSet(set3);
                 series->addBarSet(set4);
                 //! [3]
                 //! [4]
                 // Enable tooltip
                 series->setToolTipEnabled();
                 // Connect clicked signal of set to toggle floating values of set.
                 // Note that we leave QBarset "Zak" unconnected here, so clicking on it doesn't toggle values.
                 QObject::connect(set0,SIGNAL(clicked(QString)),set0,SIGNAL(toggleFloatingValues()));
                 QObject::connect(set1,SIGNAL(clicked(QString)),set1,SIGNAL(toggleFloatingValues()));
                 QObject::connect(set2,SIGNAL(clicked(QString)),set2,SIGNAL(toggleFloatingValues()));
                 QObject::connect(set3,SIGNAL(clicked(QString)),set3,SIGNAL(toggleFloatingValues()));
+                QObject::connect(set4,SIGNAL(clicked(QString)),set4,SIGNAL(toggleFloatingValues()));
                 //! [4]
                 //! [5]
                 // Create view for chart and add series to it. Apply theme.
                 QChartView* chartView =  new QChartView(&window);
                 chartView->addSeries(series);
                 chartView->setChartTitle("simple percent barchart");
                 chartView->setChartTheme(QChart::ChartThemeIcy);
                 //! [5]
                 //! [6]
                 chartView->axisX()->setAxisVisible(false);
                 chartView->axisX()->setGridVisible(false);
                 chartView->axisX()->setLabelsVisible(false);
                 //! [6]
                 window.setCentralWidget(chartView);
                 window.resize(400, 300);
                 window.show();
                 return a.exec();
             }

src/barchart/barpresenter.cpp +4 -3

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

src/barchart/barpresenterbase.cpp 0 -1

             #include "barpresenterbase_p.h"
             #include "bar_p.h"
             #include "barvalue_p.h"
             #include "separator_p.h"
             #include "qbarset.h"
             #include "qbarseries.h"
             #include "qchart.h"
             #include "qchartaxis.h"
             #include "qchartaxiscategories.h"
             #include <QDebug>
             #include <QToolTip>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             BarPresenterBase::BarPresenterBase(QBarSeries *series, QChart *parent)
                 : ChartItem(parent)
                 ,mLayoutSet(false)
                 ,mSeries(series)
                 ,mChart(parent)
             {
                 connect(series,SIGNAL(showToolTip(QPoint,QString)),this,SLOT(showToolTip(QPoint,QString)));
                 connect(series,SIGNAL(enableSeparators(bool)),this,SLOT(enableSeparators(bool)));
                 enableSeparators(series->separatorsVisible());
                 initAxisLabels();
                 dataChanged();
             }
             BarPresenterBase::~BarPresenterBase()
             {
                 disconnect(this,SLOT(showToolTip(QPoint,QString)));
                 disconnect(this,SLOT(enableSeparators(bool)));
             }
             void BarPresenterBase::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 if (!mLayoutSet) {
                     qDebug() << "BarPresenterBase::paint called without layout set. Aborting.";
                     return;
                 }
                 foreach(QGraphicsItem* i, childItems()) {
                     i->paint(painter,option,widget);
                 }
             }
             QRectF BarPresenterBase::boundingRect() const
             {
                 return QRectF(0,0,mWidth,mHeight);
             }
             void BarPresenterBase::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;
                 }
                 mBars.clear();
                 mSeparators.clear();
                 mFloatingValues.clear();
                 // Create new graphic items for bars
                 for (int c=0; c<mSeries->categoryCount(); c++) {
                     QString category = mSeries->categoryName(c);
                     for (int s=0; s<mSeries->barsetCount(); s++) {
                         QBarSet *set = mSeries->barsetAt(s);
                         Bar *bar = new Bar(category,this);
                         childItems().append(bar);
                         mBars.append(bar);
                         connect(bar,SIGNAL(clicked(QString)),set,SIGNAL(clicked(QString)));
                         connect(bar,SIGNAL(rightClicked(QString)),set,SIGNAL(rightClicked(QString)));
                         connect(bar,SIGNAL(hoverEntered(QPoint)),set,SLOT(barHoverEnterEvent(QPoint)));
                         connect(bar,SIGNAL(hoverLeaved()),set,SLOT(barHoverLeaveEvent()));
                     }
                 }
                 // Create separators
                 int count = mSeries->categoryCount() - 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
                     sep->setVisible(mSeries->separatorsVisible());
                     childItems().append(sep);
                     mSeparators.append(sep);
                 }
                 // Create floating values
                 for (int category=0; category<mSeries->categoryCount(); category++) {
                     for (int s=0; s<mSeries->barsetCount(); s++) {
                         QBarSet *set = mSeries->barsetAt(s);
                         BarValue *value = new BarValue(*set, this);
                         childItems().append(value);
                         mFloatingValues.append(value);
                         connect(set,SIGNAL(toggleFloatingValues()),value,SLOT(toggleVisible()));
                     }
                 }
             }
             void BarPresenterBase::initAxisLabels()
             {
                 int count = mSeries->categoryCount();
                 if (0 == count) {
                     return;
                 }
                 mChart->axisX()->setTicksCount(count+2);
                 qreal min = 0;
                 qreal max = count+1;
                 mChart->axisX()->setMin(min);
                 mChart->axisX()->setMax(max);
                 QChartAxisCategories* categories = mChart->axisX()->categories();
                 categories->clear();
                 for (int i=0; i<count; i++) {
                     categories->insert(i+1,mSeries->categoryName(i));
                 }
                 mChart->axisX()->setLabelsVisible(true);
             }
             //handlers
             void BarPresenterBase::handleModelChanged(int index)
             {
             //    qDebug() << "BarPresenterBase::handleModelChanged" << index;
                 dataChanged();
             }
             void BarPresenterBase::handleDomainChanged(const Domain& domain)
             {
                 qDebug() << "BarPresenterBase::handleDomainChanged";
                 /*
                 int count = mSeries->categoryCount();
                 if (0 == count) {
                     return;
                 }
                 // Position labels to domain
                 qreal min = domain.minX();
                 qreal max = domain.maxX();
                 qreal step = (max-min)/count;
                 QChartAxisCategories& categories = mChart->axisX()->categories();
                 categories.clear();
                 for (int i=0; i<count; i++) {
                     categories.insert(min,mSeries->categoryName(i));
                     min += step;
                 }
                 */
             }
             void BarPresenterBase::handleGeometryChanged(const QRectF& rect)
             {
                 mWidth = rect.width();
                 mHeight = rect.height();
                 layoutChanged();
                 mLayoutSet = true;
                 setPos(rect.topLeft());
             }
             void BarPresenterBase::showToolTip(QPoint pos, QString tip)
             {
                 // TODO: cool tooltip instead of default
                 QToolTip::showText(pos,tip);
             }
             void BarPresenterBase::enableSeparators(bool enabled)
             {
                 for (int i=0; i<mSeparators.count(); i++) {
                     mSeparators.at(i)->setVisible(enabled);
                 }
             }
             #include "moc_barpresenterbase_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/percentbarpresenter.cpp +3 -3

             #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->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);
-                        // TODO: remove hard coding, apply layout
+                        QBarSet* barSet = mSeries->barsetAt(set);
-                        value->resize(100,50);
+                        value->resize(100,50);  // TODO: proper layout for this.
                         value->setPos(xPos, yPos-barHeight/2);
-                        value->setPen(QPen(QColor(255,255,255,255)));
+                        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/barchart/qbarset.cpp +16 0

             #include "qbarset.h"
             #include <QDebug>
             #include <QToolTip>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QBarSet
                 \brief part of QtCommercial chart API.
                 QBarSet represents one set of bars. Set of bars contains one data value for each category.
                 First value of set is assumed to belong to first category, second to second category and so on.
                 If set has fewer values than there are categories, then the missing values are assumed to be
                 at the end of set. For missing values in middle of a set, numerical value of zero is used.
                 \mainclass
                 \sa QBarSeries, QStackedBarSeries, QPercentBarSeries
             */
             /*!
                 \fn void QBarSet::clicked(QString category)
                 \brief signals that set has been clicked
                 Parameter \a category describes on which category was clicked
             */
             /*!
                 \fn void QBarSet::rightClicked(QString category)
                 \brief signals that set has been clicked with right mouse button
                 Parameter \a category describes on which category was clicked
             */
             /*!
                 \fn void QBarSet::hoverEnter(QPoint pos)
                 \brief signals that mouse has entered over the set at position \a pos.
             */
             /*!
                 \fn void QBarSet::hoverLeave()
                 \brief signals that mouse has left from the set.
             */
             /*!
                 \fn void QBarSet::toggleFloatingValues()
                 \brief \internal
             */
             /*!
                 \fn void QBarSet::showToolTip(QPoint pos, QString tip)
                 \brief \internal \a pos \a tip
             */
             /*!
                 Constructs QBarSet with a name of \a name and with parent of \a parent
             */
             QBarSet::QBarSet(QString name, QObject *parent)
                 : QObject(parent)
                 ,mName(name)
             {
             }
             /*!
                 Sets new \a name for set.
             */
             void QBarSet::setName(QString name)
             {
                 mName = name;
             }
             /*!
                 Returns name of the set.
             */
             QString QBarSet::name()
             {
                 return mName;
             }
             /*!
                 Appends new value \a value to the end of set.
             */
             QBarSet& QBarSet::operator << (const qreal &value)
             {
                 mValues.append(value);
                 return *this;
             }
             /*!
                 Returns count of values in set.
             */
             int QBarSet::count()
             {
                 return mValues.count();
             }
             /*!
                 Returns value of set indexed by \a index
             */
             qreal QBarSet::valueAt(int index)
             {
                 return mValues.at(index);
             }
             /*!
                 Sets a new value \a value to set, indexed by \a index
             */
             void QBarSet::setValue(int index, qreal value)
             {
                 mValues.replace(index,value);
             }
             /*!
                 Returns total sum of all values in barset.
             */
             qreal QBarSet::total()
             {
                 qreal total(0);
                 for (int i=0; i<mValues.count(); i++) {
                     total += mValues.at(i);
                 }
                 return total;
             }
             /*!
                 Sets pen for set. Bars of this set are drawn using \a pen
             */
             void QBarSet::setPen(const QPen pen)
             {
                 mPen = pen;
             }
             /*!
                 Returns pen of the set.
             */
             QPen QBarSet::pen() const
             {
                 return mPen;
             }
             /*!
                 Sets brush for the set. Bars of this set are drawn using \a brush
             */
             void QBarSet::setBrush(const QBrush brush)
             {
                 mBrush = brush;
             }
             /*!
                 Returns brush of the set.
             */
             QBrush QBarSet::brush() const
             {
                 return mBrush;
             }
             /*!
+                Sets the pen for floating values that are drawn on top of this set
+            */
+            void QBarSet::setFloatingValuePen(const QPen pen)
+            {
+                mFloatingValuePen = pen;
+            }
+            /*!
+                Returns the pen for floating values that are drawn on top of this set
+            */
+            QPen QBarSet::floatingValuePen() const
+            {
+                return mFloatingValuePen;
+            }
+            /*!
                 \internal \a pos
             */
             void QBarSet::barHoverEnterEvent(QPoint pos)
             {
                 emit showToolTip(pos, mName);
                 emit hoverEnter(pos);
             }
             /*!
                 \internal
             */
             void QBarSet::barHoverLeaveEvent()
             {
                 // Emit signal to user of charts
                 emit hoverLeave();
             }
             #include "moc_qbarset.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/qbarset.h +4 -1

             #ifndef QBARSET_H
             #define QBARSET_H
             #include <qchartglobal.h>
             #include <QPen>
             #include <QBrush>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QTCOMMERCIALCHART_EXPORT QBarSet : public QObject
             {
                 Q_OBJECT
             public:
                 QBarSet(QString name, QObject *parent = 0);
                 void setName(QString name);
                 QString name();
                 QBarSet& operator << (const qreal &value);  // appends new value to set
                 // TODO: remove indices eventually. Use as internal?
                 int count();                                // count of values in set
                 qreal valueAt(int index);                   // for modifying individual values
                 void setValue(int index, qreal value);      // setter for individual value
                 qreal total();                              // total values in the set
                 // TODO:
                 //qreal value(QString category);
                 //void setValue(QString category, qreal value);
                 void setPen(const QPen pen);
                 QPen pen() const;
                 void setBrush(const QBrush brush);
                 QBrush brush() const;
+                void setFloatingValuePen(const QPen pen);
+                QPen floatingValuePen() const;
             Q_SIGNALS:
                 void clicked(QString category);                         // Clicked and hover signals exposed to user
                 void rightClicked(QString category);
                 void toggleFloatingValues();
                 // TODO: Expose this to user or not?
                 // TODO: TO PIMPL --->
                 void hoverEnter(QPoint pos);
                 void hoverLeave();
                 void showToolTip(QPoint pos, QString tip);  // Private signal
                 // <--- TO PIMPL
             public Q_SLOTS:
                 // These are for internal communication
                 // TODO: TO PIMPL --->
                 void barHoverEnterEvent(QPoint pos);
                 void barHoverLeaveEvent();
                 // <--- TO PIMPL
             private:
                 QString mName;
                 QList<qreal> mValues;   // TODO: replace with map (category, value)
                 QMap<QString,qreal> mMappedValues;
                 QPen mPen;
                 QBrush mBrush;
+                QPen mFloatingValuePen;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QBARSET_H

src/barchart/stackedbarpresenter.cpp +3 -3

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

src/charttheme.cpp +24 0

             #include "charttheme_p.h"
             #include "qchart.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 "piepresenter_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"
             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();
                     default:
                         return new ChartThemeDefault();
                 }
             }
             void ChartTheme::decorate(QChart* chart)
             {
                 chart->setChartBackgroundBrush(m_backgroundGradient);
             }
             //TODO helper to by removed later
             void ChartTheme::decorate(ChartItem* item, QSeries* series,int count)
             {
                 switch(series->type())
                 {
                     case QSeries::SeriesTypeLine: {
                         QLineSeries* s = static_cast<QLineSeries*>(series);
                         LineChartItem* i = static_cast<LineChartItem*>(item);
                         decorate(i,s,count);
                         break;
                     }
                     case QSeries::SeriesTypeArea: {
                                QAreaSeries* s = static_cast<QAreaSeries*>(series);
                                AreaChartItem* i = static_cast<AreaChartItem*>(item);
                                decorate(i,s,count);
                                break;
                     }
                     case QSeries::SeriesTypeBar: {
                         QBarSeries* b = static_cast<QBarSeries*>(series);
                         BarPresenter* i = static_cast<BarPresenter*>(item);
                         decorate(i,b,count);
                         break;
                     }
                     case QSeries::SeriesTypeStackedBar: {
                         QStackedBarSeries* s = static_cast<QStackedBarSeries*>(series);
                         StackedBarPresenter* i = static_cast<StackedBarPresenter*>(item);
                         decorate(i,s,count);
                         break;
                     }
                     case QSeries::SeriesTypePercentBar: {
                         QPercentBarSeries* s = static_cast<QPercentBarSeries*>(series);
                         PercentBarPresenter* i = static_cast<PercentBarPresenter*>(item);
                         decorate(i,s,count);
                         break;
                     }
                     case QSeries::SeriesTypeScatter: {
                         QScatterSeries* s = qobject_cast<QScatterSeries*>(series);
                         Q_ASSERT(s);
                         ScatterChartItem* i = static_cast<ScatterChartItem*>(item);
                         Q_ASSERT(i);
                         decorate(i, s, count);
                         break;
                     }
                     case QSeries::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(AreaChartItem* item, QAreaSeries* series,int count)
             {
                 QPen pen;
                 QBrush brush;
                 if(pen != series->pen()){
                    item->setPen(series->pen());
                 }else{
                     pen.setColor(m_seriesColors.at(count%m_seriesColors.size()));
                     pen.setWidthF(2);
                     item->setPen(pen);
                 }
                 if(brush != series->brush()){
                    item->setBrush(series->brush());
                 }else{
                    QBrush brush(m_seriesColors.at(count%m_seriesColors.size()));
                    item->setBrush(brush);
                 }
             }
             void ChartTheme::decorate(LineChartItem* item, QLineSeries* series,int count)
             {
                 QPen pen;
                 if(pen != series->pen()){
                     item->setLinePen(series->pen());
                     return;
                 }
                 pen.setColor(m_seriesColors.at(count%m_seriesColors.size()));
                 pen.setWidthF(2);
                 item->setLinePen(pen);
             }
             void ChartTheme::decorate(BarPresenter* item, QBarSeries* series,int count)
             {
                 QList<QBarSet*> sets = series->barSets();
                 for (int i=0; i<sets.count(); i++) {
                     qreal pos = (qreal) i / (qreal) sets.count();
                     QColor c = colorAt(m_seriesGradients.at(count % 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(count % m_seriesGradients.size()), 1);
+                    } else {
+                        c = colorAt(m_seriesGradients.at(count % m_seriesGradients.size()), 0);
+                    }
+                    sets.at(i)->setFloatingValuePen(QPen(c));
                 }
             }
             void ChartTheme::decorate(StackedBarPresenter* item, QStackedBarSeries* series,int count)
             {
                 QList<QBarSet*> sets = series->barSets();
                 for (int i=0; i<sets.count(); i++) {
                     qreal pos = (qreal) i / (qreal) sets.count();
                     QColor c = colorAt(m_seriesGradients.at(count % m_seriesGradients.size()), pos);
                     sets.at(i)->setBrush(QBrush(c));
+                    if (pos < 0.3) {
+                        c = colorAt(m_seriesGradients.at(count % m_seriesGradients.size()), 1);
+                    } else {
+                        c = colorAt(m_seriesGradients.at(count % m_seriesGradients.size()), 0);
+                    }
+                    sets.at(i)->setFloatingValuePen(QPen(c));
                 }
             }
             void ChartTheme::decorate(PercentBarPresenter* item, QPercentBarSeries* series,int count)
             {
                 QList<QBarSet*> sets = series->barSets();
                 for (int i=0; i<sets.count(); i++) {
                     qreal pos = (qreal) i / (qreal) sets.count();
                     QColor c = colorAt(m_seriesGradients.at(count % m_seriesGradients.size()), pos);
                     sets.at(i)->setBrush(QBrush(c));
+                    if (pos < 0.3) {
+                        c = colorAt(m_seriesGradients.at(count % m_seriesGradients.size()), 1);
+                    } else {
+                        c = colorAt(m_seriesGradients.at(count % m_seriesGradients.size()), 0);
+                    }
+                    sets.at(i)->setFloatingValuePen(QPen(c));
                 }
             }
             void ChartTheme::decorate(ScatterChartItem* item, QScatterSeries* series, int count)
             {
                 Q_ASSERT(item);
                 Q_ASSERT(series);
                 QColor color = m_seriesColors.at(count % m_seriesColors.size());
                 // TODO: define alpha in the theme? or in the series?
                 //color.setAlpha(120);
                 QBrush brush(color, Qt::SolidPattern);
                 item->setBrush(Qt::blue);
                 QPen pen(brush, 3);
                 pen.setColor(color);
                 item->setPen(pen);
             }
             void ChartTheme::decorate(PiePresenter* item, QPieSeries* series, int count)
             {
                 // 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(count % m_seriesGradients.size()), 0.1);
                     series->slices().at(i)->setSlicePen(penColor);
                     QColor brushColor = colorAt(m_seriesGradients.at(count % m_seriesGradients.size()), pos);
                     series->slices().at(i)->setSliceBrush(brushColor);
                 }
             }
             void ChartTheme::decorate(QChartAxis* axis, AxisItem* item)
             {
                 //TODO: dummy defults for now
                 axis->setLabelsBrush(Qt::black);
                 axis->setLabelsPen(Qt::NoPen);
                 axis->setShadesPen(Qt::NoPen);
                 axis->setShadesOpacity(0.5);
             }
             void ChartTheme::decorate(SplineChartItem* item, QSplineSeries* series, int count)
             {
                 Q_ASSERT(item);
                 Q_ASSERT(series);
                 QPen pen;
                 if(pen != series->pen()){
                     item->setLinePen(series->pen());
                 }else{
                     pen.setColor(m_seriesColors.at(count%m_seriesColors.size()));
                     pen.setWidthF(series->pen().widthF());
                     item->setLinePen(series->pen());
                 }
             //    QColor color = m_seriesColors.at(count % m_seriesColors.size());
                 // TODO: define alpha in the theme? or in the series?
                 //color.setAlpha(120);
             //    QBrush brush(color, Qt::SolidPattern);
             //    presenter->m_markerBrush = brush;
             //    QPen pen(brush, 3);
             //    pen.setColor(color);
             //    presenter->m_markerPen = pen;
             }
             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

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