HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r996:ce5f1c868418

Improves build configuration...

Michal Klocek -

r996:ce5f1c868418

parent child

Context file:

r996:ce5f1c868418

Expand all files

build.pri ~~integrated.pri~~ renamed +1 -1

-            integrated_build:{
+            local_build:{
                 INCLUDEPATH += $$CHART_BUILD_PUBLIC_HEADER_DIR
                 !win32: {
                     LIBS += -L $$CHART_BUILD_LIB_DIR -Wl,-rpath,$$CHART_BUILD_LIB_DIR
                 }else{
                     win32-msvc*: {
                         # hack fix for error:
                         #   "LINK : fatal error LNK1146: no argument specified with option '/LIBPATH:'"
                         QMAKE_LIBDIR += $$CHART_BUILD_LIB_DIR
                     }else{
                         LIBS += -L $$CHART_BUILD_LIB_DIR
                     }
                 }
                 CONFIG(debug, debug|release) {
                     LIBS += -lQtCommercialChartd
                     #this is ugly hack to work around missing rpath, it simply copies lib
                     win32:{
                         copylib.target = $$CHART_BUILD_BIN_DIR/QtCommercialChartd.dll
                         copylib.commands = $$QMAKE_COPY $$CHART_BUILD_LIB_DIR\\QtCommercialChartd.dll $$CHART_BUILD_BIN_DIR
                         copylib.depends = $$CHART_BUILD_LIB_DIR/QtCommercialChartd.dll
                         PRE_TARGETDEPS += $$CHART_BUILD_BIN_DIR/QtCommercialChartd.dll
                         QMAKE_EXTRA_TARGETS +=copylib
                     }
                 } else {
                     LIBS += -lQtCommercialChart
                     #this is ugly hack to work around missing rpath, it simply copies lib
                     win32: {
                         copylib.target = $$CHART_BUILD_BIN_DIR/QtCommercialChart
                         copylib.commands = $$QMAKE_COPY $$CHART_BUILD_LIB_DIR\\QtCommercialChart.dll $$CHART_BUILD_BIN_DIR
                         copylib.depends = $$CHART_BUILD_LIB_DIR/QtCommercialChart.dll
                         PRE_TARGETDEPS += $$CHART_BUILD_BIN_DIR/QtCommercialChart
                         QMAKE_EXTRA_TARGETS +=copylib
                     }
                 }
                 mac: {
                     # This is a hack to make binaries to use the internal version of the QtCommercial Charts library on OSX
                     CHARTS_LIB_NAME = libQtCommercialChart.1.dylib
                     CONFIG(debug, debug|release) {
                         CHARTS_LIB_NAME = libQtCommercialChartd.1.dylib
                     }
                     BIN_TARGET_PATH = ""
                     exists ($$CHART_BUILD_BIN_DIR"/"$$TARGET".app/Contents/MacOS/"$$TARGET) {
                         BIN_TARGET_PATH = $$CHART_BUILD_BIN_DIR"/"$$TARGET".app/Contents/MacOS/"$$TARGET
                     }
                     exists ($$CHART_BUILD_BIN_DIR"/test/"$$TARGET".app/Contents/MacOS/"$$TARGET) {
                         # Executable in test folder
                         BIN_TARGET_PATH = $$CHART_BUILD_BIN_DIR"/test/"$$TARGET".app/Contents/MacOS/"$$TARGET
                     }
                     exists ($$CHART_BUILD_BIN_DIR"/test/tst_"$$TARGET".app/Contents/MacOS/tst_"$$TARGET) {
                         # Executable in test folder with custom target "tst_NNN"
                         BIN_TARGET_PATH = $$CHART_BUILD_BIN_DIR"/test/tst_"$$TARGET".app/Contents/MacOS/tst_"$$TARGET
                     }
                     exists($$CHART_BUILD_PLUGIN_DIR"/lib"$$TARGET".dylib") {
                         # Plugin
                         BIN_TARGET_PATH = $$CHART_BUILD_PLUGIN_DIR"/lib"$$TARGET".dylib"
                     }
                     !isEmpty (BIN_TARGET_PATH) {
                         QMAKE_POST_LINK += install_name_tool -change $$CHARTS_LIB_NAME $$CHART_BUILD_LIB_DIR"/"$$CHARTS_LIB_NAME $$BIN_TARGET_PATH
             #            message($$QMAKE_POST_LINK)
                     }
                     # Hack to make qml plugins available as internal build versions
                     exists($$CHART_BUILD_PLUGIN_DIR"/lib"$$TARGET".dylib") {
                         QMAKE_POST_LINK += " & $$QMAKE_COPY qmldir $$CHART_BUILD_PLUGIN_DIR"
                         message($$QMAKE_POST_LINK)
                     }
                 }
             } else {
                 CONFIG += qtcommercialchart
             }

charts.pro +11 -6

-            !include(common.pri) {
+            !include(config.pri) {
-                error('missing common.pri')
+                error('Missing config.pri')
             }
             TEMPLATE = subdirs
-            SUBDIRS += src qmlplugin examples demos test
+            SUBDIRS = src qmlplugin examples demos test
-            integrated_build:{
+            local_build:{
-                message('Configured for integrated build against local libs...')
+                message('Configured for local build against local libs...')
+                message('You can run "make" to build qchart library, examples and demos...')
             } else {
                 message('Running build aginst system libs...')
-                message('Please build example test and qmlplugin after installing library.')
+                message('Bulding only charts library...')
+                message('You can run "make install" to build and install charts.')
+                message('Afterwards you can run "cd examples; qmake ; make " to build examples.')
+                message('Run qmake CONFIG+=local_build' to build everything at once.)
+                SUBDIRS = src
             }
             CONFIG += ordered
             QMAKE_CXXFLAGS += -g -Wall
             unix:QMAKE_DISTCLEAN += -r build bin include lib doc/html
             win32:QMAKE_DISTCLEAN += /Q /s build bin include lib doc\\html
             # install feature file
             feature.path = $$[QT_INSTALL_DATA]/mkspecs/features
             feature.files = $$PWD/features/qtcommercialchart.prf
             INSTALLS += feature
             docs.target = docs
             win32:{
                 docs.commands = qdoc3 $$CHART_BUILD_DOC_DIR\\qcharts.qdocconf
             }else{
                 docs.commands = qdoc3 $$CHART_BUILD_DOC_DIR/qcharts.qdocconf
             }
             docs.depends = FORCE
             QMAKE_EXTRA_TARGETS += docs

config.pri ~~common.pri~~ renamed +6 -3

-            CONFIG+=integrated_build #remove if you want to build against installed libs
+            #check if shadow build
             !contains($${PWD}, $${OUT_PWD}){
-               search = "$$PWD:::"
+                search = "$$PWD:::"
                 temp = $$split(search,"/")
                 temp = $$last(temp)
                 path = $$replace(search,$$temp,'')
                 temp = $$split(OUT_PWD,$$path)
                 temp = $$split(temp,'/')
                 temp = $$first(temp)
                 path = "$${path}$${temp}"
                 SHADOW=$$path
+                CONFIG-=developer_build
             }else{
                 SHADOW=$$PWD
             }
             CHART_BUILD_PUBLIC_HEADER_DIR = $$SHADOW/include
             CHART_BUILD_PRIVATE_HEADER_DIR = $$CHART_BUILD_PUBLIC_HEADER_DIR/private
             CHART_BUILD_LIB_DIR = $$SHADOW/lib
             CHART_BUILD_DIR = $$SHADOW/build
             CHART_BUILD_BIN_DIR = $$SHADOW/bin
             CHART_BUILD_PLUGIN_DIR = $$CHART_BUILD_LIB_DIR/QtCommercial/Chart
             CHART_BUILD_DOC_DIR = $$SHADOW/doc
             # hack to fix windows builds
             win32:{
                 CHART_BUILD_PUBLIC_HEADER_DIR = $$replace(CHART_BUILD_PUBLIC_HEADER_DIR, "/","\\")
                 CHART_BUILD_PRIVATE_HEADER_DIR = $$replace(CHART_BUILD_PRIVATE_HEADER_DIR, "/","\\")
                 CHART_BUILD_LIB_DIR = $$replace(CHART_BUILD_LIB_DIR, "/","\\")
                 CHART_BUILD_BUILD_DIR = $$replace(CHART_BUILD_BUILD_DIR, "/","\\")
                 CHART_BUILD_BIN_DIR = $$replace(CHART_BUILD_BIN_DIR, "/","\\")
                 CHART_BUILD_PLUGIN_DIR = $$replace(CHART_BUILD_PLUGIN_DIR, "/","\\")
                 CHART_BUILD_DOC_DIR = $$replace(CHART_BUILD_DOC_DIR, "/","\\")
             }
             mac: {
                 # TODO: The following qmake flags are a work-around to make QtCommercial Charts compile on
                 # QtCommercial 4.8. On the other hand Charts builds successfully with Qt open source 4.8
                 # without these definitions, so this is probably a configuration issue on QtCommercial 4.8;
                 # it should probably define the minimum OSX version to be 10.5...
                 QMAKE_CXXFLAGS *= -mmacosx-version-min=10.5
                 QMAKE_LFLAGS *= -mmacosx-version-min=10.5
             }
+            developer_build: DEFINES+=DEVELOPER_BUILD
  No newline at end of file

demos/demos.pri +4 -4

-            !include( ../common.pri ) {
+            !include( ../config.pri ) {
-             error( "Couldn't find the common.pri file!" )
+             error( "Couldn't find the config.pri file!" )
             }
-            !include( ../integrated.pri ) {
+            !include( ../build.pri ) {
-             error( "Couldn't find the integrated.pri file !")
+             error( "Couldn't find the build.pri file !")
             }
             DESTDIR = $$CHART_BUILD_BIN_DIR
             OBJECTS_DIR = $$CHART_BUILD_DIR/bin/$$TARGET
             MOC_DIR = $$CHART_BUILD_DIR/bin/$$TARGET
             UI_DIR = $$CHART_BUILD_DIR/bin/$$TARGET
             RCC_DIR = $$CHART_BUILD_DIR/bin/$$TARGET
             TEMPLATE = app
             QT += core gui

examples/examples.pri +4 -4

-            !include( ../common.pri ) {
+            !include( ../config.pri ) {
-             error( "Couldn't find the common.pri file!" )
+             error( "Couldn't find the config.pri file!" )
             }
-            !include( ../integrated.pri ) {
+            !include( ../build.pri ) {
-             error( "Couldn't find the integrated.pri file !")
+             error( "Couldn't find the build.pri file !")
             }
             DESTDIR = $$CHART_BUILD_BIN_DIR
             OBJECTS_DIR = $$CHART_BUILD_DIR/bin/$$TARGET
             MOC_DIR = $$CHART_BUILD_DIR/bin/$$TARGET
             UI_DIR = $$CHART_BUILD_DIR/bin/$$TARGET
             RCC_DIR = $$CHART_BUILD_DIR/bin/$$TARGET
             TEMPLATE = app
             QT += core gui

qmlplugin/declarativexypoint.h +1 0

             /****************************************************************************
             **
             ** 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$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #ifndef DECLARATIVE_XY_POINT_H
             #define DECLARATIVE_XY_POINT_H
             #include "qchartglobal.h"
             #include <QObject>
             #include <QPointF>
+            #include <QTextStream>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class DeclarativeXyPoint : public QObject, public QPointF
             {
                 Q_OBJECT
                 Q_PROPERTY(qreal x READ x WRITE setX /*NOTIFY dataXChanged*/)
                 Q_PROPERTY(qreal y READ y WRITE setY /*NOTIFY dataYChanged*/)
             public:
                 explicit DeclarativeXyPoint(QObject *parent = 0);
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // DECLARATIVE_XY_POINT_H

qmlplugin/qmlplugin.pro +3 -3

             TEMPLATE = lib
             TARGET = qtcommercialchartqml
             CONFIG += qt plugin
             QT += declarative
-            !include( ../common.pri ) {
+            !include( ../config.pri ) {
                 error( "Couldn't find the common.pri file!" )
             }
-            !include( ../integrated.pri ) {
+            !include( ../build.pri ) {
-                error( "Couldn't find the integrated.pri file !")
+                error( "Couldn't find the build.pri file !")
             }
             DESTDIR = $$CHART_BUILD_PLUGIN_DIR
             contains(QT_MAJOR_VERSION, 5) {
                 # TODO: QtQuick2 not supported by the implementation currently
                 DEFINES += QTQUICK2
             }
             OBJECTS_DIR = $$CHART_BUILD_DIR/plugin
             MOC_DIR = $$CHART_BUILD_DIR/plugin
             UI_DIR = $$CHART_BUILD_DIR/plugin
             RCC_DIR = $$CHART_BUILD_DIR/plugin
             SOURCES += \
                 plugin.cpp \
                 declarativechart.cpp \
                 declarativexyseries.cpp \
                 declarativexypoint.cpp \
                 declarativelineseries.cpp \
                 declarativesplineseries.cpp \
                 declarativeareaseries.cpp \
                 declarativescatterseries.cpp \
                 declarativepieseries.cpp \
                 declarativebarseries.cpp
             HEADERS += \
                 declarativechart.h \
                 declarativexyseries.h \
                 declarativexypoint.h \
                 declarativelineseries.h \
                 declarativesplineseries.h \
                 declarativeareaseries.h \
                 declarativescatterseries.h \
                 declarativepieseries.h \
                 declarativebarseries.h
             TARGETPATH = QtCommercial/Chart
             target.path = $$[QT_INSTALL_IMPORTS]/$$TARGETPATH
             qmldir.files += $$PWD/qmldir
             qmldir.path +=  $$[QT_INSTALL_IMPORTS]/$$TARGETPATH
             INSTALLS += target qmldir

src/animations/splineanimation.cpp +1 0

             /****************************************************************************
             **
             ** 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$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "splineanimation_p.h"
             #include "splinechartitem_p.h"
+            #include <QDebug>
             Q_DECLARE_METATYPE(QVector<QPointF>)
             Q_DECLARE_METATYPE(SplineVector)
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             SplineAnimation::SplineAnimation(SplineChartItem* item):ChartAnimation(item),
                 m_item(item),
                 m_dirty(true)
             {
             }
             SplineAnimation::~SplineAnimation()
             {
             }
             void SplineAnimation::setValues(QVector<QPointF> &oldPoints, QVector<QPointF> &newPoints, QVector<QPointF> &oldControlPoints, QVector<QPointF> &newControlPoints, int index)
             {
                 int x = oldPoints.count();
                 int y = newPoints.count();
                 Q_ASSERT(newPoints.count() * 2 - 2 == newControlPoints.count());
                 if (x != y && abs(x - y) != 1) {
                     m_oldSpline.first = newPoints;
                     m_oldSpline.second = newControlPoints;
                     oldPoints.resize(newPoints.size());
                     oldControlPoints.resize(newControlPoints.size());
                     SplineVector oldPair;
                     oldPair.first = oldPoints;
                     oldPair.second = oldControlPoints;
                     SplineVector newPair;
                     newPair.first = newPoints;
                     newPair.second = newControlPoints;
                     setKeyValueAt(0.0, qVariantFromValue(oldPair));
                     setKeyValueAt(1.0, qVariantFromValue(newPair));
                     m_dirty = false;
                 }
                 else {
                     if(m_dirty) {
                         m_oldSpline.first = oldPoints;
                         m_oldSpline.second = oldControlPoints;
                         m_dirty = false;
                     }
                     oldPoints = newPoints;
                     oldControlPoints = newControlPoints;
                     if (y < x) {
                         m_oldSpline.first.remove(index); //remove
                         m_oldSpline.second.remove(index * 2);
                         m_oldSpline.second.remove(index * 2);
                     }
                     if (y > x) {
                         m_oldSpline.first.insert(index, x > 0 ? m_oldSpline.first[index-1] : newPoints[index]); //add
                         m_oldSpline.second.insert((index - 1) * 2, x > 1 ? m_oldSpline.second[(index-2)*2] : newControlPoints[(index - 1) * 2]); //add
                         m_oldSpline.second.insert((index - 1) * 2 + 1, x > 1 ? m_oldSpline.second[(index - 2) * 2 + 1] : newControlPoints[(index - 1) * 2 + 1]); //add
                     }
                     SplineVector newPair;
                     newPair.first=newPoints;
                     newPair.second=newControlPoints;
                     setKeyValueAt(0.0, qVariantFromValue(m_oldSpline));
                     setKeyValueAt(1.0, qVariantFromValue(newPair));
                 }
             }
             QVariant SplineAnimation::interpolated(const QVariant &start, const QVariant &end, qreal progress ) const
             {
                 SplineVector startPair  =  qVariantValue< SplineVector >(start);
                 SplineVector endPair =  qVariantValue< SplineVector >(end);
                 SplineVector result;
                 switch (m_type) {
                 case MoveDownAnimation: {
                     if (startPair.first.count() != endPair.first.count())
                         break;
                     Q_ASSERT(startPair.first.count() * 2 - 2 == startPair.second.count());
                     Q_ASSERT(endPair.first.count() * 2 - 2 == endPair.second.count());
                     for(int i = 0; i < endPair.first.count(); i++) {
                         qreal x = startPair.first[i].x() + ((endPair.first[i].x() - startPair.first[i].x()) * progress);
                         qreal y = startPair.first[i].y() + ((endPair.first[i].y() - startPair.first[i].y()) * progress);
                         result.first << QPointF(x,y);
                         if (i + 1 >= endPair.first.count())
                             continue;
                         x = startPair.second[i * 2].x() + ((endPair.second[i * 2].x() - startPair.second[i * 2].x()) * progress);
                         y = startPair.second[i * 2].y() + ((endPair.second[i * 2].y() - startPair.second[i * 2].y()) * progress);
                         result.second << QPoint(x,y);
                         x = startPair.second[i * 2 + 1].x() + ((endPair.second[i * 2 + 1].x() - startPair.second[i * 2 + 1].x()) * progress);
                         y = startPair.second[i * 2 + 1].y() + ((endPair.second[i * 2 + 1].y() - startPair.second[i * 2 + 1].y()) * progress);
                         result.second << QPoint(x,y);
                     }
                 }
                     break;
                 case LineDrawAnimation:{
                     Q_ASSERT(endPair.first.count() * 2 - 2 == endPair.second.count());
                     int count = endPair.first.count()* qBound(qreal(0), progress, qreal(1));
                     for(int i = 0; i < count; i++) {
                         result.first << endPair.first[i];
                         if(i + 1 == count)
                             break;
                         result.second << endPair.second[2 * i];
                         result.second << endPair.second[2 * i + 1];
                     }
                 }
                     break;
                 default:
                     qWarning() << "Unknow type of animation";
                     break;
                 }
                 return qVariantFromValue(result);
             }
             void SplineAnimation::updateCurrentValue (const QVariant &value )
             {
                 if (state() != QAbstractAnimation::Stopped) { //workaround
                     m_dirty = true;
                     QPair<QVector<QPointF >, QVector<QPointF > > pair = qVariantValue< QPair< QVector<QPointF>, QVector<QPointF> > >(value);
                     m_item->setLayout(pair.first, pair.second);
                 }
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/animations/xyanimation.cpp +1 0

             /****************************************************************************
             **
             ** 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$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "xyanimation_p.h"
             #include "xychartitem_p.h"
+            #include <QDebug>
             Q_DECLARE_METATYPE(QVector<QPointF>)
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             XYAnimation::XYAnimation(XYChartItem *item):ChartAnimation(item),
                 m_item(item),
                 m_dirty(false)
             {
             }
             XYAnimation::~XYAnimation()
             {
             }
             void XYAnimation::setValues(QVector<QPointF> &oldPoints, QVector<QPointF> &newPoints, int index)
             {
                 int x = oldPoints.count();
                 int y = newPoints.count();
                 if (x != y && abs(x - y) != 1) {
                     m_oldPoints = newPoints;
                     oldPoints.resize(newPoints.size());
                     setKeyValueAt(0.0, qVariantFromValue(oldPoints));
                     setKeyValueAt(1.0, qVariantFromValue(newPoints));
                     m_dirty = false;
                 }
                 else {
                     if (m_dirty) {
                         m_oldPoints = oldPoints;
                         m_dirty = false;
                     }
                     oldPoints = newPoints;
                     if (y < x)
                         m_oldPoints.remove(index); //remove
                     if (y > x)
                         m_oldPoints.insert(index, x > 0 ? m_oldPoints[index-1] : newPoints[index]); //add
                     setKeyValueAt(0.0, qVariantFromValue(m_oldPoints));
                     setKeyValueAt(1.0, qVariantFromValue(newPoints));
                     Q_ASSERT(m_oldPoints.count() == newPoints.count());
                 }
             }
             QVariant XYAnimation::interpolated(const QVariant &start, const QVariant &end, qreal progress ) const
             {
                 QVector<QPointF> startVector = qVariantValue<QVector<QPointF> >(start);
                 QVector<QPointF> endVector = qVariantValue<QVector<QPointF> >(end);
                 QVector<QPointF> result;
                 switch (m_type) {
                 case MoveDownAnimation: {
                     if (startVector.count() != endVector.count())
                         break;
                     for(int i = 0; i < startVector.count(); i++) {
                         qreal x = startVector[i].x() + ((endVector[i].x() - startVector[i].x()) * progress);
                         qreal y = startVector[i].y() + ((endVector[i].y() - startVector[i].y()) * progress);
                         result << QPointF(x, y);
                     }
                 }
                     break;
                 case LineDrawAnimation: {
                     for(int i = 0; i < endVector.count() * qBound(qreal(0), progress, qreal(1)); i++)
                         result << endVector[i];
                 }
                     break;
                 default:
                     qWarning() << "Unknown type of animation";
                     break;
                 }
                 return qVariantFromValue(result);
             }
             void XYAnimation::updateCurrentValue (const QVariant &value)
             {
                 if(state()!=QAbstractAnimation::Stopped){ //workaround
                     m_dirty = true;
                     QVector<QPointF> vector = qVariantValue<QVector<QPointF> >(value);
                     m_item->setLayout(vector);
                 }
             }
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/axis.cpp +2 -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$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "axis_p.h"
             #include "qchartaxis.h"
             #include "qchartaxis_p.h"
             #include "qchartaxiscategories_p.h"
             #include "chartpresenter_p.h"
             #include "chartanimator_p.h"
             #include <QPainter>
+            #include <QDebug>
             #include <cmath>
             static int label_padding = 5;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             Axis::Axis(QChartAxis *axis,ChartPresenter *presenter,AxisType type) : Chart(presenter),
                 m_chartAxis(axis),
                 m_type(type),
                 m_labelsAngle(0),
                 m_grid(new QGraphicsItemGroup(presenter->rootItem())),
                 m_shades(new QGraphicsItemGroup(presenter->rootItem())),
                 m_labels(new QGraphicsItemGroup(presenter->rootItem())),
                 m_axis(new QGraphicsItemGroup(presenter->rootItem())),
                 m_min(0),
                 m_max(0),
                 m_ticksCount(0)
             {
                 //initial initialization
                 m_axis->setZValue(ChartPresenter::AxisZValue);
                 m_axis->setHandlesChildEvents(false);
                 m_shades->setZValue(ChartPresenter::ShadesZValue);
                 m_grid->setZValue(ChartPresenter::GridZValue);
                 QObject::connect(m_chartAxis->d_ptr.data(),SIGNAL(updated()),this,SLOT(handleAxisUpdated()));
                 QObject::connect(m_chartAxis->categories()->d_ptr.data(),SIGNAL(updated()),this,SLOT(handleAxisCategoriesUpdated()));
                 handleAxisUpdated();
             }
             Axis::~Axis()
             {
             }
             void Axis::createItems(int count)
             {
                 if (m_axis->children().size() == 0)
                     m_axis->addToGroup(new AxisItem(this));
                 for (int i = 0; i < count; ++i) {
                     m_grid->addToGroup(new QGraphicsLineItem());
                     m_labels->addToGroup(new QGraphicsSimpleTextItem());
                     m_axis->addToGroup(new QGraphicsLineItem());
                     if ((m_grid->childItems().size())%2 && m_grid->childItems().size()>2) m_shades->addToGroup(new QGraphicsRectItem());
                    }
             }
             void Axis::deleteItems(int count)
             {
                 QList<QGraphicsItem *> lines = m_grid->childItems();
                 QList<QGraphicsItem *> labels = m_labels->childItems();
                 QList<QGraphicsItem *> shades = m_shades->childItems();
                 QList<QGraphicsItem *> axis = m_axis->childItems();
                 for (int i = 0; i < count; ++i) {
                     if (lines.size()%2 && lines.size() > 1) delete(shades.takeLast());
                     delete(lines.takeLast());
                     delete(labels.takeLast());
                     delete(axis.takeLast());
                 }
             }
             void Axis::updateLayout(QVector<qreal> &layout)
             {
                 if (animator()) {
                     animator()->updateLayout(this,layout);
                 } else {
                     setLayout(layout);
                 }
             }
             bool Axis::createLabels(QStringList &labels,qreal min, qreal max,int ticks) const
             {
                 Q_ASSERT(max>=min);
                 Q_ASSERT(ticks>1);
                 QChartAxisCategories* categories = m_chartAxis->categories();
                 bool category = categories->count()>0;
                 if (!category) {
                     int n = qMax(int(-floor(log10((max-min)/(ticks-1)))),0);
                     n++;
                     for (int i=0; i< ticks; i++) {
                         qreal value = min + (i * (max - min)/ (ticks-1));
                         labels << QString::number(value,'f',n);
                     }
                 } else {
                     QList<qreal> values = categories->values();
                     for (int i=0; i< ticks; i++) {
                         qreal value = (min + (i * (max - min)/ (ticks-1)));
                         int j=0;
                         for (; j<values.count(); j++) {
                             if (values.at(j) > value) break;
                         }
                         if (j!=0) value=values.at(j-1);
                         QString label = categories->label(value);
                         labels << label;
                     }
                 }
                 return category;
             }
             void Axis::setAxisOpacity(qreal opacity)
             {
                 m_axis->setOpacity(opacity);
             }
             qreal Axis::axisOpacity() const
             {
                 return m_axis->opacity();
             }
             void Axis::setGridOpacity(qreal opacity)
             {
                 m_grid->setOpacity(opacity);
             }
             qreal Axis::gridOpacity() const
             {
                 return m_grid->opacity();
             }
             void Axis::setLabelsOpacity(qreal opacity)
             {
                 m_labels->setOpacity(opacity);
             }
             qreal Axis::labelsOpacity() const
             {
                 return m_labels->opacity();
             }
             void Axis::setShadesOpacity(qreal opacity)
             {
                 m_shades->setOpacity(opacity);
             }
             qreal Axis::shadesOpacity() const
             {
                 return m_shades->opacity();
             }
             void Axis::setLabelsAngle(int angle)
             {
                 foreach(QGraphicsItem* item , m_labels->childItems()) {
                       item->setRotation(angle);
                 }
                 m_labelsAngle=angle;
             }
             void Axis::setLabelsPen(const QPen &pen)
             {
                 foreach(QGraphicsItem* item , m_labels->childItems()) {
                     static_cast<QGraphicsSimpleTextItem*>(item)->setPen(pen);
                 }
             }
             void Axis::setLabelsBrush(const QBrush &brush)
             {
                 foreach(QGraphicsItem* item , m_labels->childItems()) {
                     static_cast<QGraphicsSimpleTextItem*>(item)->setBrush(brush);
                 }
             }
             void Axis::setLabelsFont(const QFont &font)
             {
                 foreach(QGraphicsItem* item , m_labels->childItems()) {
                     static_cast<QGraphicsSimpleTextItem*>(item)->setFont(font);
                 }
             }
             void Axis::setShadesBrush(const QBrush &brush)
             {
                 foreach(QGraphicsItem* item , m_shades->childItems()) {
                     static_cast<QGraphicsRectItem*>(item)->setBrush(brush);
                 }
             }
             void Axis::setShadesPen(const QPen &pen)
             {
                 foreach(QGraphicsItem* item , m_shades->childItems()) {
                     static_cast<QGraphicsRectItem*>(item)->setPen(pen);
                 }
             }
             void Axis::setAxisPen(const QPen &pen)
             {
                 foreach(QGraphicsItem* item , m_axis->childItems()) {
                        static_cast<QGraphicsLineItem*>(item)->setPen(pen);
                 }
             }
             void Axis::setGridPen(const QPen &pen)
             {
                 foreach(QGraphicsItem* item , m_grid->childItems()) {
                     static_cast<QGraphicsLineItem*>(item)->setPen(pen);
                 }
             }
             QVector<qreal> Axis::calculateLayout() const
             {
                 Q_ASSERT(m_ticksCount>=2);
                 QVector<qreal> points;
                 points.resize(m_ticksCount);
                 switch (m_type)
                 {
                     case X_AXIS:
                     {
                         const qreal deltaX = m_rect.width()/(m_ticksCount-1);
                         for (int i = 0; i < m_ticksCount; ++i) {
                              int x = i * deltaX + m_rect.left();
                              points[i] = x;
                         }
                     }
                     break;
                     case Y_AXIS:
                     {
                         const qreal deltaY = m_rect.height()/(m_ticksCount-1);
                         for (int i = 0; i < m_ticksCount; ++i) {
                              int y = i * -deltaY + m_rect.bottom();
                              points[i] = y;
                         }
                     }
                     break;
                 }
                 return points;
             }
             void Axis::setLayout(QVector<qreal> &layout)
             {
             	int diff = m_layoutVector.size() - layout.size();
                 if (diff>0) {
             		deleteItems(diff);
                 } else if (diff<0) {
             		createItems(-diff);
             	}
                 if( diff!=0) handleAxisUpdated();
             	QStringList ticksList;
                 bool categories = createLabels(ticksList,m_min,m_max,layout.size());
                 QList<QGraphicsItem *> lines = m_grid->childItems();
                 QList<QGraphicsItem *> labels = m_labels->childItems();
                 QList<QGraphicsItem *> shades = m_shades->childItems();
                 QList<QGraphicsItem *> axis = m_axis->childItems();
             	Q_ASSERT(labels.size() == ticksList.size());
             	Q_ASSERT(layout.size() == ticksList.size());
             	qreal minWidth = 0;
             	qreal minHeight = 0;
             	switch (m_type)
             	{
             		case X_AXIS:
             		{
             			QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(axis.at(0));
             			lineItem->setLine(m_rect.left(), m_rect.bottom(), m_rect.right(), m_rect.bottom());
             			for (int i = 0; i < layout.size(); ++i) {
             				QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(lines.at(i));
             				lineItem->setLine(layout[i], m_rect.top(), layout[i], m_rect.bottom());
             				QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem*>(labels.at(i));
                             if (!categories || i<1) {
             				    labelItem->setText(ticksList.at(i));
             				    const QRectF& rect = labelItem->boundingRect();
             				    minWidth+=rect.width();
             				    minHeight=qMax(rect.height(),minHeight);
             				    QPointF center = rect.center();
             				    labelItem->setTransformOriginPoint(center.x(), center.y());
             				    labelItem->setPos(layout[i] - center.x(), m_rect.bottom() + label_padding);
                             } else {
             				    labelItem->setText(ticksList.at(i));
             			        const QRectF& rect = labelItem->boundingRect();
             			        minWidth+=rect.width();
             			        minHeight=qMax(rect.height()+label_padding,minHeight);
             				    QPointF center = rect.center();
             				    labelItem->setTransformOriginPoint(center.x(), center.y());
             				    labelItem->setPos(layout[i] - (layout[i] - layout[i-1])/2 - center.x(), m_rect.bottom() + label_padding);
             				}
                             if ((i+1)%2 && i>1) {
             					QGraphicsRectItem *rectItem = static_cast<QGraphicsRectItem*>(shades.at(i/2-1));
             					rectItem->setRect(layout[i-1],m_rect.top(),layout[i]-layout[i-1],m_rect.height());
             				}
             				lineItem = static_cast<QGraphicsLineItem*>(axis.at(i+1));
             				lineItem->setLine(layout[i],m_rect.bottom(),layout[i],m_rect.bottom()+5);
             			}
             		}
             		break;
             		case Y_AXIS:
             		{
             			QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(axis.at(0));
             			lineItem->setLine(m_rect.left() , m_rect.top(), m_rect.left(), m_rect.bottom());
             			for (int i = 0; i < layout.size(); ++i) {
             				QGraphicsLineItem *lineItem = static_cast<QGraphicsLineItem*>(lines.at(i));
             				lineItem->setLine(m_rect.left() , layout[i], m_rect.right(), layout[i]);
             				QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem*>(labels.at(i));
                             if (!categories || i<1) {
             				    labelItem->setText(ticksList.at(i));
             				    const QRectF& rect = labelItem->boundingRect();
             				    minWidth=qMax(rect.width()+label_padding,minWidth);
             				    minHeight+=rect.height();
             				    QPointF center = rect.center();
             				    labelItem->setTransformOriginPoint(center.x(), center.y());
             				    labelItem->setPos(m_rect.left() - rect.width() - label_padding , layout[i]-center.y());
                             } else {
             				    labelItem->setText(ticksList.at(i));
             				    const QRectF& rect = labelItem->boundingRect();
             				    minWidth=qMax(rect.width(),minWidth);
             				    minHeight+=rect.height();
             				    QPointF center = rect.center();
             				    labelItem->setTransformOriginPoint(center.x(), center.y());
             				    labelItem->setPos(m_rect.left() - rect.width() - label_padding , layout[i] - (layout[i] - layout[i-1])/2 -center.y());
             				}
                             if ((i+1)%2 && i>1) {
             					QGraphicsRectItem *rectItem = static_cast<QGraphicsRectItem*>(shades.at(i/2-1));
             					rectItem->setRect(m_rect.left(),layout[i],m_rect.width(),layout[i-1]-layout[i]);
             				}
             				lineItem = static_cast<QGraphicsLineItem*>(axis.at(i+1));
             				lineItem->setLine(m_rect.left()-5,layout[i],m_rect.left(),layout[i]);
             			}
             		}
             		break;
             		default:
-                    qDebug()<<"Unknown axis type";
+            		    qWarning()<<"Unknown axis type";
             		break;
             	}
                 m_layoutVector=layout;
                 presenter()->setMinimumMarginWidth(this,minWidth);
                 presenter()->setMinimumMarginHeight(this,minHeight);
             }
             bool Axis::isEmpty()
             {
                 return m_rect.isEmpty() || qFuzzyIsNull(m_min - m_max) || m_ticksCount==0;
             }
             //handlers
             void Axis::handleAxisCategoriesUpdated()
             {
                 if (isEmpty()) return;
             	updateLayout(m_layoutVector);
             }
             void Axis::handleAxisUpdated()
             {
                 if (isEmpty()) return;
                 if (m_chartAxis->isAxisVisible()) {
                     setAxisOpacity(100);
                 } else {
                     setAxisOpacity(0);
                 }
                 if (m_chartAxis->isGridLineVisible()) {
                     setGridOpacity(100);
                 } else {
                     setGridOpacity(0);
                 }
                 if (m_chartAxis->labelsVisible()) {
                     setLabelsOpacity(100);
                 } else {
                     setLabelsOpacity(0);
                 }
                 if (m_chartAxis->shadesVisible()) {
                     setShadesOpacity(m_chartAxis->shadesOpacity());
                 } else {
                     setShadesOpacity(0);
                 }
                 setLabelsAngle(m_chartAxis->labelsAngle());
                 setAxisPen(m_chartAxis->axisPen());
                 setLabelsPen(m_chartAxis->labelsPen());
                 setLabelsBrush(m_chartAxis->labelsBrush());
                 setLabelsFont(m_chartAxis->labelsFont());
                 setGridPen(m_chartAxis->gridLinePen());
                 setShadesPen(m_chartAxis->shadesPen());
                 setShadesBrush(m_chartAxis->shadesBrush());
             }
             void Axis::handleRangeChanged(qreal min, qreal max,int tickCount)
             {
                 if (qFuzzyIsNull(min - max) || tickCount < 2)
                     return;
                 m_min = min;
                 m_max = max;
                 m_ticksCount= tickCount;
                 if (isEmpty()) return;
                 QVector<qreal> layout = calculateLayout();
                 updateLayout(layout);
             }
             void Axis::handleGeometryChanged(const QRectF &rect)
             {
                 if(m_rect != rect)
                 {
                     m_rect = rect;
                     if (isEmpty()) return;
                     QVector<qreal> layout = calculateLayout();
                     updateLayout(layout);
                 }
             }
             void Axis::axisSelected()
             {
                 qDebug()<<"TODO: axis clicked";
             }
             #include "moc_axis_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/qchartaxiscategories_p.h +1 0

             /****************************************************************************
             **
             ** 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$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             //  W A R N I N G
             //  -------------
             //
             // This file is not part of the QtCommercial Chart API.  It exists purely as an
             // implementation detail.  This header file may change from version to
             // version without notice, or even be removed.
             //
             // We mean it.
             #ifndef QCHARTAXISCATEGORIES_P_H
             #define QCHARTAXISCATEGORIES_P_H
             #include "qchartaxiscategories.h"
+            #include <QMap>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QChartAxisCategoriesPrivate : public QObject
             {
                 Q_OBJECT
             public:
                 QChartAxisCategoriesPrivate(QChartAxisCategories *q);
                 ~QChartAxisCategoriesPrivate();
             Q_SIGNALS:
                 void updated();
             private:
                 QChartAxisCategories *q_ptr;
                 QMap<qreal,QString> m_map;
                 friend class QChartAxisCategories;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/barchart/qbarset_p.h +1 0

             #ifndef QBARSET_P_H
             #define QBARSET_P_H
             #include "qbarset.h"
+            #include <QMap>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QBarSetPrivate : public QObject
             {
                 Q_OBJECT
             public:
                 QBarSetPrivate(const QString name, QBarSet *parent);
                 ~QBarSetPrivate();
             Q_SIGNALS:
                 void clicked(QString category, Qt::MouseButtons button);
                 void structureChanged();
                 void valueChanged();
                 void labelsVisibleChanged(bool visible);
             public:
                 QBarSet * const q_ptr;
                 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_labelPen;
                 QBrush m_labelBrush;
                 QFont m_labelFont;
                 bool m_labelsVisible;
                 friend class QBarSet;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QBARSETPRIVATE_P_H

src/chart.cpp +1 0

             /****************************************************************************
             **
             ** 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$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "chart_p.h"
             #include "chartpresenter_p.h"
+            #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             Chart::Chart(ChartPresenter *presenter):QObject(presenter),
                 m_animator(0),
                 m_presenter(presenter)
             {
             }
             void Chart::setAnimator(ChartAnimator* animator)
             {
                 m_animator=animator;
             }
             ChartAnimator* Chart::animator() const
             {
                 return m_animator;
             }
             ChartPresenter* Chart::presenter() const
             {
                 return m_presenter;
             }
             void Chart::handleGeometryChanged(const QRectF& rect)
             {
                 Q_UNUSED(rect);
                 qWarning()<<"Slot not implemented";
             }
             void Chart::handleDomainChanged(qreal minX,qreal maxX,qreal minY,qreal maxY)
             {
                 Q_UNUSED(minX);
                 Q_UNUSED(maxX);
                 Q_UNUSED(minY);
                 Q_UNUSED(maxY);
                 qWarning()<<"Slot not implemented";
             }
             void Chart::rangeXChanged(qreal min, qreal max, int tickXCount)
             {
                 Q_UNUSED(min);
                 Q_UNUSED(max);
                 Q_UNUSED(tickXCount);
                 qWarning()<<"Slot not implemented";
             }
             void Chart::rangeYChanged(qreal min, qreal max, int tickYCount)
             {
                 Q_UNUSED(min);
                 Q_UNUSED(max);
                 Q_UNUSED(tickYCount);
                 qWarning()<<"Slot not implemented";
             }
             #include "moc_chart_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/chart_p.h +1 0

             /****************************************************************************
             **
             ** 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$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #ifndef CHART_H
             #define CHART_H
             #include "qchartglobal.h"
+            #include <QObject>
             #include <QRect>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class ChartAnimator;
             class ChartPresenter;
             class Chart: public QObject
             {
                 Q_OBJECT
             public:
                 explicit Chart(ChartPresenter *presenter);
             public Q_SLOTS:
                 virtual void handleGeometryChanged(const QRectF& rect);
                 virtual void handleDomainChanged(qreal minX,qreal maxX,qreal minY,qreal maxY);
                 virtual void rangeXChanged(qreal min, qreal max, int tickXCount);
                 virtual void rangeYChanged(qreal min, qreal max, int tickYCount);
                 void setAnimator(ChartAnimator* animator);
                 ChartAnimator* animator() const;
                 ChartPresenter* presenter() const;
             private:
                 ChartAnimator* m_animator;
                 ChartPresenter* m_presenter;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/chartconfig_p.h +7 -3

             /****************************************************************************
             **
             ** 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$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #ifndef CHARTCONFIG_H
             #define CHARTCONFIG_H
             #include "qchartglobal.h"
             #ifdef Q_CC_MSVC
             // There is a problem with jom.exe currently. It does not seem to understand QMAKE_EXTRA_TARGETS properly.
             // This is the case at least with shadow builds.
             // http://qt-project.org/wiki/jom
-            const char *buildTime = __DATE__;
+            #undef DEVELOPER_BUILD
+            #endif
+            #ifndef DEVELOPER_BUILD
+            const char *buildTime =  __TIME__" "__DATE__;
             const char *gitHead = "unknown";
             #else
             #include "qchartversion_p.h"
             #endif
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class ChartConfig {
             private:
                 ChartConfig(){
-                #ifndef QT_NO_DEBUG
+                #if defined(DEVELOPMENT_BUILD) && !defined(QT_NO_DEBUG)
                     qDebug()<<"buildTime" << buildTime;
                     qDebug()<<"gitHead" << gitHead;
                 #endif
                     m_instance = this;
                 }
             public:
                 static ChartConfig* instance(){
                     if(!m_instance){
                         m_instance= new ChartConfig();
                     }
                     return m_instance;
                 }
                 QString compilationTime(){
                     return buildTime;
                 }
                 QString compilationHead(){
                     return gitHead;
                 }
             private:
                 static ChartConfig* m_instance;
             };
             ChartConfig* ChartConfig::m_instance=0;
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/domain_p.h +1 0

             /****************************************************************************
             **
             ** 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$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #ifndef DOMAIN_H
             #define DOMAIN_H
             #include "qchartglobal.h"
             #include <QRectF>
             #include <QSizeF>
+            #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class Domain: public QObject {
                 Q_OBJECT
             public:
                 explicit Domain(QObject* object=0);
                 virtual ~Domain();
                 void setRange(qreal minX, qreal maxX, qreal minY, qreal maxY);
                 void setRange(qreal minX, qreal maxX, qreal minY, qreal maxY, int tickXCount, int tickYCount);
                 void setRangeX(qreal min, qreal max);
                 void setRangeX(qreal min, qreal max, int tickCount);
                 void setRangeY(qreal min, qreal max);
                 void setRangeY(qreal min, qreal max, int tickCount);
                 void setMinX(qreal min);
                 void setMaxX(qreal max);
                 void setMinY(qreal min);
                 void setMaxY(qreal max);
                 qreal minX() const { return m_minX; }
                 qreal maxX() const { return m_maxX; }
                 qreal minY() const { return m_minY; }
                 qreal maxY() const { return m_maxY; }
                 qreal spanX() const;
                 qreal spanY() const;
                 bool isEmpty() const;
                 int tickXCount() const {return m_tickXCount;}
                 int tickYCount() const {return m_tickYCount;}
                 friend bool operator== (const Domain &domain1, const Domain &domain2);
                 friend bool operator!= (const Domain &domain1, const Domain &domain2);
                 friend QDebug operator<<(QDebug dbg, const Domain &domain);
                 void zoomIn(const QRectF& rect, const QSizeF& size);
                 void zoomOut(const QRectF& rect, const QSizeF& size);
                 void move(int dx,int dy,const QSizeF& size);
             Q_SIGNALS:
                 void domainChanged(qreal minX, qreal maxX, qreal minY, qreal maxY);
                 void rangeXChanged(qreal min, qreal max, int tickXCount);
                 void rangeYChanged(qreal min, qreal max, int tickYCount);
             public Q_SLOTS:
                 void handleAxisXChanged(qreal min,qreal max,int tickXCount = 5,bool niceNumbers = false);
                 void handleAxisYChanged(qreal min,qreal max,int tickYCount = 5,bool niceNumbers = false);
             private:
                 void looseNiceNumbers(qreal &min, qreal &max, int &ticksCount);
                 qreal niceNumber(qreal x,bool celing);
             private:
                 qreal m_minX;
                 qreal m_maxX;
                 qreal m_minY;
                 qreal m_maxY;
                 int m_tickXCount;
                 int m_tickYCount;
                 bool m_niceNumbers;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/piechart/piechartitem.cpp 0 -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$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "piechartitem_p.h"
             #include "piesliceitem_p.h"
             #include "qpieslice.h"
             #include "qpieseries.h"
             #include "chartpresenter_p.h"
             #include "chartdataset_p.h"
             #include "chartanimator_p.h"
-            #include <QDebug>
             #include <QPainter>
             #include <QTimer>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             PieChartItem::PieChartItem(QPieSeries *series, ChartPresenter* presenter)
                 :ChartItem(presenter),
                 m_series(series)
             {
                 Q_ASSERT(series);
                 connect(series, SIGNAL(added(QList<QPieSlice*>)), this, SLOT(handleSlicesAdded(QList<QPieSlice*>)));
                 connect(series, SIGNAL(removed(QList<QPieSlice*>)), this, SLOT(handleSlicesRemoved(QList<QPieSlice*>)));
                 connect(series, SIGNAL(piePositionChanged()), this, SLOT(handlePieLayoutChanged()));
                 connect(series, SIGNAL(pieSizeChanged()), this, SLOT(handlePieLayoutChanged()));
                 QTimer::singleShot(0, this, SLOT(initialize())); // TODO: get rid of this
                 // Note: the following does not affect as long as the item does not have anything to paint
                 setZValue(ChartPresenter::PieSeriesZValue);
             }
             PieChartItem::~PieChartItem()
             {
                 // slices deleted automatically through QGraphicsItem
             }
             void PieChartItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *, QWidget *)
             {
                 Q_UNUSED(painter)
                 // TODO: paint shadows for all components
                 // - get paths from items & merge & offset and draw with shadow color?
                 //painter->setBrush(QBrush(Qt::red));
                 //painter->drawRect(m_debugRect);
             }
             void PieChartItem::initialize()
             {
                 handleSlicesAdded(m_series->slices());
             }
             void PieChartItem::handleSlicesAdded(QList<QPieSlice*> slices)
             {
                 bool isEmpty = m_slices.isEmpty();
                 presenter()->chartTheme()->decorate(m_series, presenter()->dataSet()->seriesIndex(m_series));
                 foreach (QPieSlice *s, slices) {
                     PieSliceItem* item = new PieSliceItem(this);
                     m_slices.insert(s, item);
                     connect(s, SIGNAL(changed()), this, SLOT(handleSliceChanged()));
                     connect(item, SIGNAL(clicked(Qt::MouseButtons)), s, SIGNAL(clicked(Qt::MouseButtons)));
                     connect(item, SIGNAL(hoverEnter()), s, SIGNAL(hoverEnter()));
                     connect(item, SIGNAL(hoverLeave()), s, SIGNAL(hoverLeave()));
                     PieSliceData data = sliceData(s);
                     if (animator())
                         animator()->addAnimation(this, s, data, isEmpty);
                     else
                         setLayout(s, data);
                 }
             }
             void PieChartItem::handleSlicesRemoved(QList<QPieSlice*> slices)
             {
                 presenter()->chartTheme()->decorate(m_series, presenter()->dataSet()->seriesIndex(m_series));
                 foreach (QPieSlice *s, slices) {
                     if (animator())
                         animator()->removeAnimation(this, s);
                     else
                         destroySlice(s);
                 }
             }
             void PieChartItem::handlePieLayoutChanged()
             {
                 PieLayout layout = calculateLayout();
                 applyLayout(layout);
                 update();
             }
             void PieChartItem::handleSliceChanged()
             {
                 QPieSlice* slice = qobject_cast<QPieSlice *>(sender());
                 Q_ASSERT(m_slices.contains(slice));
                 PieSliceData data = sliceData(slice);
                 updateLayout(slice, data);
                 update();
             }
             void PieChartItem::handleDomainChanged(qreal, qreal, qreal, qreal)
             {
                 // TODO
             }
             void PieChartItem::handleGeometryChanged(const QRectF& rect)
             {
                 prepareGeometryChange();
                 m_rect = rect;
                 handlePieLayoutChanged();
             }
             void PieChartItem::calculatePieLayout()
             {
                 // find pie center coordinates
                 m_pieCenter.setX(m_rect.left() + (m_rect.width() * m_series->horizontalPosition()));
                 m_pieCenter.setY(m_rect.top() + (m_rect.height() * m_series->verticalPosition()));
                 // find maximum radius for pie
                 m_pieRadius = m_rect.height() / 2;
                 if (m_rect.width() < m_rect.height())
                     m_pieRadius = m_rect.width() / 2;
                 // apply size factor
                 m_pieRadius *= m_series->pieSize();
             }
             PieSliceData PieChartItem::sliceData(QPieSlice *slice)
             {
             	// TODO: This function is kid of useless now. Refactor.
                 PieSliceData sliceData = PieSliceData::data(slice);
                 sliceData.m_center = PieSliceItem::sliceCenter(m_pieCenter, m_pieRadius, slice);
                 sliceData.m_radius = m_pieRadius;
                 return sliceData;
             }
             PieLayout PieChartItem::calculateLayout()
             {
                 calculatePieLayout();
                 PieLayout layout;
                 foreach (QPieSlice* s, m_series->slices()) {
                     if (m_slices.contains(s)) // calculate layout only for those slices that are already visible
                         layout.insert(s, sliceData(s));
                 }
                 return layout;
             }
             void PieChartItem::applyLayout(const PieLayout &layout)
             {
                 if (animator())
                     animator()->updateLayout(this, layout);
                 else
                     setLayout(layout);
             }
             void PieChartItem::updateLayout(QPieSlice *slice, const PieSliceData &sliceData)
             {
                 if (animator())
                     animator()->updateLayout(this, slice, sliceData);
                 else
                     setLayout(slice, sliceData);
             }
             void PieChartItem::setLayout(const PieLayout &layout)
             {
                 foreach (QPieSlice *slice, layout.keys()) {
                     PieSliceItem *item = m_slices.value(slice);
                     Q_ASSERT(item);
                     item->setSliceData(layout.value(slice));
                     item->updateGeometry();
                     item->update();
                 }
             }
             void PieChartItem::setLayout(QPieSlice *slice, const PieSliceData &sliceData)
             {
                 // find slice
                 PieSliceItem *item = m_slices.value(slice);
                 Q_ASSERT(item);
                 item->setSliceData(sliceData);
                 item->updateGeometry();
                 item->update();
             }
             void PieChartItem::destroySlice(QPieSlice *slice)
             {
                 delete m_slices.take(slice);
             }
             #include "moc_piechartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/piechart/pieslicedata_p.h 0 -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$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #ifndef PIESLICEDATA_P_H
             #define PIESLICEDATA_P_H
             #include "qchartglobal.h"
             #include "qpieslice.h"
             #include <QPen>
             #include <QBrush>
-            #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             template <class T>
             class Themed : public T
             {
             public:
                 Themed():m_isThemed(true) {}
                 inline T &operator=(const T &other) { return T::operator =(other); }
                 inline bool operator!=(const T &other) const { return T::operator !=(other); }
                 inline bool operator!=(const Themed &other) const
                 {
                     if (T::operator !=(other))
                         return true;
                     if (m_isThemed != other.m_isThemed)
                         return true;
                     return false;
                 }
                 inline void setThemed(bool state) { m_isThemed = state; }
                 inline bool isThemed() const { return m_isThemed; }
             private:
                 bool m_isThemed;
             };
             class PieSliceData
             {
             public:
                 PieSliceData()
                 {
                     m_value = 0;
                     m_isExploded = false;
                     m_explodeDistanceFactor = 0.15;
                     m_isLabelVisible = false;
                     m_labelArmLengthFactor = 0.15;
                     m_percentage = 0;
                     m_radius = 0;
                     m_startAngle = 0;
                     m_angleSpan = 0;
                 }
                 bool operator!=(const PieSliceData &other) const
                 {
                     if (!qFuzzyIsNull(m_value - other.m_value))
                         return true;
                     if (m_slicePen != other.m_slicePen ||
                         m_sliceBrush != other.m_sliceBrush)
                         return true;
                     if (m_isExploded != other.m_isExploded ||
                         !qFuzzyIsNull(m_explodeDistanceFactor - other.m_explodeDistanceFactor))
                         return true;
                     if (m_isLabelVisible != other.m_isLabelVisible ||
                         m_labelText != other.m_labelText ||
                         m_labelFont != other.m_labelFont ||
                         !qFuzzyIsNull(m_labelArmLengthFactor - other.m_labelArmLengthFactor) ||
                         m_labelPen != other.m_labelPen)
                         return true;
                     if (!qFuzzyIsNull(m_percentage - other.m_percentage) ||
                         m_center != other.m_center ||
                         !qFuzzyIsNull(m_radius - other.m_radius) ||
                         !qFuzzyIsNull(m_startAngle - other.m_startAngle) ||
                         !qFuzzyIsNull(m_angleSpan - other.m_angleSpan))
                         return true;
                     return false;
                 }
                 void emitChangedSignal(QPieSlice *s)
                 {
                     emit s->changed();
                 }
                 static PieSliceData &data(QPieSlice *slice)
                 {
                     Q_ASSERT(slice);
                     return *slice->d;
                 }
                 qreal m_value;
                 Themed<QPen> m_slicePen;
                 Themed<QBrush> m_sliceBrush;
                 bool m_isExploded;
                 qreal m_explodeDistanceFactor;
                 bool m_isLabelVisible;
                 QString m_labelText;
                 Themed<QFont> m_labelFont;
                 qreal m_labelArmLengthFactor;
                 Themed<QPen> m_labelPen;
                 qreal m_percentage;
                 QPointF m_center;
                 qreal m_radius;
                 qreal m_startAngle;
                 qreal m_angleSpan;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // PIESLICEDATA_P_H

src/piechart/piesliceitem.cpp 0 -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$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "piesliceitem_p.h"
             #include "piechartitem_p.h"
             #include "qpieseries.h"
             #include "qpieslice.h"
             #include "chartpresenter_p.h"
             #include <QPainter>
-            #include <QDebug>
             #include <qmath.h>
             #include <QGraphicsSceneEvent>
             #include <QTime>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             #define PI 3.14159265 // TODO: is this defined in some header?
             QPointF offset(qreal angle, qreal length)
             {
                 qreal dx = qSin(angle*(PI/180)) * length;
                 qreal dy = qCos(angle*(PI/180)) * length;
                 return QPointF(dx, -dy);
             }
             PieSliceItem::PieSliceItem(QGraphicsItem* parent)
                 :QGraphicsObject(parent)
             {
                 setAcceptHoverEvents(true);
                 setAcceptedMouseButtons(Qt::MouseButtonMask);
                 setZValue(ChartPresenter::PieSeriesZValue);
             }
             PieSliceItem::~PieSliceItem()
             {
             }
             QRectF PieSliceItem::boundingRect() const
             {
                 return m_boundingRect;
             }
             QPainterPath PieSliceItem::shape() const
             {
                 // Don't include the label and label arm.
                 // This is used to detect a mouse clicks. We do not want clicks from label.
                 return m_slicePath;
             }
             void PieSliceItem::paint(QPainter* painter, const QStyleOptionGraphicsItem* /*option*/, QWidget* /*widget*/)
             {
                 painter->save();
                 painter->setClipRect(parentItem()->boundingRect());
                 painter->setPen(m_data.m_slicePen);
                 painter->setBrush(m_data.m_sliceBrush);
                 painter->drawPath(m_slicePath);
                 painter->restore();
                 if (m_data.m_isLabelVisible) {
                     painter->setClipRect(parentItem()->boundingRect());
                     painter->setPen(m_data.m_labelPen);
                     painter->drawPath(m_labelArmPath);
             		// the pen color will affect the font color as well
                     painter->setFont(m_data.m_labelFont);
                     painter->drawText(m_labelTextRect.bottomLeft(), m_data.m_labelText);
                 }
             }
             void PieSliceItem::hoverEnterEvent(QGraphicsSceneHoverEvent* /*event*/)
             {
                 emit hoverEnter(); // TODO: refactor emit hover(somebooleanvalue)
             }
             void PieSliceItem::hoverLeaveEvent(QGraphicsSceneHoverEvent* /*event*/)
             {
                 emit hoverLeave(); // TODO: refactor emit hover(somebooleanvalue)
             }
             void PieSliceItem::mousePressEvent(QGraphicsSceneMouseEvent *event)
             {
                 emit clicked(event->buttons());
             }
             void PieSliceItem::setSliceData(PieSliceData sliceData)
             {
                 m_data = sliceData;
             }
             void PieSliceItem::updateGeometry()
             {
                 if (m_data.m_radius <= 0)
                     return;
                 prepareGeometryChange();
                 // update slice path
                 qreal centerAngle;
                 QPointF armStart;
                 m_slicePath = slicePath(m_data.m_center, m_data.m_radius, m_data.m_startAngle, m_data.m_angleSpan, &centerAngle, &armStart);
                 // update text rect
                 m_labelTextRect = labelTextRect(m_data.m_labelFont, m_data.m_labelText);
                 // update label arm path
                 QPointF labelTextStart;
                 m_labelArmPath = labelArmPath(armStart, centerAngle, m_data.m_radius * m_data.m_labelArmLengthFactor, m_labelTextRect.width(), &labelTextStart);
                 // update text position
                 m_labelTextRect.moveBottomLeft(labelTextStart);
                 // update bounding rect
                 if (m_data.m_isLabelVisible)
                     m_boundingRect = m_slicePath.boundingRect().united(m_labelArmPath.boundingRect()).united(m_labelTextRect);
                 else
                     m_boundingRect = m_slicePath.boundingRect();
             }
             QPointF PieSliceItem::sliceCenter(QPointF point, qreal radius, QPieSlice *slice)
             {
                 if (slice->isExploded()) {
                     qreal centerAngle = slice->startAngle() + ((slice->endAngle() - slice->startAngle())/2);
                     qreal len = radius * slice->explodeDistanceFactor();
                     qreal dx = qSin(centerAngle*(PI/180)) * len;
                     qreal dy = -qCos(centerAngle*(PI/180)) * len;
                     point += QPointF(dx, dy);
                 }
                 return point;
             }
             QPainterPath PieSliceItem::slicePath(QPointF center, qreal radius, qreal startAngle, qreal angleSpan, qreal *centerAngle, QPointF* armStart)
             {
                 // calculate center angle
                 *centerAngle = startAngle + (angleSpan/2);
                 // calculate slice rectangle
                 QRectF rect(center.x()-radius, center.y()-radius, radius*2, radius*2);
                 // slice path
                 // TODO: draw the shape so that it might have a hole in the center
                 QPainterPath path;
                 path.moveTo(rect.center());
                 path.arcTo(rect, -startAngle + 90, -angleSpan);
                 path.closeSubpath();
                 // calculate label arm start point
                 *armStart = center;
                 *armStart += offset(*centerAngle, radius + PIESLICE_LABEL_GAP);
                 return path;
             }
             QPainterPath PieSliceItem::labelArmPath(QPointF start, qreal angle, qreal length, qreal textWidth, QPointF *textStart)
             {
                 // prevent label arm pointing straight down because it will look bad
                 if (angle < 180 && angle > 170)
                     angle = 170;
                 if (angle > 180 && angle < 190)
                     angle = 190;
                 // line from slice to label
                 qreal dx = qSin(angle*(PI/180)) * length;
                 qreal dy = -qCos(angle*(PI/180)) * length;
                 QPointF parm1 = start + QPointF(dx, dy);
                 // line to underline the label
                 QPointF parm2 = parm1;
                 if (angle < 180) { // arm swings the other way on the left side
                      parm2 += QPointF(textWidth, 0);
                      *textStart = parm1;
                 }
                 else {
                      parm2 += QPointF(-textWidth,0);
                      *textStart = parm2;
                 }
                 // elevate the text position a bit so that it does not hit the line
                 *textStart += QPointF(0, -3);
                 QPainterPath path;
                 path.moveTo(start);
                 path.lineTo(parm1);
                 path.lineTo(parm2);
                 return path;
             }
             QRectF PieSliceItem::labelTextRect(QFont font, QString text)
             {
                 QFontMetricsF fm(font);
                 return fm.boundingRect(text);
             }
             #include "moc_piesliceitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/piechart/qpieseries.cpp 0 -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$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "qpieseries.h"
             #include "qpieseries_p.h"
             #include "qpieslice.h"
             #include "pieslicedata_p.h"
             #include "chartdataset_p.h"
             #include "charttheme_p.h"
             #include "chartanimator_p.h"
             #include "legendmarker_p.h"
             #include <QAbstractItemModel>
-            #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             /*!
                 \class QPieSeries
                 \brief Pie series API for QtCommercial Charts
                 The pie series defines a pie chart which consists of pie slices which are defined as QPieSlice objects.
                 The slices can have any values as the QPieSeries will calculate its relative value to the sum of all slices.
                 The actual slice size is determined by that relative value.
                 Pie size and position on the chart is controlled by using relative values which range from 0.0 to 1.0
                 These relate to the actual chart rectangle.
                 By default the pie is defined as a full pie but it can also be a partial pie.
                 This can be done by setting a starting angle and angle span to the series.
                 Full pie is 360 degrees where 0 is at 12 a'clock.
                 See the \l {PieChart Example} {pie chart example} to learn how to create a simple pie chart.
                 \image examples_piechart.png
             */
             /*!
                 \property QPieSeries::horizontalPosition
                 \brief Defines the horizontal position of the pie.
                 The value is a relative value to the chart rectangle where:
                 \list
                 \o 0.0 is the absolute left.
                 \o 1.0 is the absolute right.
                 \endlist
                 Default value is 0.5 (center).
             */
             /*!
                 \property QPieSeries::verticalPosition
                 \brief Defines the vertical position of the pie.
                 The value is a relative value to the chart rectangle where:
                 \list
                 \o 0.0 is the absolute top.
                 \o 1.0 is the absolute bottom.
                 \endlist
                 Default value is 0.5 (center).
             */
             /*!
                 \property QPieSeries::size
                 \brief Defines the pie size.
                 The value is a relative value to the chart rectangle where:
                 \list
                 \o 0.0 is the minimum size (pie not drawn).
                 \o 1.0 is the maximum size that can fit the chart.
                 \endlist
                 Default value is 0.7.
             */
             /*!
                 \property QPieSeries::startAngle
                 \brief Defines the starting angle of the pie.
                 Full pie is 360 degrees where 0 degrees is at 12 a'clock.
                 Default is value is 0.
             */
             /*!
                 \property QPieSeries::endAngle
                 \brief Defines the ending angle of the pie.
                 Full pie is 360 degrees where 0 degrees is at 12 a'clock.
                 Default is value is 360.
             */
             /*!
                 Constructs a series object which is a child of \a parent.
             */
             QPieSeries::QPieSeries(QObject *parent) :
                 QAbstractSeries(*new QPieSeriesPrivate(this),parent)
             {
             }
             /*!
                 Destroys the series and its slices.
             */
             QPieSeries::~QPieSeries()
             {
                 // NOTE: d_prt destroyed by QObject
             }
             /*!
                 Returns QChartSeries::SeriesTypePie.
             */
             QAbstractSeries::QSeriesType QPieSeries::type() const
             {
                 return QAbstractSeries::SeriesTypePie;
             }
             /*!
                 Sets an array of \a slices to the series replacing the existing slices.
                 Slice ownership is passed to the series.
             */
             void QPieSeries::replace(QList<QPieSlice*> slices)
             {
                 clear();
                 append(slices);
             }
             /*!
                 Appends an array of \a slices to the series.
                 Slice ownership is passed to the series.
             */
             void QPieSeries::append(QList<QPieSlice*> slices)
             {
                 Q_D(QPieSeries);
                 foreach (QPieSlice* s, slices) {
                     s->setParent(this);
                     d->m_slices << s;
                 }
                 d->updateDerivativeData();
                 foreach (QPieSlice* s, slices) {
                     connect(s, SIGNAL(changed()), d, SLOT(sliceChanged()));
                     connect(s, SIGNAL(clicked(Qt::MouseButtons)), d, SLOT(sliceClicked(Qt::MouseButtons)));
                     connect(s, SIGNAL(hoverEnter()), d, SLOT(sliceHoverEnter()));
                     connect(s, SIGNAL(hoverLeave()), d, SLOT(sliceHoverLeave()));
                 }
                 emit added(slices);
             }
             /*!
                 Appends a single \a slice to the series.
                 Slice ownership is passed to the series.
             */
             void QPieSeries::append(QPieSlice* slice)
             {
                 append(QList<QPieSlice*>() << slice);
             }
             /*!
                 Appends a single \a slice to the series and returns a reference to the series.
                 Slice ownership is passed to the series.
             */
             QPieSeries& QPieSeries::operator << (QPieSlice* slice)
             {
                 append(slice);
                 return *this;
             }
             /*!
                 Appends a single slice to the series with give \a value and \a name.
                 Slice ownership is passed to the series.
             */
             QPieSlice* QPieSeries::append(qreal value, QString name)
             {
                 QPieSlice* slice = new QPieSlice(value, name);
                 append(slice);
                 return slice;
             }
             /*!
                 Inserts a single \a slice to the series before the slice at \a index position.
                 Slice ownership is passed to the series.
             */
             void QPieSeries::insert(int index, QPieSlice* slice)
             {
                 Q_D(QPieSeries);
                 Q_ASSERT(index <= d->m_slices.count());
                 slice->setParent(this);
                 d->m_slices.insert(index, slice);
                 d->updateDerivativeData();
                 connect(slice, SIGNAL(changed()), d, SLOT(sliceChanged()));
                 connect(slice, SIGNAL(clicked(Qt::MouseButtons)), d, SLOT(sliceClicked(Qt::MouseButtons)));
                 connect(slice, SIGNAL(hoverEnter()), d, SLOT(sliceHoverEnter()));
                 connect(slice, SIGNAL(hoverLeave()), d, SLOT(sliceHoverLeave()));
                 emit added(QList<QPieSlice*>() << slice);
             }
             /*!
                 Removes a single \a slice from the series and deletes the slice.
                 Do not reference the pointer after this call.
             */
             void QPieSeries::remove(QPieSlice* slice)
             {
                 Q_D(QPieSeries);
                 if (!d->m_slices.removeOne(slice)) {
                     Q_ASSERT(0); // TODO: how should this be reported?
                     return;
                 }
                 d->updateDerivativeData();
                 emit removed(QList<QPieSlice*>() << slice);
                 delete slice;
                 slice = 0;
             }
             /*!
                 Clears all slices from the series.
             */
             void QPieSeries::clear()
             {
                 Q_D(QPieSeries);
                 if (d->m_slices.count() == 0)
                     return;
                 QList<QPieSlice*> slices = d->m_slices;
                 foreach (QPieSlice* s, d->m_slices) {
                     d->m_slices.removeOne(s);
                     delete s;
                 }
                 d->updateDerivativeData();
                 emit removed(slices);
             }
             /*!
                 returns the number of the slices in this series.
             */
             int QPieSeries::count() const
             {
                 Q_D(const QPieSeries);
                 return d->m_slices.count();
             }
             /*!
                 Returns true is the series is empty.
             */
             bool QPieSeries::isEmpty() const
             {
                 Q_D(const QPieSeries);
                 return d->m_slices.isEmpty();
             }
             /*!
                 Returns a list of slices that belong to this series.
             */
             QList<QPieSlice*> QPieSeries::slices() const
             {
                 Q_D(const QPieSeries);
                 return d->m_slices;
             }
             void QPieSeries::setHorizontalPosition(qreal relativePosition)
             {
                 Q_D(QPieSeries);
                 if (d->setRealValue(d->m_pieRelativeHorPos, relativePosition, 1.0))
                     emit piePositionChanged();
             }
             void QPieSeries::setVerticalPosition(qreal relativePosition)
             {
                 Q_D(QPieSeries);
                 if (d->setRealValue(d->m_pieRelativeVerPos, relativePosition, 1.0))
                     emit piePositionChanged();
             }
             qreal QPieSeries::horizontalPosition() const
             {
                 Q_D(const QPieSeries);
                 return d->m_pieRelativeHorPos;
             }
             qreal QPieSeries::verticalPosition() const
             {
                 Q_D(const QPieSeries);
                 return d->m_pieRelativeVerPos;
             }
             void QPieSeries::setPieSize(qreal relativeSize)
             {
                 Q_D(QPieSeries);
                 if (d->setRealValue(d->m_pieRelativeSize, relativeSize, 1.0))
                     emit pieSizeChanged();
             }
             qreal QPieSeries::pieSize() const
             {
                 Q_D(const QPieSeries);
                 return d->m_pieRelativeSize;
             }
             void QPieSeries::setPieStartAngle(qreal angle)
             {
                 Q_D(QPieSeries);
                 if (d->setRealValue(d->m_pieStartAngle, angle, d->m_pieEndAngle))
                     d->updateDerivativeData();
             }
             qreal QPieSeries::pieStartAngle() const
             {
                 Q_D(const QPieSeries);
                 return d->m_pieStartAngle;
             }
             /*!
                 Sets the end angle of the pie.
                 Full pie is 360 degrees where 0 degrees is at 12 a'clock.
                 \a angle must be greater than start angle.
                 \sa pieEndAngle(), pieStartAngle(), setPieStartAngle()
             */
             void QPieSeries::setPieEndAngle(qreal angle)
             {
                 Q_D(QPieSeries);
                 if (d->setRealValue(d->m_pieEndAngle, angle, 360.0, d->m_pieStartAngle))
                     d->updateDerivativeData();
             }
             /*!
                 Returns the end angle of the pie.
                 Full pie is 360 degrees where 0 degrees is at 12 a'clock.
                 \sa setPieEndAngle(), pieStartAngle(), setPieStartAngle()
             */
             qreal QPieSeries::pieEndAngle() const
             {
                 Q_D(const QPieSeries);
                 return d->m_pieEndAngle;
             }
             /*!
                 Sets the all the slice labels \a visible or invisible.
                 \sa QPieSlice::isLabelVisible(), QPieSlice::setLabelVisible()
             */
             void QPieSeries::setLabelsVisible(bool visible)
             {
                 Q_D(QPieSeries);
                 foreach (QPieSlice* s, d->m_slices)
                     s->setLabelVisible(visible);
             }
             /*!
                 Returns the sum of all slice values in this series.
                 \sa QPieSlice::value(), QPieSlice::setValue(), QPieSlice::percentage()
             */
             qreal QPieSeries::sum() const
             {
                 Q_D(const QPieSeries);
                 return d->m_sum;
             }
             /*!
                 \fn void QPieSeries::clicked(QPieSlice* slice, Qt::MouseButtons buttons)
                 This signal is emitted when a \a slice has been clicked with mouse \a buttons.
                 \sa QPieSlice::clicked()
             */
             /*!
                 \fn void QPieSeries::hoverEnter(QPieSlice* slice)
                 This signal is emitted when user has hovered over a \a slice.
                 \sa QPieSlice::hoverEnter()
             */
             /*!
                 \fn void QPieSeries::hoverLeave(QPieSlice* slice)
                 This signal is emitted when user has hovered away from a \a slice.
                 \sa QPieSlice::hoverLeave()
             */
             /*!
                 \fn void QPieSeries::added(QList<QPieSlice*> slices)
                 This signal is emitted when \a slices has been added to the series.
                 \sa append(), insert()
             */
             /*!
                 \fn void QPieSeries::removed(QList<QPieSlice*> slices)
                 This signal is emitted when \a slices has been removed from the series.
                 \sa remove(), clear()
             */
             /*!
                 \fn void QPieSeries::piePositionChanged()
                 This signal is emitted when pie position has changed.
                 \sa verticalPosition(), setVerticalPosition(), horizontalPosition(), setHorizontalPosition()
             */
             /*!
                 \fn void QPieSeries::pieSizeChanged()
                 This signal is emitted when pie size has changed.
                 \sa pieSize(), setPieSize()
             */
             /*!
                  \fn bool QPieSeries::setModel(QAbstractItemModel *model)
                  Sets the \a model to be used as a data source
              */
             bool QPieSeries::setModel(QAbstractItemModel* model)
             {
                 Q_D(QPieSeries);
                 // disconnect signals from old model
                 if(d->m_model)
                 {
                     disconnect(d->m_model, 0, this, 0);
                     d->m_mapValues = -1;
                     d->m_mapLabels = -1;
                     d->m_mapOrientation = Qt::Vertical;
                 }
                 // set new model
                 if(model)
                 {
                     d->m_model = model;
                     return true;
                 }
                 else
                 {
                     d->m_model = 0;
                     return false;
                 }
             }
             /*!
                  \fn bool QPieSeries::setModelMapping(int modelValuesLine, int modelLabelsLine, Qt::Orientation orientation)
                  Sets column/row specified by \a modelValuesLine to be used as a list of pie slice values for the pie.
                  Parameter \a modelValuesLine indicates the column/row where the values for the pie slices are located in the model.
                  Parameter \a modelLabelsLine indicates the column/row where the labels for the pie slices are located in the model.
                  The \a orientation parameter specifies whether the data is in columns or in rows.
              */
             void QPieSeries::setModelMapping(int modelValuesLine, int modelLabelsLine, Qt::Orientation orientation)
             {
                 Q_D(QPieSeries);
                 if (d->m_model == 0)
                     return;
                 d->m_mapValues = modelValuesLine;
                 d->m_mapLabels = modelLabelsLine;
                 d->m_mapOrientation = orientation;
                 // connect the signals
                 if (d->m_mapOrientation == Qt::Vertical) {
                     connect(d->m_model, SIGNAL(dataChanged(QModelIndex,QModelIndex)), d, SLOT(modelUpdated(QModelIndex,QModelIndex)));
                     connect(d->m_model, SIGNAL(rowsInserted(QModelIndex,int,int)), d, SLOT(modelDataAdded(QModelIndex,int,int)));
                     connect(d->m_model, SIGNAL(rowsRemoved(QModelIndex,int,int)), d, SLOT(modelDataRemoved(QModelIndex,int,int)));
                 } else {
                     connect(d->m_model, SIGNAL(dataChanged(QModelIndex,QModelIndex)), d, SLOT(modelUpdated(QModelIndex,QModelIndex)));
                     connect(d->m_model, SIGNAL(columnsInserted(QModelIndex,int,int)), d, SLOT(modelDataAdded(QModelIndex,int,int)));
                     connect(d->m_model, SIGNAL(columnsRemoved(QModelIndex,int,int)), d, SLOT(modelDataRemoved(QModelIndex,int,int)));
                 }
                 // create the initial slices set
                 if (d->m_mapOrientation == Qt::Vertical) {
                     for (int i = 0; i < d->m_model->rowCount(); i++)
                         append(d->m_model->data(d->m_model->index(i, d->m_mapValues), Qt::DisplayRole).toDouble(), d->m_model->data(d->m_model->index(i, d->m_mapLabels), Qt::DisplayRole).toString());
                 } else {
                     for (int i = 0; i < d->m_model->columnCount(); i++)
                         append(d->m_model->data(d->m_model->index(d->m_mapValues, i), Qt::DisplayRole).toDouble(), d->m_model->data(d->m_model->index(d->m_mapLabels, i), Qt::DisplayRole).toString());
                 }
             }
             ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QPieSeriesPrivate::QPieSeriesPrivate(QPieSeries *parent) :
                 QAbstractSeriesPrivate(parent),
                 m_pieRelativeHorPos(0.5),
                 m_pieRelativeVerPos(0.5),
                 m_pieRelativeSize(0.7),
                 m_pieStartAngle(0),
                 m_pieEndAngle(360),
                 m_sum(0),
                 m_mapValues(0),
                 m_mapLabels(0),
                 m_mapOrientation(Qt::Horizontal)
             {
             }
             QPieSeriesPrivate::~QPieSeriesPrivate()
             {
             }
             void QPieSeriesPrivate::updateDerivativeData()
             {
                 m_sum = 0;
                 // nothing to do?
                 if (m_slices.count() == 0)
                     return;
                 // calculate sum of all slices
                 foreach (QPieSlice* s, m_slices)
                     m_sum += s->value();
                 // nothing to show..
                 if (qFuzzyIsNull(m_sum))
                     return;
                 // update slice attributes
                 qreal sliceAngle = m_pieStartAngle;
                 qreal pieSpan = m_pieEndAngle - m_pieStartAngle;
                 QVector<QPieSlice*> changed;
                 foreach (QPieSlice* s, m_slices) {
                     PieSliceData data = PieSliceData::data(s);
                     data.m_percentage = s->value() / m_sum;
                     data.m_angleSpan = pieSpan * data.m_percentage;
                     data.m_startAngle = sliceAngle;
                     sliceAngle += data.m_angleSpan;
                     if (PieSliceData::data(s) != data) {
                         PieSliceData::data(s) = data;
                         changed << s;
                     }
                 }
                 // emit signals
                 foreach (QPieSlice* s, changed)
                     PieSliceData::data(s).emitChangedSignal(s);
             }
             void QPieSeriesPrivate::sliceChanged()
             {
                 Q_ASSERT(m_slices.contains(qobject_cast<QPieSlice *>(sender())));
                 updateDerivativeData();
             }
             void QPieSeriesPrivate::sliceClicked(Qt::MouseButtons buttons)
             {
                 QPieSlice* slice = qobject_cast<QPieSlice *>(sender());
                 Q_ASSERT(m_slices.contains(slice));
                 Q_Q(QPieSeries);
                 emit q->clicked(slice, buttons);
             }
             void QPieSeriesPrivate::sliceHoverEnter()
             {
                 QPieSlice* slice = qobject_cast<QPieSlice *>(sender());
                 Q_ASSERT(m_slices.contains(slice));
                 Q_Q(QPieSeries);
                 emit q->hoverEnter(slice);
             }
             void QPieSeriesPrivate::sliceHoverLeave()
             {
                 QPieSlice* slice = qobject_cast<QPieSlice *>(sender());
                 Q_ASSERT(m_slices.contains(slice));
                 Q_Q(QPieSeries);
                 emit q->hoverLeave(slice);
             }
             void QPieSeriesPrivate::modelUpdated(QModelIndex topLeft, QModelIndex bottomRight)
             {
                 Q_UNUSED(bottomRight)
                 if (m_mapOrientation == Qt::Vertical)
                 {
                     if (topLeft.column() == m_mapValues)
                         if (m_mapValues == m_mapLabels)
                         {
                             m_slices.at(topLeft.row())->setValue(m_model->data(topLeft, Qt::DisplayRole).toDouble());
                             m_slices.at(topLeft.row())->setLabel(m_model->data(topLeft, Qt::DisplayRole).toString());
                         }
                         else
                         {
                             m_slices.at(topLeft.row())->setValue(m_model->data(topLeft, Qt::DisplayRole).toDouble());
                         }
                     else if (topLeft.column() == m_mapLabels)
                         m_slices.at(topLeft.row())->setLabel(m_model->data(topLeft, Qt::DisplayRole).toString());
                 }
                 else
                 {
                     if (topLeft.row() == m_mapValues)
                         if (m_mapValues == m_mapLabels)
                         {
                             m_slices.at(topLeft.column())->setValue(m_model->data(topLeft, Qt::DisplayRole).toDouble());
                             m_slices.at(topLeft.column())->setLabel(m_model->data(topLeft, Qt::DisplayRole).toString());
                         }
                         else
                         {
                             m_slices.at(topLeft.column())->setValue(m_model->data(topLeft, Qt::DisplayRole).toDouble());
                         }
                     else if (topLeft.row() == m_mapLabels)
                         m_slices.at(topLeft.column())->setLabel(m_model->data(topLeft, Qt::DisplayRole).toString());
                 }
             }
             void QPieSeriesPrivate::modelDataAdded(QModelIndex parent, int start, int end)
             {
                 Q_UNUSED(parent)
                 Q_UNUSED(end)
                 Q_Q(QPieSeries);
                 QPieSlice* newSlice = new QPieSlice;
                 newSlice->setLabelVisible(true);
                 if (m_mapOrientation == Qt::Vertical)
                 {
                     newSlice->setValue(m_model->data(m_model->index(start, m_mapValues), Qt::DisplayRole).toDouble());
                     newSlice->setLabel(m_model->data(m_model->index(start, m_mapLabels), Qt::DisplayRole).toString());
                 }
                 else
                 {
                     newSlice->setValue(m_model->data(m_model->index(m_mapValues, start), Qt::DisplayRole).toDouble());
                     newSlice->setLabel(m_model->data(m_model->index(m_mapLabels, start), Qt::DisplayRole).toString());
                 }
                 q->insert(start, newSlice);
             }
             void QPieSeriesPrivate::modelDataRemoved(QModelIndex parent, int start, int end)
             {
                 Q_UNUSED(parent)
                 Q_UNUSED(end)
                 Q_Q(QPieSeries);
                 q->remove(m_slices.at(start));
             }
             bool QPieSeriesPrivate::setRealValue(qreal &value, qreal newValue, qreal max, qreal min)
             {
                 // Remove rounding errors
                 qreal roundedValue = newValue;
                 if (qFuzzyIsNull(min) && qFuzzyIsNull(newValue))
                     roundedValue = 0.0;
                 else if (qFuzzyCompare(newValue, max))
                     roundedValue = max;
                 else if (qFuzzyCompare(newValue, min))
                     roundedValue = min;
                 // Check if the position is valid after removing the rounding errors
                 if (roundedValue < min || roundedValue > max) {
                     qWarning("QPieSeries: Illegal value");
                     return false;
                 }
                 if (!qFuzzyIsNull(value - roundedValue)) {
                     value = roundedValue;
                     return true;
                 }
                 // The change was so small it is considered a rounding error
                 return false;
             }
             void QPieSeriesPrivate::scaleDomain(Domain& domain)
             {
                 Q_UNUSED(domain);
             #ifndef QT_NO_DEBUG
                 qWarning() << __FILE__<<__FUNCTION__<<"not implemented";
             #endif
             }
             Chart* QPieSeriesPrivate::createGraphics(ChartPresenter* presenter)
             {
                 Q_Q(QPieSeries);
                 PieChartItem* pie = new PieChartItem(q,presenter);
                 if(presenter->animationOptions().testFlag(QChart::SeriesAnimations)) {
                     presenter->animator()->addAnimation(pie);
                 }
                 presenter->chartTheme()->decorate(q, presenter->dataSet()->seriesIndex(q));
                 return pie;
             }
             QList<LegendMarker*> QPieSeriesPrivate::createLegendMarker(QLegend* legend)
             {
                 Q_Q(QPieSeries);
                 QList<LegendMarker*> markers;
                 foreach(QPieSlice* slice, q->slices()) {
                     PieLegendMarker* marker = new PieLegendMarker(q,slice,legend);
                     markers << marker;
                 }
                 return markers;
             }
             #include "moc_qpieseries.cpp"
             #include "moc_qpieseries_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/qchartglobal.h +5 -4

             /****************************************************************************
             **
             ** 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$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #ifndef CHARTGLOBAL_H
             #define CHARTGLOBAL_H
             #define QTCOMMERCIALCHART_VERSION_STR   "1.0"
             #define QTCOMMERCIALCHART_VERSION 0x01
             #if defined(QTCOMMERCIALCHART_LIBRARY)
             #  define QTCOMMERCIALCHART_EXPORT Q_DECL_EXPORT
             #else
             #  define QTCOMMERCIALCHART_EXPORT Q_DECL_IMPORT
             #endif
             #define QTCOMMERCIALCHART_NAMESPACE QtCommercialChart
             #ifdef QTCOMMERCIALCHART_NAMESPACE
             # define QTCOMMERCIALCHART_BEGIN_NAMESPACE namespace QTCOMMERCIALCHART_NAMESPACE {
             # define QTCOMMERCIALCHART_END_NAMESPACE }
             # define QTCOMMERCIALCHART_USE_NAMESPACE using namespace QTCOMMERCIALCHART_NAMESPACE;
             #else
             # define QTCOMMERCIALCHART_BEGIN_NAMESPACE
             # define QTCOMMERCIALCHART_END_NAMESPACE
             # define QTCOMMERCIALCHART_USE_NAMESPACE
             #endif
-            #define CHART_DEBUG chartDebug(3,__LINE__,__FILE__,__FUNCTION__);
+            #if defined(DEVELOPER_BUILD) && !defined(QT_NO_DEBUG)
+            #define CHART_DEBUG chartDebug(3,__LINE__,__FILE__,__FUNCTION__)
             #include <stdarg.h>
             #include <QDebug>
-            /*
+            static inline QDebug chartDebug(int numargs,...)
-            static QDebug chartDebug(int numargs,...)
             {
                    va_list valist;
                    va_start(valist,numargs);
                    //for( int i = 0 ; i < numargs; i++ )
                    int line=va_arg(valist,int);
                    char* file=va_arg(valist,char*);
                    char* function=va_arg(valist,char*);
                    va_end(valist);
                    return qDebug()<<QString().append(function).append("(").append(file).append(":%1)").arg(line);
             }
-            */
+            #endif
             #endif

src/scatterseries/scatterchartitem.cpp +1 0

             /****************************************************************************
             **
             ** 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$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "scatterchartitem_p.h"
             #include "qscatterseries.h"
             #include "qscatterseries_p.h"
             #include "chartpresenter_p.h"
             #include <QPainter>
             #include <QGraphicsScene>
+            #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ScatterChartItem::ScatterChartItem(QScatterSeries *series, ChartPresenter *presenter) :
                 XYChartItem(series,presenter),
                 m_series(series),
                 m_items(this),
                 m_shape(QScatterSeries::MarkerShapeRectangle),
                 m_size(15)
             {
                 QObject::connect(m_series->d_func(),SIGNAL(updated()), this, SLOT(handleUpdated()));
                 setZValue(ChartPresenter::ScatterSeriesZValue);
                 setFlags(QGraphicsItem::ItemClipsChildrenToShape);
                 handleUpdated();
                 m_items.setHandlesChildEvents(false);
                 // TODO: how to draw a drop shadow?
             //    QGraphicsDropShadowEffect *dropShadow = new QGraphicsDropShadowEffect();
             //    dropShadow->setOffset(2.0);
             //    dropShadow->setBlurRadius(2.0);
             //    setGraphicsEffect(dropShadow);
             }
             QRectF ScatterChartItem::boundingRect() const
             {
                 return m_rect;
             }
             void ScatterChartItem::createPoints(int count)
             {
                 for (int i = 0; i < count; ++i) {
                     QGraphicsItem *item = 0;
                     switch (m_shape) {
                                case QScatterSeries::MarkerShapeCircle:{
                                    QGraphicsEllipseItem* i = new QGraphicsEllipseItem(0,0,m_size,m_size);
                                    const QRectF& rect = i->boundingRect();
                                    i->setPos(-rect.width()/2,-rect.height()/2);
                                    item = new Marker(i,this);
                                    break;
                                }
                                case QScatterSeries::MarkerShapeRectangle:{
                                    QGraphicsRectItem* i = new QGraphicsRectItem(0,0,m_size,m_size);
                                    i->setPos(-m_size/2,-m_size/2);
                                    item = new Marker(i,this);
                                    break;
                                }
                                default:
                                    qWarning()<<"Unsupported marker type";
                                    break;
                     }
                     m_items.addToGroup(item);
                 }
             }
             void ScatterChartItem::deletePoints(int count)
             {
                 QList<QGraphicsItem *> items = m_items.childItems();
                 for (int i = 0; i < count; ++i) {
                     delete(items.takeLast());
                 }
             }
             void ScatterChartItem::markerSelected(Marker *marker)
             {
                 emit XYChartItem::clicked(QPointF(m_series->x(marker->index()), m_series->y(marker->index())));
             }
             void ScatterChartItem::setLayout(QVector<QPointF>& points)
             {
                 if(points.size()==0)
                 {
                     XYChartItem::setLayout(points);
                     return;
                 }
                 int diff = m_items.childItems().size() - points.size();
                 if(diff>0) {
                     deletePoints(diff);
                 }
                 else if(diff<0) {
                     createPoints(-diff);
                 }
                 if(diff!=0) handleUpdated();
                 QList<QGraphicsItem*> items = m_items.childItems();
                 for (int i = 0; i < points.size(); i++) {
                     Marker* item = static_cast<Marker*>(items.at(i));
                     const QPointF& point = points.at(i);
                     const QRectF& rect = item->boundingRect();
                     item->setIndex(i);
                     item->setPos(point.x()-rect.width()/2,point.y()-rect.height()/2);
                     if(!clipRect().contains(point)) {
                         item->setVisible(false);
                     }
                     else {
                         item->setVisible(true);
                     }
                 }
                 prepareGeometryChange();
                 m_rect = clipRect();
                 XYChartItem::setLayout(points);
             }
             void ScatterChartItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
                 Q_UNUSED(painter)
                 Q_UNUSED(option)
                 Q_UNUSED(widget)
             }
             void ScatterChartItem::setPen(const QPen& pen)
             {
                 foreach(QGraphicsItem* item , m_items.childItems()) {
                        static_cast<Marker*>(item)->setPen(pen);
                 }
             }
             void ScatterChartItem::setBrush(const QBrush& brush)
             {
                 foreach(QGraphicsItem* item , m_items.childItems()) {
                         static_cast<Marker*>(item)->setBrush(brush);
                  }
             }
             void ScatterChartItem::handleUpdated()
             {
                 int count = m_items.childItems().count();
                 if(count==0) return;
                 bool recreate = m_size != m_series->size() || m_shape != m_series->shape();
                 //TODO: only rewrite on size change
                 m_size = m_series->size();
                 m_shape = m_series->shape();
                 if(recreate){
                     deletePoints(count);
                     createPoints(count);
                 }
                 setPen(m_series->pen());
                 setBrush(m_series->brush());
             }
             #include "moc_scatterchartitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/scroller.cpp +1 0

             /****************************************************************************
             **
             ** 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$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "scroller_p.h"
             #include "qlegend.h"
             #include <QGraphicsSceneMouseEvent>
+            #include <QDebug>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             Scroller::Scroller():
             m_ticker(this),
             m_state(Idle),
             m_moveThreshold(10),
             m_timeTreshold(50)
             {
             }
             Scroller::~Scroller()
             {
             }
             void Scroller::mousePressEvent(QGraphicsSceneMouseEvent* event)
             {
                 if (event->button() == Qt::LeftButton) {
                     switch (m_state) {
                     case Idle:
                     {
                         m_state = Pressed;
                         m_offset = offset();
                         m_press = event->pos();
                         m_timeStamp = QTime::currentTime();
                         event->accept();
                         break;
                     }
                     case Scroll:
                     {
                         m_state = Stop;
                         m_speed = QPoint(0, 0);
                         m_offset = offset();
                         m_press = event->pos();
                         event->accept();
                         break;
                     }
                     case Pressed:
                     case Move:
                     case Stop:
                         qWarning() << __FUNCTION__<<"Scroller unexpected state" << m_state;
                         event->ignore();
                         break;
                     }
                 }
             }
             void Scroller::mouseMoveEvent(QGraphicsSceneMouseEvent* event)
             {
                 QPointF delta = event->pos() - m_press;
                 switch (m_state) {
                 case Pressed:
                 case Stop:
                 {
                     if (qAbs(delta.x()) > m_moveThreshold || qAbs(delta.y()) > m_moveThreshold) {
                         m_state = Move;
                         m_timeStamp = QTime::currentTime();
                         m_distance = QPointF(0, 0);
                         m_press = event->pos();
                         event->accept();
                         break;
                     }
                     else {
                         event->ignore();
                         break;
                     }
                 }
                 case Move:
                 {
                     setOffset(m_offset - delta);
                     calculateSpeed(event->pos());
                     event->accept();
                     break;
                 }
                 case Idle:
                 case Scroll:
                     qWarning() << __FUNCTION__<<"Scroller unexpected state" << m_state;
                     event->ignore();
                     break;
                 }
             }
             void Scroller::mouseReleaseEvent(QGraphicsSceneMouseEvent* event)
             {
                 if (event->button() == Qt::LeftButton) {
                     switch (m_state) {
                     case Scroll:
                         m_state = Stop;
                         m_speed = QPointF(0, 0);
                         m_offset = offset();
                         event->accept();
                         break;
                     case Pressed:
                     {
                         m_state = Idle;
                         //if (m_timeStamp.elapsed() < m_clickedPressDelay) {
                         //emit clicked(m_offset.toPoint());
                         //}
                         event->accept();
                         break;
                     }
                     case Move:
                     {
                         calculateSpeed(event->pos());
                         m_offset = offset();
                         m_press = event->pos();
                         if (m_speed == QPointF(0, 0)) {
                             m_state = Idle;
                         }
                         else {
                             m_speed /= 4;
                             m_state = Scroll;
                             m_ticker.start(20);
                         }
                         event->accept();
                         break;
                     }
                     case Stop:
                     case Idle:
                         qWarning() << __FUNCTION__<<"Scroller unexpected state" << m_state;
                         event->ignore();
                         break;
                     }
                 }
             }
             void Scroller::scrollTick()
             {
                 switch (m_state) {
                     case Scroll:
                     {
                         lowerSpeed(m_speed);
                         setOffset(m_offset - m_speed);
                         m_offset = offset();
                         if (m_speed == QPointF(0, 0)) {
                             m_state = Idle;
                             m_ticker.stop();
                         }
                         break;
                     }
                     case Stop:
                         m_ticker.stop();
                         break;
                     case Idle:
                     case Move:
                     case Pressed:
                         qWarning() << __FUNCTION__<<"Scroller unexpected state" << m_state;
                         m_ticker.stop();
                     break;
                 }
             }
             void Scroller::lowerSpeed(QPointF& speed, qreal maxSpeed)
             {
                 qreal x = qBound(-maxSpeed, speed.x(), maxSpeed);
                 qreal y = qBound(-maxSpeed, speed.y(), maxSpeed);
                 x = (x == 0) ? x :
                     (x > 0) ? qMax(qreal(0), x - m_fraction.x()) : qMin(qreal(0), x + m_fraction.x());
                 y = (y == 0) ? y :
                     (y > 0) ? qMax(qreal(0), y - m_fraction.y()) : qMin(qreal(0), y + m_fraction.y());
                 speed.setX(x);
                 speed.setY(y);
             }
             void Scroller::calculateSpeed(const QPointF& position)
             {
                 if (m_timeStamp.elapsed() > m_timeTreshold) {
                     QPointF distance = position - m_press;
                     m_timeStamp = QTime::currentTime();
                     m_speed = distance -  m_distance;
                     m_distance = distance;
                     qreal fraction = qMax(qAbs(m_speed.x()), qAbs(m_speed.y()));
                     if (fraction != 0) {
                         m_fraction.setX(qAbs(m_speed.x() / fraction));
                         m_fraction.setY(qAbs(m_speed.y() / fraction));
                     }
                     else {
                         m_fraction.setX(1);
                         m_fraction.setY(1);
                     }
                 }
             }
             /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             ScrollTicker::ScrollTicker(Scroller *scroller,QObject* parent):QObject(parent),
                 m_scroller(scroller)
             {
             }
             void ScrollTicker::start(int interval)
             {
                 if (!m_timer.isActive()){
                     m_timer.start(interval, this);
                 }
             }
             void ScrollTicker::stop()
             {
                 m_timer.stop();
             }
             void ScrollTicker::timerEvent(QTimerEvent *event)
             {
                 Q_UNUSED(event);
                 m_scroller->scrollTick();
             }
             #include "moc_scroller_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/src.pro +12 -10

-            !include( ../common.pri ):error( Couldn't find the common.pri file! )
+            !include( ../config.pri ):error( Couldn't find the config.pri file! )
             TARGET = QtCommercialChart
             DESTDIR = $$CHART_BUILD_LIB_DIR
             TEMPLATE = lib
             QT += core \
                 gui
             win32-msvc*: LIBS += User32.lib
             CONFIG += debug_and_release
             CONFIG(debug, debug|release):TARGET = QtCommercialChartd
             SOURCES += \
                 $$PWD/chartdataset.cpp \
                 $$PWD/chartpresenter.cpp \
                 $$PWD/charttheme.cpp \
                 $$PWD/domain.cpp \
                 $$PWD/qchart.cpp \
                 $$PWD/qchartview.cpp \
                 $$PWD/qabstractseries.cpp \
                 $$PWD/chartbackground.cpp \
                 $$PWD/chart.cpp \
                 $$PWD/scroller.cpp
             PRIVATE_HEADERS += \
                 $$PWD/chartdataset_p.h \
                 $$PWD/chartitem_p.h \
                 $$PWD/chartpresenter_p.h \
                 $$PWD/charttheme_p.h \
                 $$PWD/domain_p.h \
                 $$PWD/chartbackground_p.h \
                 $$PWD/chart_p.h \
                 $$PWD/chartconfig_p.h \
                 $$PWD/qchart_p.h \
                 $$PWD/qchartview_p.h \
                 $$PWD/scroller_p.h \
                 $$PWD/qabstractseries_p.h
             PUBLIC_HEADERS += \
                 $$PWD/qchart.h \
                 $$PWD/qchartglobal.h \
                 $$PWD/qabstractseries.h \
                 $$PWD/qchartview.h
             include(animations/animations.pri)
             include(areachart/areachart.pri)
             include(axis/axis.pri)
             include(barchart/barchart.pri)
             include(legend/legend.pri)
             include(linechart/linechart.pri)
             include(piechart/piechart.pri)
             include(scatterseries/scatter.pri)
             include(splinechart/splinechart.pri)
             include(themes/themes.pri)
             include(xychart/xychart.pri)
             HEADERS += $$PUBLIC_HEADERS
             HEADERS += $$PRIVATE_HEADERS
             HEADERS += $$THEMES
             INCLUDEPATH += ../include .
             OBJECTS_DIR = $$CHART_BUILD_DIR/lib
             MOC_DIR = $$CHART_BUILD_DIR/lib
             UI_DIR = $$CHART_BUILD_DIR/lib
             RCC_DIR = $$CHART_BUILD_DIR/lib
             DEFINES += QTCOMMERCIALCHART_LIBRARY
             #qt public headers
             #this is very primitive and lame parser , TODO: make perl script insted
             !exists($$CHART_BUILD_PUBLIC_HEADER_DIR/QChartGlobal)
             {
                 system($$QMAKE_MKDIR $$CHART_BUILD_PUBLIC_HEADER_DIR)
                  win32:{
                     command = "echo $${LITERAL_HASH}include \"qchartglobal.h\" > $$CHART_BUILD_PUBLIC_HEADER_DIR/QChartGlobal"
                 }else{
                     command = "echo \"$${LITERAL_HASH}include \\\"qchartglobal.h\\\"\" > $$CHART_BUILD_PUBLIC_HEADER_DIR/QChartGlobal"
                 }
+                PUBLIC_QT_HEADERS += $$CHART_BUILD_PUBLIC_HEADER_DIR/QChartGlobal
                 system($$command)
             }
             for(file, PUBLIC_HEADERS) {
                 name = $$split(file,'/')
                 name = $$last(name)
                 class = "$$cat($$file)"
                 class = $$find(class,class)
                 !isEmpty(class){
                 class = $$split(class,QTCOMMERCIALCHART_EXPORT)
                 class = $$member(class,1)
                 class = $$split(class,' ')
                 class = $$replace(class,' ','')
                 class = $$member(class,0)
                 win32:{
                     command = "echo $${LITERAL_HASH}include \"$$name\" > $$CHART_BUILD_PUBLIC_HEADER_DIR/$$class"
                 }else{
                     command = "echo \"$${LITERAL_HASH}include \\\"$$name\\\"\" > $$CHART_BUILD_PUBLIC_HEADER_DIR/$$class"
                 }
                 PUBLIC_QT_HEADERS += $$CHART_BUILD_PUBLIC_HEADER_DIR/$$class
                 system($$command)
                 }
             }
             public_headers.path = $$[QT_INSTALL_HEADERS]/QtCommercialChart
             public_headers.files = $$PUBLIC_HEADERS $$PUBLIC_QT_HEADERS
             target.path = $$[QT_INSTALL_LIBS]
             INSTALLS += target public_headers
             install_build_public_headers.name = build_public_headers
             install_build_public_headers.output = $$CHART_BUILD_PUBLIC_HEADER_DIR/${QMAKE_FILE_BASE}.h
             install_build_public_headers.input = PUBLIC_HEADERS
             install_build_public_headers.commands = $$QMAKE_COPY \
                 ${QMAKE_FILE_NAME} \
                 $$CHART_BUILD_PUBLIC_HEADER_DIR
             install_build_public_headers.CONFIG += target_predeps \
                 no_link
             install_build_private_headers.name = buld_private_headers
             install_build_private_headers.output = $$CHART_BUILD_PRIVATE_HEADER_DIR/${QMAKE_FILE_BASE}.h
             install_build_private_headers.input = PRIVATE_HEADERS
             install_build_private_headers.commands = $$QMAKE_COPY \
                 ${QMAKE_FILE_NAME} \
                 $$CHART_BUILD_PRIVATE_HEADER_DIR
             install_build_private_headers.CONFIG += target_predeps \
                 no_link
             QMAKE_EXTRA_COMPILERS += install_build_public_headers \
                 install_build_private_headers \
+            # There is a problem with jom.exe currently. It does not seem to understand QMAKE_EXTRA_TARGETS properly.
+            # This is the case at least with shadow builds.
+            # http://qt-project.org/wiki/jom
-            !win32-msvc*: {
+            developer_build:!win32-msvc*:{
-                # There is a problem with jom.exe currently. It does not seem to understand QMAKE_EXTRA_TARGETS properly.
-                # This is the case at least with shadow builds.
-                # http://qt-project.org/wiki/jom
                 chartversion.target = $$PWD/qchartversion_p.h
                 unix:{
                     chartversion.commands = @echo \
-                        "const char *buildTime = \\\"`date +'%y%m%d%H%M'`\\\" \\; \
+                        \" $${LITERAL_HASH}ifndef QCHARTVERSION_P_H\\n\
-                         const char *gitHead = \\\"`git rev-parse HEAD`\\\" \\; " \
+                        $${LITERAL_HASH}define QCHARTVERSION_P_H\\n\
+                        const char *buildTime = \\\"`date +'%y%m%d%H%M'`\\\" ; \\n\
+                        const char *gitHead = \\\"`git rev-parse HEAD`\\\" ; \\n \
+                        $${LITERAL_HASH}endif \"  \
                         > \
                         $$chartversion.target;
                 }else{
                     chartversion.commands = @echo \
                         "const char *buildTime = \"%date%_%time%\" ; \
                          const char *gitHead = \"unknown\" ; " \
                         > \
                         $$chartversion.target
                 }
                 chartversion.depends = $$HEADERS \
                     $$SOURCES
-                PRE_TARGETDEPS += $$PWD/qchartversion_p.h
+                PRE_TARGETDEPS += $$chartversion.target
                 QMAKE_CLEAN += $$PWD/qchartversion_p.h
                 QMAKE_EXTRA_TARGETS += chartversion
             }
             unix:QMAKE_DISTCLEAN += -r \
                 $$CHART_BUILD_HEADER_DIR \
                 $$CHART_BUILD_LIB_DIR
             win32:QMAKE_DISTCLEAN += /Q \
                 $$CHART_BUILD_HEADER_DIR \
                 $$CHART_BUILD_LIB_DIR
             # treat warnings as errors
             win32-msvc*: {
                 QMAKE_CXXFLAGS += /WX
             } else {
                 QMAKE_CXXFLAGS += -Werror
             }

test/auto/auto.pri +2 -13

@@ -1,17 +1,6
1	!include( ../~~../common~~.pri ) {	1	!include( ../test.pri ) {
2	error( "Couldn't find the ~~common~~.pri file!" )	2	error( "Couldn't find the test.pri file!" )
3	}
4	!include( ../../integrated.pri ) {
5	error( "Couldn't find the integrated.pri file !")
6	}	3	}
7		4
8	TEMPLATE = app
9	CONFIG += qtestlib	5	CONFIG += qtestlib
10
11	DESTDIR = $$CHART_BUILD_BIN_DIR/test
12	OBJECTS_DIR = $$CHART_BUILD_DIR/test/$$TARGET
13	MOC_DIR = $$CHART_BUILD_DIR/test/$$TARGET
14	UI_DIR = $$CHART_BUILD_DIR/test/$$TARGET
15	RCC_DIR = $$CHART_BUILD_DIR/test/$$TARGET
16
17	!contains(TARGET, ^tst_.*):TARGET = $$join(TARGET,,"tst_")	6	!contains(TARGET, ^tst_.*):TARGET = $$join(TARGET,,"tst_")

test/gdpbarchart/widget.cpp +1 0

             /****************************************************************************
             **
             ** 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$
             ** Licensees holding valid Qt Commercial licenses may use this file in
             ** accordance with the Qt Commercial License Agreement provided with the
             ** Software or, alternatively, in accordance with the terms contained in
             ** a written agreement between you and Digia.
             **
             ** If you have questions regarding the use of this file, please use
             ** contact form at http://qt.digia.com
             ** $QT_END_LICENSE$
             **
             ****************************************************************************/
             #include "widget.h"
             #include <QChart>
             #include <QScatterSeries>
             #include <QChartAxis>
             #include <QBarSet>
             #include <QBarSeries>
             #include <QLegend>
             #include <QGridLayout>
             #include <QPushButton>
             #include <QLabel>
             #include <QListWidget>
             #include <QPrinter>
             #include <QPrintDialog>
             #include <QRadioButton>
             #include <QStringList>
             #include <QSqlQuery>
+            #include <QDebug>
             QTCOMMERCIALCHART_USE_NAMESPACE
             Widget::Widget(QWidget *parent)
                 : QWidget(parent)
             {
                 setGeometry(100, 100, 1000, 600);
                 // right panel layout
                 barChartRadioButton = new QRadioButton(tr("Bar chart"));
                 barChartRadioButton->setChecked(true);
                 scatterChartRadioButton = new QRadioButton(tr("Scatter chart"));
                 scatterChartRadioButton->setChecked(false);
                 countrieslist = new QListWidget;
                 countrieslist->setSelectionMode(QAbstractItemView::MultiSelection);
                 //list of years widget
                 yearslist = new QListWidget;
                 yearslist->setSelectionMode(QAbstractItemView::ExtendedSelection);
                 for (int i = 1990; i < 2011; i++)
                     yearslist->addItem(QString("%1").arg(i));
                 QPushButton* refreshButton = new QPushButton(tr("Refresh"));
                 connect(refreshButton, SIGNAL(clicked()), this, SLOT(refreshChart()));
                 QPushButton* printButton = new QPushButton(tr("Print to pdf"));
                 connect(printButton, SIGNAL(clicked()), this, SLOT(printChart()));
                 QVBoxLayout* rightPanelLayout = new QVBoxLayout;
                 rightPanelLayout->addWidget(barChartRadioButton);
                 rightPanelLayout->addWidget(scatterChartRadioButton);
                 rightPanelLayout->addWidget(countrieslist);
                 rightPanelLayout->addWidget(yearslist);
                 rightPanelLayout->addWidget(refreshButton);
                 rightPanelLayout->addWidget(printButton);
                 rightPanelLayout->setStretch(0, 1);
                 rightPanelLayout->setStretch(1, 0);
                 QChart *chart = new QChart();
                 chart->setTitle("GDP by country");
                 chart->legend()->setVisible(true);
                 // main layout
                 chartView = new QChartView(chart);
                 QGridLayout* mainLayout = new QGridLayout;
                 mainLayout->addWidget(chartView, 0, 0);
                 mainLayout->addLayout(rightPanelLayout, 0, 1);
                 mainLayout->setColumnStretch(0,1);
                 setLayout(mainLayout);
                 // connect to the database
                 db = QSqlDatabase::addDatabase("QSQLITE");
                 db.setDatabaseName("gdpData");
                 if(!db.open())
                 {
                     qDebug() << "could not open database. SQLite db file missing (?)";
                     return;
                 }
                 // get the list of all countires and regions.
                 QSqlQuery query;
                 query.exec("SELECT DISTINCT country FROM gdp2");
                 // add the countries to the country filter
                 while (query.next()) {
                     countrieslist->addItem(query.value(0).toString());
                 }
             }
             Widget::~Widget()
             {
                 //
                 db.close();
             }
             /*!
                 refreshes the chart
             */
             void Widget::refreshChart()
             {
                 chartView->chart()->removeAllSeries();
                 // selected countries items list is not sorted. copy the values to QStringlist and sort them.
                 QStringList selectedCountriesStrings;
                 QList<QListWidgetItem*> selectedCountriesItems = countrieslist->selectedItems();
                 for (int i = 0; i < selectedCountriesItems.size(); i++)
                     selectedCountriesStrings.append(selectedCountriesItems[i]->text());
                 selectedCountriesStrings.sort();
                 QSqlQuery query;
                 // selected years items list is not sorted. copy the values to QList<int> and sort them.
                 QList<int> selectedYearsInts;
                 QList<QListWidgetItem*> selectedYearsItems = yearslist->selectedItems();
                 for (int i = 0; i < selectedYearsItems.size(); i++)
                     selectedYearsInts.append(selectedYearsItems[i]->text().toInt());
                 qSort(selectedYearsInts.begin(), selectedYearsInts.end());
                 if (barChartRadioButton->isChecked())
                 {
                     // use the sorted selected coutries list to initialize BarCategory
                     QStringList category;
                     for (int i = 0; i < selectedCountriesStrings.size(); i++)
                         category << selectedCountriesStrings[i];
                     QBarSeries* series0 = new QBarSeries(category);
                     series0 = new QBarSeries(category);
                     // prepare the selected counries SQL query
                     QString countriesQuery = "country IN (";
                     for (int i = 0; i < selectedCountriesStrings.size(); i++)
                     {
                         countriesQuery.append("'" + selectedCountriesStrings[i] + "'");
                         if ( i < selectedCountriesStrings.size() - 1)
                             countriesQuery.append(",");
                         else
                             countriesQuery.append(")");
                     }
                     // perform a query for each selected year
                     for (int i = 0; i < selectedYearsInts.size(); i++)
                     {
                         query.exec("SELECT country,gdpvalue FROM gdp2 where year=" + QString("%1").arg(selectedYearsInts[i]) + " AND " + countriesQuery);
                         QBarSet* barSet = new QBarSet(QString::number(selectedYearsInts[i]));
                         //        while (query.next()) {
                         //            qDebug() << query.value(0).toString() << " : " << query.value(1).toString();
                         //        }
                         query.first();
                         // the data for some of the coutries for some years might be missing.
                         // QBarChart needs bars to have same size
                         for (int k = 0; k < selectedCountriesStrings.size(); k++)
                         {
                             if (selectedCountriesStrings[k] == query.value(0).toString())
                             {
                                 *barSet << query.value(1).toReal();
                                 qDebug() << query.value(0).toString() << query.value(1).toReal() << " : " << QString("%1").arg(selectedYearsInts[i]);
                                 query.next();
                             }
                             else
                             {
                                 // data missing, put 0
                                 *barSet << 0.0f;
                                 qDebug() << "Putting 0 for the missing data" << " : " << QString("%1").arg(selectedYearsInts[i]);
                             }
                         }
                         series0->appendBarSet(barSet);
                     }
                     // add the serie to the chart
                     chartView->chart()->addSeries(series0);
                 }
                 else if (scatterChartRadioButton->isChecked())
                 {
                     QString yearsQuery = "year IN (";
                     for (int i = 0; i < selectedYearsInts.size(); i++)
                     {
                         yearsQuery.append("'" + QString("%1").arg(selectedYearsInts[i]) + "'");
                         if ( i < selectedYearsInts.size() - 1)
                             yearsQuery.append(",");
                         else
                             yearsQuery.append(")");
                     }
                     // perform a query for each selected country
                     for (int i = 0; i < selectedCountriesStrings.size(); i++)
                     {
                         query.exec("SELECT year,gdpvalue FROM gdp2 where country='" + selectedCountriesStrings[i] + "' AND " + yearsQuery);
                         query.first();
                         QScatterSeries* series = new QScatterSeries;
                         series->setName(selectedCountriesStrings[i]);
                         // the data for some of the coutries for some years might be missing.
                         for (int k = 0; k < selectedYearsInts.size(); k++)
                         {
                             if (selectedYearsInts[k] == query.value(0).toInt())
                             {
                                 *series << QPointF(query.value(0).toInt() , query.value(1).toReal());
                                 qDebug() << query.value(0).toString() << query.value(1).toReal() << " : " << QString("%1").arg(selectedYearsInts[k]);
                                 query.next();
                             }
                             else
                             {
                                 // data missing, put 0
                                 *series << QPointF(selectedYearsInts[k] , 0.0f);
                                 qDebug() << "Putting 0 for the missing data" << " : " << QString("%1").arg(selectedYearsInts[i]) << " " << query.value(0).toInt();
                             }
                         }
                         //            chartArea->axisX()->setRange(selectedYearsInts[selectedYearsInts.size() - 1] + 1, selectedYearsInts[0] - 1);
                         chartView->chart()->addSeries(series);
                     }
                     chartView->chart()->axisX()->setRange(selectedYearsInts[selectedYearsInts.size() - 1] - 1, selectedYearsInts[0] + 1);
                 }
             }
             void Widget::printChart()
             {
                 QPrinter printer;
                 //    QPrinter printer(QPrinter::HighResolution);
                 printer.setOutputFormat(QPrinter::PdfFormat);
                 printer.setOrientation(QPrinter::Landscape);
                 printer.setOutputFileName("print.pdf");
                 QPainter painter;
                 painter.begin(&printer);
                 chartView->render(&painter);
             }

test/test.pri +4 -4

-            !include( ../common.pri ) {
+            !include( ../config.pri ) {
-                error( "Couldn't find the common.pri file!" )
+                error( "Couldn't find the config.pri file!" )
             }
-            !include( ../integrated.pri ) {
+            !include( ../build.pri ) {
-                error( "Couldn't find the integrated.pri file !")
+                error( "Couldn't find the build.pri file !")
             }
             TEMPLATE = app
             DESTDIR = $$CHART_BUILD_BIN_DIR/test
             OBJECTS_DIR = $$CHART_BUILD_DIR/test/$$TARGET
             MOC_DIR = $$CHART_BUILD_DIR/test/$$TARGET
             UI_DIR = $$CHART_BUILD_DIR/test/$$TARGET
             RCC_DIR = $$CHART_BUILD_DIR/test/$$TARGET

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