HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r776:2e4d7bdf36a4

const to getters, renamed addBarset to appendBarset

sauimone -

r776:2e4d7bdf36a4

parent child

Context file:

r776:2e4d7bdf36a4

Collapse all files

demos/chartthemes/themewidget.cpp +1 -1

             /****************************************************************************
              **
              ** Copyright (C) 2012 Digia Plc
              ** All rights reserved.
              ** For any questions to Digia, please use contact form at http://qt.digia.com
              **
              ** This file is part of the Qt Commercial Charts Add-on.
              **
              ** $QT_BEGIN_LICENSE:BSD$
              ** You may use this file under the terms of the BSD license as follows:
              **
              ** "Redistribution and use in source and binary forms, with or without
              ** modification, are permitted provided that the following conditions are
              ** met:
              **   * Redistributions of source code must retain the above copyright
              **     notice, this list of conditions and the following disclaimer.
              **   * Redistributions in binary form must reproduce the above copyright
              **     notice, this list of conditions and the following disclaimer in
              **     the documentation and/or other materials provided with the
              **     distribution.
              **   * Neither the name of Digia nor the names of its contributors
              **     may be used to endorse or promote products derived from this
              **     software without specific prior written permission.
              **
              ** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
              ** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
              ** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
              ** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
              ** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
              ** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
              ** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
              ** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
              ** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
              ** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
              ** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
              ** $QT_END_LICENSE$
              **
              ** Copyright (c) 2011 Nokia Corporation and/or its subsidiary(-ies).
              **
              ****************************************************************************/
             #include "themewidget.h"
             #include <QChartView>
             #include <QPieSeries>
             #include <QPieSlice>
             #include <QBarSeries>
             #include <QPercentBarSeries>
             #include <QStackedBarSeries>
             #include <QBarSet>
             #include <QLineSeries>
             #include <QSplineSeries>
             #include <QScatterSeries>
             #include <QAreaSeries>
             #include <QGridLayout>
             #include <QFormLayout>
             #include <QComboBox>
             #include <QSpinBox>
             #include <QCheckBox>
             #include <QGroupBox>
             #include <QLabel>
             #include <QTime>
             ThemeWidget::ThemeWidget(QWidget* parent) :
                 QWidget(parent),
                 m_listCount(3),
                 m_valueMax(100),
                 m_valueCount(11),
                 m_dataTable(generateRandomData(m_listCount,m_valueMax,m_valueCount)),
                 m_themeComboBox(createThemeBox()),
                 m_antialiasCheckBox(new QCheckBox("Anti aliasing")),
                 m_animatedComboBox(createAnimationBox())
             {
                 connectSignals();
                 // create layout
                 QGridLayout* baseLayout = new QGridLayout();
                 QHBoxLayout *settingsLayout = new QHBoxLayout();
                 settingsLayout->addWidget(new QLabel("Theme:"));
                 settingsLayout->addWidget(m_themeComboBox);
                 settingsLayout->addWidget(new QLabel("Animation:"));
                 settingsLayout->addWidget(m_animatedComboBox);
                 settingsLayout->addWidget(m_antialiasCheckBox);
                 settingsLayout->addStretch();
                 baseLayout->addLayout(settingsLayout, 0, 0, 1, 3);
                 //create charts
                 QChartView *chartView;
                 chartView = new QChartView(createAreaChart());
                 baseLayout->addWidget(chartView, 1, 0);
                 m_charts << chartView;
                 chartView = new QChartView(createBarChart(m_valueCount));
                 baseLayout->addWidget(chartView, 1, 1);
                 m_charts << chartView;
                 chartView = new QChartView(createLineChart());
                 baseLayout->addWidget(chartView, 1, 2);
                 m_charts << chartView;
                 chartView = new QChartView(createPieChart());
                 chartView->setSizePolicy(QSizePolicy::Ignored, QSizePolicy::Ignored); // funny things happen if the pie slice labels no not fit the screen...
                 baseLayout->addWidget(chartView, 2, 0);
                 m_charts << chartView;
                 chartView = new QChartView(createSplineChart());
                 baseLayout->addWidget(chartView, 2, 1);
                 m_charts << chartView;
                 chartView = new QChartView(createScatterChart());
                 baseLayout->addWidget(chartView, 2, 2);
                 m_charts << chartView;
                 setLayout(baseLayout);
             }
             ThemeWidget::~ThemeWidget()
             {
             }
             void ThemeWidget::connectSignals()
             {
                 connect(m_themeComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(updateUI()));
                 connect(m_antialiasCheckBox, SIGNAL(toggled(bool)), this, SLOT(updateUI()));
                 connect(m_animatedComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(updateUI()));
             }
             DataTable ThemeWidget::generateRandomData(int listCount,int valueMax,int valueCount) const
             {
                 DataTable dataTable;
                 // set seed for random stuff
                 qsrand(QTime(0, 0, 0).secsTo(QTime::currentTime()));
                 // generate random data
                 for (int i(0); i < listCount; i++) {
                     DataList dataList;
                     for (int j(0); j < valueCount; j++) {
                         QPointF value(j + (qreal) rand() / (qreal) RAND_MAX, qrand() % valueMax);
                         QString label = "Item " + QString::number(i) + ":" + QString::number(j);
                         dataList << Data(value, label);
                     }
                     dataTable << dataList;
                 }
                 return dataTable;
             }
             QComboBox* ThemeWidget::createThemeBox() const
             {
                 // settings layout
                 QComboBox* themeComboBox = new QComboBox();
                 themeComboBox->addItem("Default", QChart::ChartThemeDefault);
                 themeComboBox->addItem("Light", QChart::ChartThemeLight);
                 themeComboBox->addItem("Blue Cerulean", QChart::ChartThemeBlueCerulean);
                 themeComboBox->addItem("Dark", QChart::ChartThemeDark);
                 themeComboBox->addItem("Brown Sand", QChart::ChartThemeBrownSand);
                 themeComboBox->addItem("Blue NCS", QChart::ChartThemeBlueNcs);
                 themeComboBox->addItem("High Contrast", QChart::ChartThemeHighContrast);
                 themeComboBox->addItem("Blue Icy", QChart::ChartThemeBlueIcy);
                 return themeComboBox;
             }
             QComboBox* ThemeWidget::createAnimationBox() const
             {
                 // settings layout
                 QComboBox* animationComboBox = new QComboBox();
                 animationComboBox->addItem("No Animations", QChart::NoAnimation);
                 animationComboBox->addItem("GridAxis Animations", QChart::GridAxisAnimations);
                 animationComboBox->addItem("Series Animations", QChart::SeriesAnimations);
                 animationComboBox->addItem("All Animations", QChart::AllAnimations);
                 return animationComboBox;
             }
             QChart* ThemeWidget::createAreaChart() const
             {
                 // area chart
                 QChart *chart = new QChart();
                 chart->setTitle("Area chart");
                 {
                     for (int i(0); i < m_dataTable.count(); i++) {
                         QLineSeries *series1 = new QLineSeries(chart);
                         QLineSeries *series2 = new QLineSeries(chart);
                         foreach (Data data, m_dataTable[i]) {
                             series1->add(data.first);
                             series2->add(QPointF(data.first.x(), 0.0));
                         }
                         QAreaSeries *area = new QAreaSeries(series1, series2);
                         chart->addSeries(area);
                     }
                 }
                 return chart;
             }
             QChart* ThemeWidget::createBarChart(int valueCount) const
             {
                 // bar chart
                 QChart* chart = new QChart();
                 chart->setTitle("Bar chart");
                 {
                     QBarCategories categories;
                     // TODO: categories
                     for (int i(0); i < valueCount; i++)
                         categories << QString::number(i);
             //            QBarSeries* series = new QBarSeries(categories, chart);
             //            QPercentBarSeries* series = new QPercentBarSeries(categories, chart);
                     QStackedBarSeries* series = new QStackedBarSeries(categories, chart);
                     for (int i(0); i < m_dataTable.count(); i++) {
                         QBarSet *set = new QBarSet("Set" + QString::number(i));
                         foreach (Data data, m_dataTable[i])
                             *set << data.first.y();
-                        series->addBarSet(set);
+                        series->appendBarSet(set);
                     }
                     chart->addSeries(series);
                 }
                 return chart;
             }
             QChart* ThemeWidget::createLineChart() const
             {
                 // line chart
                 QChart* chart = new QChart();
                 chart->setTitle("Line chart");
                 foreach (DataList list, m_dataTable) {
                     QLineSeries *series = new QLineSeries(chart);
                     foreach (Data data, list)
                         series->add(data.first);
                     chart->addSeries(series);
                 }
                 return chart;
             }
             QChart* ThemeWidget::createPieChart() const
             {
                 // pie chart
                 QChart* chart = new QChart();
                 chart->setTitle("Pie chart");
                 qreal pieSize = 1.0 / m_dataTable.count();
                 for (int i = 0; i < m_dataTable.count(); i++) {
                     QPieSeries *series = new QPieSeries(chart);
                     foreach (Data data, m_dataTable[i]) {
                         QPieSlice *slice = series->add(data.first.y(), data.second);
                         if (data == m_dataTable[i].first()) {
                             slice->setLabelVisible();
                             slice->setExploded();
                         }
                     }
                     qreal hPos = (pieSize / 2) + (i / (qreal) m_dataTable.count());
                     series->setPieSize(pieSize);
                     series->setPiePosition(hPos, 0.5);
                     chart->addSeries(series);
                 }
                 return chart;
             }
             QChart* ThemeWidget::createSplineChart() const
             { // spine chart
                 QChart* chart = new QChart();
                 chart->setTitle("Spline chart");
                 foreach (DataList list, m_dataTable) {
                     QSplineSeries *series = new QSplineSeries(chart);
                     foreach (Data data, list)
                         series->add(data.first);
                     chart->addSeries(series);
                 }
                 return chart;
             }
             QChart* ThemeWidget::createScatterChart() const
             { // scatter chart
                 QChart* chart = new QChart();
                 chart->setTitle("Scatter chart");
                 foreach (DataList list, m_dataTable) {
                     QScatterSeries *series = new QScatterSeries(chart);
                     foreach (Data data, list)
                         series->add(data.first);
                     chart->addSeries(series);
                 }
                 return chart;
             }
             void ThemeWidget::updateUI()
             {
                 QChart::ChartTheme theme = (QChart::ChartTheme) m_themeComboBox->itemData(m_themeComboBox->currentIndex()).toInt();
                 if (m_charts.at(0)->chart()->theme() != theme) {
                     foreach (QChartView *chartView, m_charts)
                         chartView->chart()->setTheme(theme);
                     QPalette pal = window()->palette();
                     if (theme == QChart::ChartThemeLight) {
                         pal.setColor(QPalette::Window, QRgb(0xf0f0f0));
                         pal.setColor(QPalette::WindowText, QRgb(0x404044));
                     } else if (theme == QChart::ChartThemeDark) {
                         pal.setColor(QPalette::Window, QRgb(0x121218));
                         pal.setColor(QPalette::WindowText, QRgb(0xd6d6d6));
                     } else if (theme == QChart::ChartThemeBlueCerulean) {
                         pal.setColor(QPalette::Window, QRgb(0x40434a));
                         pal.setColor(QPalette::WindowText, QRgb(0xd6d6d6));
                     } else if (theme == QChart::ChartThemeBrownSand) {
                         pal.setColor(QPalette::Window, QRgb(0x9e8965));
                         pal.setColor(QPalette::WindowText, QRgb(0x404044));
                     } else if (theme == QChart::ChartThemeBlueNcs) {
                         pal.setColor(QPalette::Window, QRgb(0x018bba));
                         pal.setColor(QPalette::WindowText, QRgb(0x404044));
                     } else if (theme == QChart::ChartThemeHighContrast) {
                         pal.setColor(QPalette::Window, QRgb(0xffab03));
                         pal.setColor(QPalette::WindowText, QRgb(0x181818));
                     } else if (theme == QChart::ChartThemeBlueIcy) {
                         pal.setColor(QPalette::Window, QRgb(0xcee7f0));
                         pal.setColor(QPalette::WindowText, QRgb(0x404044));
                     } else {
                         pal.setColor(QPalette::Window, QRgb(0xf0f0f0));
                         pal.setColor(QPalette::WindowText, QRgb(0x404044));
                     }
                     window()->setPalette(pal);
                 }
                 bool checked = m_antialiasCheckBox->isChecked();
                 foreach (QChartView *chart, m_charts)
                     chart->setRenderHint(QPainter::Antialiasing, checked);
                 QChart::AnimationOptions options(m_animatedComboBox->itemData(m_animatedComboBox->currentIndex()).toInt());
                 if (m_charts.at(0)->chart()->animationOptions() != options) {
                     foreach (QChartView *chartView, m_charts)
                         chartView->chart()->setAnimationOptions(options);
                 }
             }

examples/barchart/main.cpp +5 -5

             /****************************************************************************
              **
              ** Copyright (C) 2012 Digia Plc
              ** All rights reserved.
              ** For any questions to Digia, please use contact form at http://qt.digia.com
              **
              ** This file is part of the Qt Commercial Charts Add-on.
              **
              ** $QT_BEGIN_LICENSE:BSD$
              ** You may use this file under the terms of the BSD license as follows:
              **
              ** "Redistribution and use in source and binary forms, with or without
              ** modification, are permitted provided that the following conditions are
              ** met:
              **   * Redistributions of source code must retain the above copyright
              **     notice, this list of conditions and the following disclaimer.
              **   * Redistributions in binary form must reproduce the above copyright
              **     notice, this list of conditions and the following disclaimer in
              **     the documentation and/or other materials provided with the
              **     distribution.
              **   * Neither the name of Digia nor the names of its contributors
              **     may be used to endorse or promote products derived from this
              **     software without specific prior written permission.
              **
              ** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
              ** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
              ** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
              ** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
              ** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
              ** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
              ** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
              ** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
              ** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
              ** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
              ** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
              ** $QT_END_LICENSE$
              **
              ** Copyright (c) 2011 Nokia Corporation and/or its subsidiary(-ies).
              **
              ****************************************************************************/
             #include <QApplication>
             #include <QMainWindow>
             #include <QChartView>
             #include <QBarSeries>
             #include <QBarSet>
             QTCOMMERCIALCHART_USE_NAMESPACE
             int main(int argc, char *argv[])
             {
                 QApplication a(argc, argv);
             //![1]
                 QBarCategories categories;
                 categories << "Jan" << "Feb" << "Mar" << "Apr" << "May" << "Jun";
             //![1]
             //![2]
                 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]
                 QBarSeries* series = new QBarSeries(categories);
-                series->addBarSet(set0);
+                series->appendBarSet(set0);
-                series->addBarSet(set1);
+                series->appendBarSet(set1);
-                series->addBarSet(set2);
+                series->appendBarSet(set2);
-                series->addBarSet(set3);
+                series->appendBarSet(set3);
-                series->addBarSet(set4);
+                series->appendBarSet(set4);
             //![3]
             //![4]
                 QChart* chart = new QChart();
                 chart->addSeries(series);
                 chart->setTitle("Simple barchart example");
             //![4]
             //![5]
                 QChartView* chartView = new QChartView(chart);
                 chartView->setRenderHint(QPainter::Antialiasing);
             //![5]
             //![6]
                 QMainWindow window;
                 window.setCentralWidget(chartView);
                 window.resize(400, 300);
                 window.show();
             //![6]
                 return a.exec();
             }

examples/percentbarchart/main.cpp +5 -5

             /****************************************************************************
              **
              ** Copyright (C) 2012 Digia Plc
              ** All rights reserved.
              ** For any questions to Digia, please use contact form at http://qt.digia.com
              **
              ** This file is part of the Qt Commercial Charts Add-on.
              **
              ** $QT_BEGIN_LICENSE:BSD$
              ** You may use this file under the terms of the BSD license as follows:
              **
              ** "Redistribution and use in source and binary forms, with or without
              ** modification, are permitted provided that the following conditions are
              ** met:
              **   * Redistributions of source code must retain the above copyright
              **     notice, this list of conditions and the following disclaimer.
              **   * Redistributions in binary form must reproduce the above copyright
              **     notice, this list of conditions and the following disclaimer in
              **     the documentation and/or other materials provided with the
              **     distribution.
              **   * Neither the name of Digia nor the names of its contributors
              **     may be used to endorse or promote products derived from this
              **     software without specific prior written permission.
              **
              ** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
              ** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
              ** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
              ** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
              ** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
              ** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
              ** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
              ** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
              ** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
              ** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
              ** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
              ** $QT_END_LICENSE$
              **
              ** Copyright (c) 2011 Nokia Corporation and/or its subsidiary(-ies).
              **
              ****************************************************************************/
             #include <QApplication>
             #include <QMainWindow>
             #include <QChartView>
             #include <QPercentBarSeries>
             #include <QBarSet>
             QTCOMMERCIALCHART_USE_NAMESPACE
             int main(int argc, char *argv[])
             {
                 QApplication a(argc, argv);
             //![1]
                 QBarCategories categories;
                 categories << "Jan" << "Feb" << "Mar" << "Apr" << "May" << "Jun";
             //![1]
             //![2]
                 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]
                 QPercentBarSeries* series = new QPercentBarSeries(categories);
-                series->addBarSet(set0);
+                series->appendBarSet(set0);
-                series->addBarSet(set1);
+                series->appendBarSet(set1);
-                series->addBarSet(set2);
+                series->appendBarSet(set2);
-                series->addBarSet(set3);
+                series->appendBarSet(set3);
-                series->addBarSet(set4);
+                series->appendBarSet(set4);
             //![3]
             //![4]
                 QChart* chart = new QChart();
                 chart->addSeries(series);
                 chart->setTitle("Simple precentbarchart example");
             //![4]
             //![5]
                 QChartView* chartView = new QChartView(chart);
                 chartView->setRenderHint(QPainter::Antialiasing);
             //![5]
             //![6]
                 QMainWindow window;
                 window.setCentralWidget(chartView);
                 window.resize(400, 300);
                 window.show();
             //![6]
                 return a.exec();
             }

examples/stackedbarchart/main.cpp +5 -5

             /****************************************************************************
              **
              ** Copyright (C) 2012 Digia Plc
              ** All rights reserved.
              ** For any questions to Digia, please use contact form at http://qt.digia.com
              **
              ** This file is part of the Qt Commercial Charts Add-on.
              **
              ** $QT_BEGIN_LICENSE:BSD$
              ** You may use this file under the terms of the BSD license as follows:
              **
              ** "Redistribution and use in source and binary forms, with or without
              ** modification, are permitted provided that the following conditions are
              ** met:
              **   * Redistributions of source code must retain the above copyright
              **     notice, this list of conditions and the following disclaimer.
              **   * Redistributions in binary form must reproduce the above copyright
              **     notice, this list of conditions and the following disclaimer in
              **     the documentation and/or other materials provided with the
              **     distribution.
              **   * Neither the name of Digia nor the names of its contributors
              **     may be used to endorse or promote products derived from this
              **     software without specific prior written permission.
              **
              ** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
              ** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
              ** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
              ** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
              ** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
              ** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
              ** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
              ** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
              ** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
              ** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
              ** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
              ** $QT_END_LICENSE$
              **
              ** Copyright (c) 2011 Nokia Corporation and/or its subsidiary(-ies).
              **
              ****************************************************************************/
             #include <QApplication>
             #include <QMainWindow>
             #include <QChartView>
             #include <QStackedBarSeries>
             #include <QBarSet>
             QTCOMMERCIALCHART_USE_NAMESPACE
             int main(int argc, char *argv[])
             {
                 QApplication a(argc, argv);
             //![1]
                 QBarCategories categories;
                 categories << "Jan" << "Feb" << "Mar" << "Apr" << "May" << "Jun";
             //![1]
             //![2]
                 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]
                 QStackedBarSeries* series = new QStackedBarSeries(categories);
-                series->addBarSet(set0);
+                series->appendBarSet(set0);
-                series->addBarSet(set1);
+                series->appendBarSet(set1);
-                series->addBarSet(set2);
+                series->appendBarSet(set2);
-                series->addBarSet(set3);
+                series->appendBarSet(set3);
-                series->addBarSet(set4);
+                series->appendBarSet(set4);
             //![3]
             //![4]
                 QChart* chart = new QChart();
                 chart->addSeries(series);
                 chart->setTitle("Simple stackedbarchart example");
             //![4]
             //![5]
                 QChartView* chartView = new QChartView(chart);
                 chartView->setRenderHint(QPainter::Antialiasing);
             //![5]
             //![6]
                 QMainWindow window;
                 window.setCentralWidget(chartView);
                 window.resize(400, 300);
                 window.show();
             //![6]
                 return a.exec();
             }

qmlplugin/declarativebarseries.cpp +3 -3

             #include "declarativebarseries.h"
             #include "declarativechart.h"
             #include "qchart.h"
             #include "qbarseries.h"
             #include "qbarset.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             DeclarativeBarSeries::DeclarativeBarSeries(QDeclarativeItem *parent) :
                 QDeclarativeItem(parent)
             {
                 setFlag(QGraphicsItem::ItemHasNoContents, false);
             }
             void DeclarativeBarSeries::componentComplete()
             {
                 if (!m_series) {
                     DeclarativeChart *declarativeChart = qobject_cast<DeclarativeChart *>(parent());
                     if (declarativeChart) {
                         QChart *chart = qobject_cast<QChart *>(declarativeChart->m_chart);
                         Q_ASSERT(chart);
             //            QStringList categories;
             //            categories << "Jan" << "Feb" << "Mar" << "Apr" << "May" << "Jun";
             //            m_series = new QBarSeries(categories);
             //            m_series = new QBarSeries(m_categories);
                         m_series = new QBarSeries(m_categories);
                         // TODO: use data from model
                         QBarSet *set0 = new QBarSet("Bub");
                         QBarSet *set1 = new QBarSet("Bob");
                         QBarSet *set2 = new QBarSet("Guybrush");
                         *set0 << 1 << 2 << 3 << 4 << 5 << 6;
                         *set1 << 5 << 0 << 0 << 4 << 0 << 7;
                         *set2 << 3 << 5 << 8 << 13 << 8 << 5;
-                        m_series->addBarSet(set0);
+                        m_series->appendBarSet(set0);
-                        m_series->addBarSet(set1);
+                        m_series->appendBarSet(set1);
-                        m_series->addBarSet(set2);
+                        m_series->appendBarSet(set2);
                         chart->addSeries(m_series);
                     }
                 }
             }
             void DeclarativeBarSeries::setBarCategories(QStringList categories)
             {
                 m_categories = categories;
                 if (m_series) {
                     // Replace categories of the QBarSeries with the new categories
                     for (int i(0); i < m_categories.count(); i++) {
                         if (m_series->categories().at(i) != m_categories.at(i))
                             m_series->insertCategory(m_series->categoryCount(), m_categories.at(i));
                     }
                     while (m_series->categoryCount() > m_categories.count())
                         m_series->removeCategory(m_series->categoryCount() - 1);
                 }
             }
             QStringList DeclarativeBarSeries::barCategories()
             {
                 return m_categories;
             }
             #include "moc_declarativebarseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/barchartitem.cpp +2 -2

             #include "barchartitem_p.h"
             #include "bar_p.h"
             #include "barvalue_p.h"
             #include "qbarset.h"
             #include "qbarseries.h"
             #include "qchart.h"
             #include "qchartaxis.h"
             #include "qchartaxiscategories.h"
             #include "chartpresenter_p.h"
             #include "chartanimator_p.h"
             #include "chartdataset_p.h"
             #include <QDebug>
             #include <QToolTip>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             BarChartItem::BarChartItem(QBarSeries *series, ChartPresenter *presenter) :
                 ChartItem(presenter),
                 m_layoutSet(false),
                 m_series(series)
             {
                 connect(series, SIGNAL(showToolTip(QPoint,QString)), this, SLOT(showToolTip(QPoint,QString)));
                 connect(series, SIGNAL(updatedBars()), this, SLOT(handleLayoutChanged()));
             //TODO:  connect(series,SIGNAL("position or size has changed"), this, SLOT(handleLayoutChanged()));
                 connect(series, SIGNAL(restructuredBar(int)), this, SLOT(handleModelChanged(int)));
                 setZValue(ChartPresenter::BarSeriesZValue);
                 dataChanged();
             }
             BarChartItem::~BarChartItem()
             {
                 disconnect(this,SLOT(showToolTip(QPoint,QString)));
             }
             void BarChartItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 if (!m_layoutSet) {
                     qWarning() << "BarChartItem::paint called without layout set. Aborting.";
                     return;
                 }
                 foreach(QGraphicsItem* i, childItems())
                     i->paint(painter,option,widget);
             }
             QRectF BarChartItem::boundingRect() const
             {
                 return m_rect;
             }
             void BarChartItem::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;
                 m_bars.clear();
                 m_floatingValues.clear();
                 m_layout.clear();
                 // Create new graphic items for bars
                 for (int c = 0; c < m_series->categoryCount(); c++) {
                     QString category = m_series->categoryName(c);
                     for (int s = 0; s < m_series->barsetCount(); s++) {
                         QBarSet *set = m_series->barsetAt(s);
                         Bar *bar = new Bar(category,this);
                         childItems().append(bar);
                         m_bars.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()));
                         m_layout.append(QRectF(0, 0, 0, 0));
                     }
                 }
                 // Create floating values
                 for (int category = 0; category < m_series->categoryCount(); category++) {
                     for (int s = 0; s < m_series->barsetCount(); s++) {
                         QBarSet *set = m_series->barsetAt(s);
                         BarValue *value = new BarValue(*set, this);
                         childItems().append(value);
                         m_floatingValues.append(value);
                         connect(set, SIGNAL(toggleFloatingValues()), value, SLOT(toggleVisible()));
                     }
                 }
             }
             QVector<QRectF> BarChartItem::calculateLayout()
             {
                 QVector<QRectF> layout;
                 // Use temporary qreals for accurancy (we might get some compiler warnings... :)
                 qreal categoryCount = m_series->categoryCount();
                 qreal setCount = m_series->barsetCount();
                 qreal width = geometry().width();
                 qreal height = geometry().height();
                 qreal max = m_series->max();
                 // Domain:
                 if (m_domainMaxY > max) {
                     max = m_domainMaxY;
                 }
                 qreal scale = (height / max);
                 qreal categoryWidth = width / categoryCount;
                 qreal barWidth = categoryWidth / (setCount+1);
                 int itemIndex(0);
                 for (int category = 0; category < categoryCount; category++) {
                     qreal xPos = categoryWidth * category + barWidth / 2;
                     qreal yPos = height;
                     for (int set = 0; set < setCount; set++) {
                         qreal barHeight = m_series->valueAt(set, category) * scale;
                         Bar* bar = m_bars.at(itemIndex);
                         QRectF rect(xPos, yPos - barHeight, barWidth, barHeight);
                         layout.append(rect);
                         bar->setPen(m_series->barsetAt(set)->pen());
                         bar->setBrush(m_series->barsetAt(set)->brush());
                         itemIndex++;
                         xPos += barWidth;
                     }
                 }
                 // Position floating values
                 itemIndex = 0;
                 for (int category = 0; category < m_series->categoryCount(); category++) {
                     qreal xPos = categoryWidth * category  + barWidth;
                     qreal yPos = height;
                     for (int set=0; set < m_series->barsetCount(); set++) {
                         qreal barHeight = m_series->valueAt(set, category) * scale;
                         BarValue* value = m_floatingValues.at(itemIndex);
                         QBarSet* barSet = m_series->barsetAt(set);
                         value->resize(100, 50);  // TODO: proper layout for this.
                         value->setPos(xPos, yPos-barHeight / 2);
                         value->setPen(barSet->floatingValuePen());
                         if (!qFuzzyIsNull(m_series->valueAt(set,category))) {
-                            value->setValueString(QString::number(m_series->valueAt(set, category)));
+                            value->setText(QString::number(m_series->valueAt(set, category)));
                         } else {
-                            value->setValueString(QString(""));
+                            value->setText(QString(""));
                         }
                         itemIndex++;
                         xPos += barWidth;
                     }
                 }
                 return layout;
             }
             void BarChartItem::applyLayout(const QVector<QRectF> &layout)
             {
                 if (animator())
                     animator()->updateLayout(this, m_layout, layout);
                 else
                     setLayout(layout);
             }
             void BarChartItem::setLayout(const QVector<QRectF> &layout)
             {
                 m_layout = layout;
                 for (int i=0; i < m_bars.count(); i++)
                     m_bars.at(i)->setRect(layout.at(i));
                 update();
             }
             //handlers
             void BarChartItem::handleModelChanged(int index)
             {
                 Q_UNUSED(index)
                 dataChanged();
             }
             void BarChartItem::handleDomainChanged(qreal minX, qreal maxX, qreal minY, qreal maxY)
             {
                 m_domainMinX = minX;
                 m_domainMaxX = maxX;
                 m_domainMinY = minY;
                 m_domainMaxY = maxY;
                 handleLayoutChanged();
             }
             void BarChartItem::handleGeometryChanged(const QRectF &rect)
             {
                 m_rect = rect;
                 handleLayoutChanged();
                 m_layoutSet = true;
                 setPos(rect.topLeft());
             }
             void BarChartItem::handleLayoutChanged()
             {
                 QVector<QRectF> layout = calculateLayout();
                 applyLayout(layout);
                 update();
             }
             void BarChartItem::showToolTip(QPoint pos, QString tip)
             {
                 // TODO: cool tooltip instead of default
                 QToolTip::showText(pos, tip);
             }
             #include "moc_barchartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/barchartmodel.cpp +11 -11

             #include <limits.h>
             #include <QVector>
             #include <QDebug>
             #include "barchartmodel_p.h"
             #include "qbarset.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             BarChartModel::BarChartModel(QStringList categories, QObject *parent) : QObject(parent),
                 m_category(categories)
             {
             }
             QStringList BarChartModel::category()
             {
                 return m_category;
             }
-            void BarChartModel::addBarSet(QBarSet *set)
+            void BarChartModel::appendBarSet(QBarSet *set)
             {
                 m_dataModel.append(set);
             }
             void BarChartModel::removeBarSet(QBarSet *set)
             {
                 if (m_dataModel.contains(set)) {
                     m_dataModel.removeOne(set);
                 }
             }
             void BarChartModel::insertBarSet(int i, QBarSet *set)
             {
                 m_dataModel.insert(i, set);
             }
             void BarChartModel::insertCategory(int i, QString category)
             {
                 m_category.insert(i, category);
             }
             void BarChartModel::removeCategory(int i)
             {
                 m_category.removeAt(i);
             }
-            QBarSet* BarChartModel::setAt(int index)
+            QBarSet* BarChartModel::barsetAt(int index) const
             {
                 return m_dataModel.at(index);
             }
-            QList<QBarSet*> BarChartModel::barSets()
+            QList<QBarSet*> BarChartModel::barSets() const
             {
                 return m_dataModel;
             }
-            int BarChartModel::barsetCount()
+            int BarChartModel::barsetCount() const
             {
                 return m_dataModel.count();
             }
-            int BarChartModel::categoryCount()
+            int BarChartModel::categoryCount() const
             {
                 return m_category.count();
             }
-            qreal BarChartModel::min()
+            qreal BarChartModel::min() const
             {
                 Q_ASSERT(m_dataModel.count() > 0);
                 // TODO: make min and max members and update them when data changes.
                 // This is slower since they are checked every time, even if data is same since previous call.
                 qreal min = INT_MAX;
                 for (int i = 0; i < m_dataModel.count(); i++) {
                     int itemCount = m_dataModel.at(i)->count();
                     for (int j = 0; j < itemCount; j++) {
                         qreal temp = m_dataModel.at(i)->valueAt(j);
                         if (temp < min)
                             min = temp;
                     }
                 }
                 return min;
             }
-            qreal BarChartModel::max()
+            qreal BarChartModel::max() const
             {
                 Q_ASSERT(m_dataModel.count() > 0);
                 // TODO: make min and max members and update them when data changes.
                 // This is slower since they are checked every time, even if data is same since previous call.
                 qreal max = INT_MIN;
                 for (int i = 0; i < m_dataModel.count(); i++) {
                     int itemCount = m_dataModel.at(i)->count();
                     for (int j = 0; j < itemCount; j++) {
                         qreal temp = m_dataModel.at(i)->valueAt(j);
                         if (temp > max)
                             max = temp;
                     }
                 }
                 return max;
             }
-            qreal BarChartModel::valueAt(int set, int category)
+            qreal BarChartModel::valueAt(int set, int category) const
             {
                 if ((set < 0) || (set >= m_dataModel.count())) {
                     // No set, no value.
                     return 0;
                 } else if ((category < 0) || (category >= m_dataModel.at(set)->count())) {
                     // No category, no value.
                     return 0;
                 }
                 return m_dataModel.at(set)->valueAt(category);
             }
-            qreal BarChartModel::percentageAt(int set, int category)
+            qreal BarChartModel::percentageAt(int set, int category) const
             {
                 if ((set < 0) || (set >= m_dataModel.count())) {
                     // No set, no value.
                     return 0;
                 } else if ((category < 0) || (category >= m_dataModel.at(set)->count())) {
                     // No category, no value.
                     return 0;
                 }
                 qreal value = m_dataModel.at(set)->valueAt(category);
                 qreal total = categorySum(category);
                 if ( qFuzzyCompare(total, 0) )
                     return 0;
                 return value / total;
             }
-            qreal BarChartModel::categorySum(int category)
+            qreal BarChartModel::categorySum(int category) const
             {
                 qreal sum(0);
                 int count = m_dataModel.count(); // Count sets
                 for (int set = 0; set < count; set++) {
                     if (category < m_dataModel.at(set)->count())
                         sum += m_dataModel.at(set)->valueAt(category);
                 }
                 return sum;
             }
-            qreal BarChartModel::maxCategorySum()
+            qreal BarChartModel::maxCategorySum() const
             {
                 qreal max = INT_MIN;
                 int count = categoryCount();
                 for (int col = 0; col < count; col++) {
                     qreal sum = categorySum(col);
                     if (sum > max)
                         max = sum;
                 }
                 return max;
             }
             QString BarChartModel::categoryName(int category)
             {
                 return m_category.at(category);
             }
             #include "moc_barchartmodel_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/barchartmodel_p.h +11 -11

             #ifndef BARCHARTMODEL_H
             #define BARCHARTMODEL_H
             #include <QObject>
             #include <QStringList>
             #include "qchartglobal.h"
             #include <qseries.h>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             // Model for bar chart. Internal class.
             // TODO: Implement as QAbstractItemModel?
             class QBarSet;
             class BarChartModel : public QObject //, public QAbstractItemModel
             {
                 Q_OBJECT
             public:
                 explicit BarChartModel(QStringList categories, QObject *parent = 0);
                 QStringList category();
-                void addBarSet(QBarSet *set);
+                void appendBarSet(QBarSet *set);
                 void removeBarSet(QBarSet *set);
                 void insertBarSet(int i, QBarSet *set);
                 void insertCategory(int i, QString category);
                 void removeCategory(int i);
-                QBarSet *setAt(int index);
+                QBarSet *barsetAt(int index) const;
-                QList<QBarSet *> barSets();
+                QList<QBarSet *> barSets() const;
-                int barsetCount();          // Number of sets in model
+                int barsetCount() const;          // Number of sets in model
-                int categoryCount();        // Number of categories
+                int categoryCount() const;        // Number of categories
-                qreal max();                // Maximum value of all sets
+                qreal max() const;                // Maximum value of all sets
-                qreal min();                // Minimum value of all sets
+                qreal min() const;                // Minimum value of all sets
-                qreal valueAt(int set, int category);
+                qreal valueAt(int set, int category) const;
-                qreal percentageAt(int set, int category);
+                qreal percentageAt(int set, int category) const;
-                qreal categorySum(int category);
+                qreal categorySum(int category) const;
-                qreal maxCategorySum();     // returns maximum sum of sets in all categories.
+                qreal maxCategorySum() const;     // returns maximum sum of sets in all categories.
                 QString categoryName(int category);
             Q_SIGNALS:
                 void modelUpdated();
             public Q_SLOTS:
             private:
                 QList<QBarSet *> m_dataModel;
                 QStringList m_category;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // BARCHARTMODEL_H

src/barchart/barvalue.cpp +3 -3

             #include "barvalue_p.h"
             #include <QPainter>
             #include <QPen>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             BarValue::BarValue(QBarSet &set, QGraphicsItem *parent)
                 : QGraphicsObject(parent),
                 m_barSet(set),
                 m_xPos(0),
                 m_yPos(0),
                 m_width(0),
                 m_height(0)
             {
                 setVisible(false);
             }
-            void BarValue::setValueString(QString str)
+            void BarValue::setText(QString str)
             {
                 m_valueString = str;
             }
-            QString BarValue::valueString()
+            QString BarValue::text() const
             {
                 return m_valueString;
             }
-            void BarValue::setPen(const QPen pen)
+            void BarValue::setPen(const QPen &pen)
             {
                 m_pen = pen;
             }
             QPen BarValue::pen() const
             {
                 return m_pen;
             }
             void BarValue::resize(qreal w, qreal h)
             {
                 m_width = w;
                 m_height = h;
             }
             void BarValue::setPos(qreal x, qreal y)
             {
                 m_xPos = x;
                 m_yPos = y;
             }
             void BarValue::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 Q_UNUSED(option)
                 Q_UNUSED(widget)
                 if (isVisible()) {
                     painter->setPen(m_pen);
                     painter->drawText(boundingRect(), m_valueString);
                 }
             }
             QRectF BarValue::boundingRect() const
             {
                 QRectF r(m_xPos, m_yPos, m_width, m_height);
                 return r;
             }
             void BarValue::toggleVisible()
             {
                 setVisible(!isVisible());
             }
             #include "moc_barvalue_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/barvalue_p.h +3 -3

             #ifndef BARVALUE_P_H
             #define BARVALUE_P_H
             #include "qchartglobal.h"
             #include <QGraphicsObject>
             #include <QPen>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QBarSet;
             // Visual class for floating bar values
             // By default these are not visible.
             class BarValue : public QGraphicsObject
             {
                 Q_OBJECT
             public:
                 BarValue(QBarSet &set, QGraphicsItem *parent = 0);
-                void setValueString(QString str);
+                void setText(QString str);
-                QString valueString();
+                QString text() const;
-                void setPen(const QPen pen);
+                void setPen(const QPen &pen);
                 QPen pen() const;
                 void resize(qreal w, qreal h);
                 void setPos(qreal x, qreal y);
                 // From QGraphicsItem
                 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
                 QRectF boundingRect() const;
             public Q_SLOTS:
                 void toggleVisible();
             private:
                 QBarSet &m_barSet;
                 QPen m_pen;
                 QString m_valueString;
                 qreal m_xPos;
                 qreal m_yPos;
                 qreal m_width;
                 qreal m_height;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // BARVALUE_P_H

src/barchart/percentbarchartitem.cpp +2 -2

             #include "percentbarchartitem_p.h"
             #include "bar_p.h"
             #include "barvalue_p.h"
             #include "qbarset.h"
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             PercentBarChartItem::PercentBarChartItem(QBarSeries *series, ChartPresenter *presenter) :
                 BarChartItem(series, presenter)
             {
             }
             QVector<QRectF> PercentBarChartItem::calculateLayout()
             {
                 QVector<QRectF> layout;
                 // Use temporary qreals for accurancy (we might get some compiler warnings... :)
                 qreal width = geometry().width();
                 qreal height = geometry().height();
                 qreal categoryCount = m_series->categoryCount();
                 qreal barWidth = width / (m_series->categoryCount() * 2);
                 qreal xStep = width / categoryCount;
                 qreal xPos =  xStep / 2 - barWidth / 2;
                 int itemIndex(0);
                 for (int category = 0; category < categoryCount; category++) {
                     qreal colSum = m_series->categorySum(category);
                     qreal scale = (height / colSum);
                     qreal yPos = height;
                     for (int set=0; set < m_series->barsetCount(); set++) {
                         qreal barHeight = m_series->valueAt(set, category) * scale;
                         Bar* bar = m_bars.at(itemIndex);
                         bar->setPen(m_series->barsetAt(set)->pen());
                         bar->setBrush(m_series->barsetAt(set)->brush());
                         QRectF rect(xPos, yPos-barHeight, barWidth, barHeight);
                         layout.append(rect);
                         itemIndex++;
                         yPos -= barHeight;
                     }
                     xPos += xStep;
                 }
                 // Position floating values
                 itemIndex = 0;
                 xPos = (width/categoryCount);
                 for (int category=0; category < m_series->categoryCount(); category++) {
                     qreal yPos = height;
                     qreal colSum = m_series->categorySum(category);
                     qreal scale = (height / colSum);
                     for (int set=0; set < m_series->barsetCount(); set++) {
                         qreal barHeight = m_series->valueAt(set,category) * scale;
                         BarValue* value = m_floatingValues.at(itemIndex);
                         QBarSet* barSet = m_series->barsetAt(set);
                         value->resize(100, 50);  // TODO: proper layout for this.
                         value->setPos(xPos, yPos-barHeight / 2);
                         value->setPen(barSet->floatingValuePen());
                         if (!qFuzzyIsNull(m_series->valueAt(set,category))) {
                             int p = m_series->percentageAt(set,category) * 100;
                             QString vString(QString::number(p));
                             vString.truncate(3);
                             vString.append("%");
-                            value->setValueString(vString);
+                            value->setText(vString);
                         } else {
-                            value->setValueString(QString(""));
+                            value->setText(QString(""));
                         }
                         itemIndex++;
                         yPos -= barHeight;
                     }
                     xPos += xStep;
                 }
                 return layout;
             }
             #include "moc_percentbarchartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/qbarseries.cpp +10 -10

             #include <QDebug>
             #include "qbarseries.h"
             #include "qbarset.h"
             #include "barchartmodel_p.h"
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QBarSeries
                 \brief part of QtCommercial chart API.
                 QBarSeries represents a series of data shown as bars. One QBarSeries can contain multible
                 QBarSet data sets. QBarSeries groups the data from sets to categories, which are defined
                 by QStringList.
                 \mainclass
                 \sa QBarSet, QStackedBarSeries, QPercentBarSeries
             */
             /*!
                 \fn virtual QSeriesType QBarSeries::type() const
                 \brief Returns type of series.
                 \sa QSeries, QSeriesType
             */
             /*!
                 \fn void QBarSeries::showToolTip(QPoint pos, QString tip)
                 \brief \internal \a pos \a tip
             */
             /*!
                 Constructs empty QBarSeries. Parameter \a categories defines the categories for chart.
                 QBarSeries is QObject which is a child of a \a parent.
             */
             QBarSeries::QBarSeries(QBarCategories categories, QObject *parent) : QSeries(parent),
                 m_internalModel(new BarChartModel(categories, this))
             {
                 m_model = 0;
                 m_mapCategories = -1;
                 m_mapBarBottom = -1;
                 m_mapBarTop = -1;
                 m_mapFirst = 0;
                 m_mapCount = 0;
                 m_mapOrientation = Qt::Vertical;
             }
             /*!
                 Adds a set of bars to series. Takes ownership of \a set.
                 Connects the clicked(QString) and rightClicked(QString) signals
                 of \a set to this series
             */
-            void QBarSeries::addBarSet(QBarSet *set)
+            void QBarSeries::appendBarSet(QBarSet *set)
             {
-                m_internalModel->addBarSet(set);
+                m_internalModel->appendBarSet(set);
                 connect(set, SIGNAL(clicked(QString)), this, SLOT(barsetClicked(QString)));
                 connect(set, SIGNAL(rightClicked(QString)), this, SLOT(barsetRightClicked(QString)));
                 connect(set, SIGNAL(valueChanged()), this, SLOT(barsetChanged()));
                 emit updatedBars();
             }
             /*!
                 Removes a set of bars from series. Releases ownership of \a set. Doesnt delete \a set.
                 Disconnects the clicked(QString) and rightClicked(QString) signals
                 of \a set from this series
             */
             void QBarSeries::removeBarSet(QBarSet *set)
             {
                 disconnect(set, SIGNAL(clicked(QString)), this, SLOT(barsetClicked(QString)));
                 disconnect(set, SIGNAL(rightClicked(QString)), this, SLOT(barsetRightClicked(QString)));
                 m_internalModel->removeBarSet(set);
                 emit updatedBars();
             }
             void QBarSeries::insertBarSet(int i, QBarSet *set)
             {
                 m_internalModel->insertBarSet(i, set);
                 //    emit barsetChanged();
             }
             void QBarSeries::insertCategory(int i, QString category)
             {
                 m_internalModel->insertCategory(i, category);
             }
             void QBarSeries::removeCategory(int i)
             {
                 m_internalModel->removeCategory(i);
             }
             /*!
                 Returns number of sets in series.
             */
-            int QBarSeries::barsetCount()
+            int QBarSeries::barsetCount() const
             {
                 //    if(m_model)
                 //        return m_mapBarTop - m_mapBarBottom;
                 //    else
                 return m_internalModel->barsetCount();
             }
             /*!
                 Returns number of categories in series
             */
-            int QBarSeries::categoryCount()
+            int QBarSeries::categoryCount() const
             {
                 return m_internalModel->categoryCount();
             }
             /*!
                 Returns a list of sets in series. Keeps ownership of sets.
              */
-            QList<QBarSet*> QBarSeries::barSets()
+            QList<QBarSet*> QBarSeries::barSets() const
             {
                 return m_internalModel->barSets();
             }
             /*!
                 \internal \a index
             */
             QBarSet* QBarSeries::barsetAt(int index)
             {
-                return m_internalModel->setAt(index);
+                return m_internalModel->barsetAt(index);
             }
             /*!
                 \internal \a category
             */
             QString QBarSeries::categoryName(int category)
             {
                 return m_internalModel->categoryName(category);
             }
             /*!
                 Enables or disables tooltip depending on parameter \a enabled.
                 Tooltip shows the name of set, when mouse is hovering on top of bar.
                 Calling without parameter \a enabled, enables the tooltip
             */
             void QBarSeries::setToolTipEnabled(bool enabled)
             {
                 // TODO: what if we add sets after call to this function? Those sets won't have tooltip enabled.
                 if (enabled) {
                     for (int i=0; i<m_internalModel->barsetCount(); i++) {
-                        QBarSet *set = m_internalModel->setAt(i);
+                        QBarSet *set = m_internalModel->barsetAt(i);
                         connect(set, SIGNAL(showToolTip(QPoint,QString)), this, SIGNAL(showToolTip(QPoint,QString)));
                     }
                 } else {
                     for (int i=0; i<m_internalModel->barsetCount(); i++) {
-                        QBarSet *set = m_internalModel->setAt(i);
+                        QBarSet *set = m_internalModel->barsetAt(i);
                         disconnect(set, SIGNAL(showToolTip(QPoint,QString)), this, SIGNAL(showToolTip(QPoint,QString)));
                     }
                 }
             }
             /*!
                 \internal \a category
             */
             void QBarSeries::barsetClicked(QString category)
             {
                 emit clicked(qobject_cast<QBarSet*>(sender()), category);
             }
             /*!
                 \internal \a category
             */
             void QBarSeries::barsetRightClicked(QString category)
             {
                 emit rightClicked(qobject_cast<QBarSet*>(sender()), category);
             }
             /*!
                 \internal
             */
             qreal QBarSeries::min()
             {
                 return m_internalModel->min();
             }
             /*!
                 \internal
             */
             qreal QBarSeries::max()
             {
                 return m_internalModel->max();
             }
             /*!
                 \internal \a set \a category
             */
             qreal QBarSeries::valueAt(int set, int category)
             {
                 return m_internalModel->valueAt(set, category);
             }
             /*!
                 \internal \a set \a category
             */
             qreal QBarSeries::percentageAt(int set, int category)
             {
                 return m_internalModel->percentageAt(set, category);
             }
             /*!
                 \internal \a category
             */
             qreal QBarSeries::categorySum(int category)
             {
                 return m_internalModel->categorySum(category);
             }
             /*!
                 \internal
             */
             qreal QBarSeries::maxCategorySum()
             {
                 return m_internalModel->maxCategorySum();
             }
             /*!
                 \internal
             */
             BarChartModel& QBarSeries::model()
             {
                 return *m_internalModel;
             }
             bool QBarSeries::setModel(QAbstractItemModel *model)
             {
                 // disconnect signals from old model
                 if(m_model)
                 {
                     disconnect(m_model, 0, this, 0);
                     m_mapCategories = -1;
                     m_mapBarBottom = -1;
                     m_mapBarTop = -1;
                     m_mapFirst = 0;
                     m_mapCount = 0;
                     m_mapOrientation = Qt::Vertical;
                 }
                 // set new model
                 if(model)
                 {
                     m_model = model;
                     return true;
                 }
                 else
                 {
                     m_model = 0;
                     return false;
                 }
             }
             // TODO
             void QBarSeries::setModelMapping(int categories, int bottomBoundry, int topBoundry, Qt::Orientation orientation)
             {
                 if (!m_model)
                     return;
                 m_mapCategories = categories;
                 m_mapBarBottom = bottomBoundry;
                 m_mapBarTop = topBoundry;
             //    m_mapFirst = 1;
                 m_mapOrientation = orientation;
                 // connect the signals
                 if (m_mapOrientation == Qt::Vertical) {
                     m_mapCount = m_model->rowCount() - m_mapFirst;
                     connect(m_model,SIGNAL(dataChanged(QModelIndex,QModelIndex)),
                             this, SLOT(modelUpdated(QModelIndex, QModelIndex)));
                     connect(m_model,SIGNAL(rowsInserted(QModelIndex, int, int)),
                             this, SLOT(modelDataAdded(QModelIndex,int,int)));
                     connect(m_model, SIGNAL(rowsRemoved(QModelIndex, int, int)),
                             this, SLOT(modelDataRemoved(QModelIndex,int,int)));
                 } else {
                     m_mapCount = m_model->columnCount() - m_mapFirst;
                     connect(m_model,SIGNAL(dataChanged(QModelIndex,QModelIndex)),
                             this, SLOT(modelUpdated(QModelIndex, QModelIndex)));
                     connect(m_model,SIGNAL(columnsInserted(QModelIndex, int, int)),
                             this, SLOT(modelDataAdded(QModelIndex,int,int)));
                     connect(m_model, SIGNAL(columnsRemoved(QModelIndex, int, int)),
                             this, SLOT(modelDataRemoved(QModelIndex,int,int)));
                 }
                 // create the initial bars
                 delete m_internalModel;
                 if (m_mapOrientation == Qt::Vertical) {
                     QStringList categories;
                     for (int k = m_mapFirst; k < m_mapFirst + m_mapCount; k++)
                         categories << m_model->data(m_model->index(k, m_mapCategories), Qt::DisplayRole).toString();
                     m_internalModel = new BarChartModel(categories, this);
                     for (int i = m_mapBarBottom; i <= m_mapBarTop; i++) {
                         QBarSet* barSet = new QBarSet(QString("Column: %1").arg(i + 1));
                         for(int m = m_mapFirst; m < m_mapFirst + m_mapCount; m++)
                             *barSet << m_model->data(m_model->index(m, i), Qt::DisplayRole).toDouble();
-                        addBarSet(barSet);
+                        appendBarSet(barSet);
                     }
                 } else {
                     QStringList categories;
                     for (int k = m_mapFirst; k < m_mapFirst + m_mapCount; k++)
                         categories << m_model->data(m_model->index(m_mapCategories, k), Qt::DisplayRole).toString();
                     m_internalModel = new BarChartModel(categories, this);
                     for (int i = m_mapBarBottom; i <= m_mapBarTop; i++) {
                         QBarSet* barSet = new QBarSet(QString("Row: %1").arg(i + 1));
                         for(int m = m_mapFirst; m < m_mapFirst + m_mapCount; m++)
                             *barSet << m_model->data(m_model->index(i, m), Qt::DisplayRole).toDouble();
-                        addBarSet(barSet);
+                        appendBarSet(barSet);
                     }
                 }
             }
             void QBarSeries::setModelMappingShift(int first, int count)
             {
                 m_mapFirst = first;
                 m_mapCount = count;
             }
             void QBarSeries::modelUpdated(QModelIndex topLeft, QModelIndex bottomRight)
             {
                 Q_UNUSED(bottomRight)
                 if (m_mapOrientation == Qt::Vertical)
                 {
                     // model update is relevant to BarSeries if the change was made to the part of the model that was mapped to BarSeries
                     if (topLeft.column() >= m_mapBarBottom && topLeft.column() <= m_mapBarTop && topLeft.row() >= m_mapFirst && topLeft.row() < m_mapFirst + m_mapCount)
                         barsetAt(topLeft.column() - m_mapBarBottom)->setValue(topLeft.row() - m_mapFirst, m_model->data(topLeft, Qt::DisplayRole).toDouble());
                 }
                 else
                 {
                     // model update is relevant to BarSeries if the change was made to the part of the model that was mapped to BarSeries
                     if (topLeft.row() >= m_mapBarBottom && topLeft.row() <= m_mapBarTop && topLeft.column() >= m_mapFirst && topLeft.column() < m_mapFirst + m_mapCount)
                         barsetAt(topLeft.row() - m_mapBarBottom)->setValue(topLeft.column() - m_mapFirst, m_model->data(topLeft, Qt::DisplayRole).toDouble());
                 }
             }
             void QBarSeries::modelDataAdded(QModelIndex /*parent*/, int start, int /*end*/)
             {
                 if (m_mapOrientation == Qt::Vertical) {
                     insertCategory(start - m_mapFirst, QString("Row: %1").arg(start + 1));
                     for (int i = 0; i <= m_mapBarTop - m_mapBarBottom; i++) {
                         barsetAt(i)->insertValue(start - m_mapFirst, m_model->data(m_model->index(start, i), Qt::DisplayRole).toDouble());
                     }
                 } else {
                     insertCategory(start - m_mapFirst, QString("Column: %1").arg(start + 1));
                     for (int i = 0; i <= m_mapBarTop - m_mapBarBottom; i++) {
                         barsetAt(i)->insertValue(start - m_mapFirst, m_model->data(m_model->index(i, start), Qt::DisplayRole).toDouble());
                     }
                 }
                 emit restructuredBar(1);
             }
             void QBarSeries::modelDataRemoved(QModelIndex parent, int start, int end)
             {
                 Q_UNUSED(parent)
                 Q_UNUSED(end)
                 removeCategory(start - m_mapFirst);
                 for (int i = 0; i <= m_mapBarTop - m_mapBarBottom; i++)
                 {
                     barsetAt(i)->removeValue(start - m_mapFirst);
                 }
                 emit restructuredBar(1);
             }
             void QBarSeries::barsetChanged()
             {
                 emit updatedBars();
             }
             QBarCategories QBarSeries::categories() const
             {
                 QBarCategories categories;
                 int count = m_internalModel->categoryCount();
                 for (int i=1; i <= count; i++) {
                       categories.insert(i, m_internalModel->categoryName(i - 1));
                 }
                 return categories;
             }
             #include "moc_qbarseries.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/barchart/qbarseries.h +4 -4

             #ifndef BARSERIES_H
             #define BARSERIES_H
             #include <qseries.h>
             #include <QStringList>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             typedef QStringList QBarCategories;
             class QBarSet;
             class BarChartModel;
             class BarCategory;
             // Container for series
             class QTCOMMERCIALCHART_EXPORT QBarSeries : public QSeries
             {
                 Q_OBJECT
             public:
                 QBarSeries(QStringList categories, QObject *parent = 0);
                 virtual QSeriesType type() const { return QSeries::SeriesTypeBar; }
-                void addBarSet(QBarSet *set);               // Takes ownership of set
+                void appendBarSet(QBarSet *set);               // Takes ownership of set
                 void removeBarSet(QBarSet *set);            // Releases ownership, doesn't delete set
                 void insertBarSet(int i, QBarSet *set);
                 void insertCategory(int i, QString category);
                 void removeCategory(int i);
-                int barsetCount();
+                int barsetCount() const;
-                int categoryCount();
+                int categoryCount() const;
-                QList<QBarSet*> barSets();
+                QList<QBarSet*> barSets() const;
                 QBarCategories categories() const;
                 bool setModel(QAbstractItemModel *model);
                 QAbstractItemModel *modelExt() { return m_model; }
                 void setModelMapping(int categories, int bottomBoundry, int topBoundry, Qt::Orientation orientation = Qt::Vertical);
                 void setModelMappingShift(int first, int count);
             public:
                 // TODO: Functions below this are not part of api and will be moved
                 // to private implementation, when we start using it
                 // TODO: TO PIMPL --->
                 QBarSet* barsetAt(int index);
                 QString categoryName(int category);
                 qreal min();
                 qreal max();
                 qreal valueAt(int set, int category);
                 qreal percentageAt(int set, int category);
                 qreal categorySum(int category);
                 qreal maxCategorySum();
                 BarChartModel& model();
                 // <--- TO PIMPL
             Q_SIGNALS:
                 //void changed(int index);
                 void clicked(QBarSet *barset, QString category);        // Up to user of api, what to do with these signals
                 void rightClicked(QBarSet *barset, QString category);
                 //
                 void updatedBars();
                 void restructuredBar(int);
                 // TODO: internal signals, these to private implementation.
                 // TODO: TO PIMPL --->
                 void showToolTip(QPoint pos, QString tip);
                 // <--- TO PIMPL
             public Q_SLOTS:
                 void setToolTipEnabled(bool enabled = true);           // enables tooltips
                 // TODO: TO PIMPL --->
                 void barsetClicked(QString category);
                 void barsetRightClicked(QString category);
                 // <--- TO PIMPL
             private Q_SLOTS:
                 // slots for updating bars when data in model changes
                 void modelUpdated(QModelIndex topLeft, QModelIndex bottomRight);
                 void modelDataAdded(QModelIndex parent, int start, int end);
                 void modelDataRemoved(QModelIndex parent, int start, int end);
                 void barsetChanged();
             protected:
                 BarChartModel *m_internalModel;     // TODO: this may change... current "2 models" situation doesn't look good.
                 QAbstractItemModel* m_model;
                 int m_mapCategories;
                 int m_mapBarBottom;
                 int m_mapBarTop;
                 int m_mapFirst;
                 int m_mapCount;
                 Qt::Orientation m_mapOrientation;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // BARSERIES_H

src/barchart/qbarset.cpp +4 -4

             #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)
                 ,m_name(name)
             {
             }
             /*!
                 Sets new \a name for set.
             */
             void QBarSet::setName(QString name)
             {
                 m_name = name;
             }
             /*!
                 Returns name of the set.
             */
-            QString QBarSet::name()
+            QString QBarSet::name() const
             {
                 return m_name;
             }
             /*!
                 Appends new value \a value to the end of set.
             */
             QBarSet& QBarSet::operator << (const qreal &value)
             {
                 m_values.append(value);
                 emit structureChanged();
                 return *this;
             }
             void QBarSet::insertValue(int i, qreal value)
             {
                 m_values.insert(i, value);
             }
             void QBarSet::removeValue(int i)
             {
                 m_values.removeAt(i);
             }
             /*!
                 Returns count of values in set.
             */
-            int QBarSet::count()
+            int QBarSet::count() const
             {
                 return m_values.count();
             }
             /*!
                 Returns value of set indexed by \a index
             */
-            qreal QBarSet::valueAt(int index)
+            qreal QBarSet::valueAt(int index) const
             {
                 return m_values.at(index);
             }
             /*!
                 Sets a new value \a value to set, indexed by \a index
             */
             void QBarSet::setValue(int index, qreal value)
             {
                 m_values.replace(index,value);
                 emit valueChanged();
             }
             /*!
                 Returns total sum of all values in barset.
             */
-            qreal QBarSet::total()
+            qreal QBarSet::total() const
             {
                 qreal total(0);
                 for (int i=0; i < m_values.count(); i++) {
                     total += m_values.at(i);
                 }
                 return total;
             }
             /*!
                 Sets pen for set. Bars of this set are drawn using \a pen
             */
             void QBarSet::setPen(const QPen &pen)
             {
                 m_pen = pen;
                 emit valueChanged();
             }
             /*!
                 Returns pen of the set.
             */
             QPen QBarSet::pen() const
             {
                 return m_pen;
             }
             /*!
                 Sets brush for the set. Bars of this set are drawn using \a brush
             */
             void QBarSet::setBrush(const QBrush &brush)
             {
                 m_brush = brush;
                 emit valueChanged();
             }
             /*!
                 Returns brush of the set.
             */
             QBrush QBarSet::brush() const
             {
                 return m_brush;
             }
             /*!
                 Sets the pen for floating values that are drawn on top of this set
             */
             void QBarSet::setFloatingValuePen(const QPen &pen)
             {
                 m_floatingValuePen = pen;
             }
             /*!
                 Returns the pen for floating values that are drawn on top of this set
             */
             QPen QBarSet::floatingValuePen() const
             {
                 return m_floatingValuePen;
             }
             /*!
                 \internal \a pos
             */
             void QBarSet::barHoverEnterEvent(QPoint pos)
             {
                 emit showToolTip(pos, m_name);
                 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 -4

             #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();
+                QString name() const;
                 QBarSet& operator << (const qreal &value);  // appends new value to set
                 void insertValue(int i, qreal value);
                 void removeValue(int i);
                 // TODO: remove indices eventually. Use as internal?
-                int count();                                // count of values in set
+                int count() const;                          // count of values in set
-                qreal valueAt(int index);                   // for modifying individual values
+                qreal valueAt(int index) const;                   // for modifying individual values
                 void setValue(int index, qreal value);      // setter for individual value
-                qreal total();                              // total values in the set
+                qreal total() const;                              // 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 structureChanged();
                 void valueChanged();
                 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 m_name;
                 QList<qreal> m_values;   // TODO: replace with map (category, value)
                 QMap<QString, qreal> m_mappedValues;
                 QPen m_pen;
                 QBrush m_brush;
                 QPen m_floatingValuePen;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QBARSET_H

src/barchart/stackedbarchartitem.cpp +2 -2

             #include "stackedbarchartitem_p.h"
             #include "bar_p.h"
             #include "barvalue_p.h"
             #include "qbarset.h"
             #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             StackedBarChartItem::StackedBarChartItem(QBarSeries *series, ChartPresenter *presenter) :
                 BarChartItem(series, presenter)
             {
             }
             StackedBarChartItem::~StackedBarChartItem()
             {
             }
             QVector<QRectF> StackedBarChartItem::calculateLayout()
             {
                 QVector<QRectF> layout;
                 // Use temporary qreals for accurancy (we might get some compiler warnings... :)
                 qreal maxSum = m_series->maxCategorySum();
                 // Domain:
                 if (m_domainMaxY > maxSum) {
                     maxSum = m_domainMaxY;
                 }
                 qreal height = geometry().height();
                 qreal width = geometry().width();
                 qreal scale = (height /  m_series->maxCategorySum());
                 qreal categotyCount = m_series->categoryCount();
                 qreal barWidth = width / (categotyCount * 2);
                 qreal xStep = width / categotyCount;
                 qreal xPos = xStep / 2 - barWidth / 2;
                 int itemIndex(0);
                 for (int category = 0; category < categotyCount; category++) {
                     qreal yPos = height;
                     for (int set=0; set < m_series->barsetCount(); set++) {
                         qreal barHeight = m_series->valueAt(set, category) * scale;
                         Bar* bar = m_bars.at(itemIndex);
                         bar->setPen(m_series->barsetAt(set)->pen());
                         bar->setBrush(m_series->barsetAt(set)->brush());
                         QRectF rect(xPos, yPos-barHeight, barWidth, barHeight);
                         layout.append(rect);
                         itemIndex++;
                         yPos -= barHeight;
                     }
                     xPos += xStep;
                 }
                 // Position floating values
                 itemIndex = 0;
                 xPos = (width/categotyCount);
                 for (int category=0; category < m_series->categoryCount(); category++) {
                     qreal yPos = height;
                     for (int set=0; set < m_series->barsetCount(); set++) {
                         qreal barHeight = m_series->valueAt(set, category) * scale;
                         BarValue* value = m_floatingValues.at(itemIndex);
                         QBarSet* barSet = m_series->barsetAt(set);
                         value->resize(100, 50);  // TODO: proper layout for this.
                         value->setPos(xPos, yPos-barHeight / 2);
                         value->setPen(barSet->floatingValuePen());
                         if (!qFuzzyIsNull(m_series->valueAt(set, category))) {
-                            value->setValueString(QString::number(m_series->valueAt(set,category)));
+                            value->setText(QString::number(m_series->valueAt(set,category)));
                         } else {
-                            value->setValueString(QString(""));
+                            value->setText(QString(""));
                         }
                         itemIndex++;
                         yPos -= barHeight;
                     }
                     xPos += xStep;
                 }
                 return layout;
             }
             #include "moc_stackedbarchartitem_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