HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r30:ef99599d15b7

Renamed to QtCommercialChart

Tero Ahola -

r30:ef99599d15b7

parent child

Context file:

r30:ef99599d15b7

Expand all files

features/qtcommercialchart.prf created 644 +9 0

@@ -0,0 +1,9
	1	message( "Configuring with QtCommercialChart addon..." )
	2
	3	INCLUDEPATH += $$[QT_INSTALL_HEADERS]/QtCommercialChart
	4
	5	CONFIG(debug, debug\|release) {
	6	LIBS += -lQtCommercialChartd
	7	} else {
	8	LIBS += -lQtCommercialChart
	9	}

src/qchartglobal.h created 644 +25 0

@@ -0,0 +1,25
	1	#ifndef CHARTGLOBAL_H
	2	#define CHARTGLOBAL_H
	3
	4	#define QTCOMMERCIALCHART_VERSION_STR "1.0"
	5	#define QTCOMMERCIALCHART_VERSION 0x01
	6
	7	#if defined(QTCOMMERCIALCHART_LIBRARY)
	8	# define QTCOMMERCIALCHART_EXPORT Q_DECL_EXPORT
	9	#else
	10	# define QTCOMMERCIALCHART_EXPORT Q_DECL_IMPORT
	11	#endif
	12
	13	#define QTCOMMERCIALCHART_NAMESPACE QtCommercialChart
	14
	15	#ifdef QTCOMMERCIALCHART_NAMESPACE
	16	# define QTCOMMERCIALCHART_BEGIN_NAMESPACE namespace QTCOMMERCIALCHART_NAMESPACE {
	17	# define QTCOMMERCIALCHART_END_NAMESPACE }
	18	# define QTCOMMERCIALCHART_USE_NAMESPACE using namespace QTCOMMERCIALCHART_NAMESPACE;
	19	#else
	20	# define QTCOMMERCIALCHART_BEGIN_NAMESPACE
	21	# define QTCOMMERCIALCHART_END_NAMESPACE
	22	# define QTCOMMERCIALCHART_USE_NAMESPACE
	23	#endif
	24
	25	#endif

charts.pro +10 -11

@@ -1,11 +1,10
1	TEMPLATE = subdirs	1	TEMPLATE = subdirs
2	SUBDIRS += src #qmlplugin	2	SUBDIRS += src #qmlplugin
3		3
4	QMAKE_CXXFLAGS += -g -Wall	4	QMAKE_CXXFLAGS += -g -Wall
5	QMAKE_DISTCLEAN += -r build	5	QMAKE_DISTCLEAN += -r build
6		6
7	# install feature file	7	# install feature file
8	feature.path = $$[QT_INSTALL_DATA]/mkspecs/features	8	feature.path = $$[QT_INSTALL_DATA]/mkspecs/features
9	feature.files = $$PWD/features/charts.prf	9	feature.files = $$PWD/features/qtcommercialchart.prf
10	INSTALLS += feature	10	INSTALLS += feature
11

example/linechart/linechart.pro +1 -1

             TARGET = lineChart
             TEMPLATE = app
             QT += core gui
-            CONFIG += charts
+            CONFIG += qtcommercialchart
             SOURCES += main.cpp

example/linechart/main.cpp +1 -1

             #include <QApplication>
             #include <QMainWindow>
             #include <qchartwidget.h>
             #include <qxychartseries.h>
             #include <qchart.h>
             #include <cmath>
-            QCHART_USE_NAMESPACE
+            QTCOMMERCIALCHART_USE_NAMESPACE
             #define PI 3.14159265358979
             int main(int argc, char *argv[])
             {
                 QApplication a(argc, argv);
                 QMainWindow window;
                 QXYChartSeries* series0 = QXYChartSeries::create();
                 series0->setColor(Qt::blue);
                 QXYChartSeries* series1 = QXYChartSeries::create();
                 series1->setColor(Qt::red);
                 QXYChartSeries* series2 = QXYChartSeries::create();
                 series2->setColor(Qt::gray);
                 QXYChartSeries* series3 = QXYChartSeries::create();
                 series3->setColor(Qt::green);
                 int numPoints = 100;
                 for (int x = 0; x < numPoints; ++x) {
                 	  series0->add(x,0);
                 	  series1->add(x, abs(sin(PI/50*x)*100));
                 	  series2->add(x, abs(cos(PI/50*x)*100));
                 	  series3->add(x,100);
                  }
                 QList<QXYChartSeries*> dataset;
                 //qDebug()<<"Series 1:" << *series1;
                 //qDebug()<<"Series 2:" << *series2;
                 dataset << series0;
                 dataset << series1;
                 dataset << series2;
                 dataset << series3;
                 QChartWidget* chartWidget =  new QChartWidget(&window);
                 chartWidget->addSeries(series1);
                 chartWidget->addSeries(series2);
                 window.setCentralWidget(chartWidget);
                 window.resize(400, 300);
                 window.show();
                 return a.exec();
             }

src/axis.cpp +2 -2

             #include "axis_p.h"
             #include <QPainter>
             #include <QDebug>
-            QCHART_BEGIN_NAMESPACE
+            QTCOMMERCIALCHART_BEGIN_NAMESPACE
             Axis::Axis(QGraphicsItem* parent): QGraphicsItem(parent)
             {
             }
             Axis::~Axis()
             {
             }
             void Axis::setLength(int length)
             {
                 QPainterPath path;
                 path.moveTo(QPointF(0,0));
                 path.lineTo(length,0);
                // path.lineTo(length-4,0);
                // path.lineTo(length,3);
                // path.lineTo(length-4,6);
                // path.lineTo(length-4,4);
                // path.lineTo(0,4);
                // path.lineTo(0,2);
                 m_path=path;
                 update();
             }
             QRectF Axis::boundingRect() const
             {
                 return m_path.boundingRect();
             }
             QPainterPath Axis::shape() const
             {
                 return m_path;
             }
             void Axis::paint(QPainter *painter, const QStyleOptionGraphicsItem *option,QWidget *widget)
             {
                 painter->save();
                 QPen pen(Qt::black);
                 //pen.setWidth(10);
                 painter->setPen(pen);
                 painter->drawPath(m_path);
                 painter->restore();
             }
-            QCHART_END_NAMESPACE
+            QTCOMMERCIALCHART_END_NAMESPACE

src/axis_p.h +3 -3

             #ifndef AXIS_H_
             #define AXIS_H_
-            #include <qchartconfig.h>
+            #include <qchartglobal.h>
             #include <QGraphicsItem>
-            QCHART_BEGIN_NAMESPACE
+            QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class Axis: public QGraphicsItem
             {
             public:
                 Axis(QGraphicsItem* parent = 0);
                 virtual ~Axis();
                 //from QGraphicsItem
                 virtual QPainterPath shape() const;
                 virtual QRectF boundingRect() const;
                 virtual void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
                 void setLength(int length);
                 void setWidth(int width);
             private:
                 QPainterPath m_path;
             };
-            QCHART_END_NAMESPACE
+            QTCOMMERCIALCHART_END_NAMESPACE
             #endif /* AXIS_H_ */

src/qchart.cpp +7 -5

             #include "qchart.h"
             #include "qchartseries.h"
             #include "xylinechartitem_p.h"
             #include "xyplotdomain_p.h"
             #include "axis_p.h"
             #include "xygrid_p.h"
             #include <QDebug>
-            QCHART_BEGIN_NAMESPACE
+            QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QChartPrivate
             {
             public:
                 QChartPrivate(QChart* parent):
                 m_axisX(new Axis(parent)),
                 m_axisY(new Axis(parent)),
                 m_grid(new XYGrid(parent)),
                 m_plotDataIndex(0),
                 m_marginSize(0){}
                 Axis* m_axisX;
                 Axis* m_axisY;
                 XYGrid* m_grid;
                 QRect m_rect;
                 QList<const QChartSeries*> m_series;
                 QList<XYPlotDomain> m_plotDataList;
                 QList<QGraphicsItem*> m_items;
                 int m_plotDataIndex;
                 int m_marginSize;
             };
             ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
             QChart::QChart(QGraphicsItem* parent):QGraphicsItem(parent),
             d_ptr(new QChartPrivate(this))
             {
                 //  setFlags(QGraphicsItem::ItemClipsChildrenToShape);
                 // set axis
                 Q_D(QChart);
                 d->m_axisY->rotate(90);
                 //TODO hardcoded values , to removed soon
                 XYPlotDomain data;
                 data.m_minX = 0.0;
                 data.m_maxX = 100.0;
                 data.m_minY = 0.0;
                 data.m_maxY = 100.0;
                 data.m_ticksX=4;
                 data.m_ticksY=4;
                 d->m_plotDataList.clear();
                 d->m_plotDataList << data;
                 d->m_grid->setZValue(10);
                 d->m_grid->setXYPlotData(d->m_plotDataList.at(0));
             }
             QChart::~QChart(){}
             QRectF QChart::boundingRect() const
             {
                 Q_D(const QChart);
                 return d->m_rect;
             }
             void QChart::addSeries(QChartSeries* series)
             {
                 Q_D(QChart);
                 d->m_series<<series;
                 switch(series->type())
                 {
-                case QChartSeries::LINE:
+                case QChartSeries::SeriesTypeLine: {
                     XYLineChartItem* item = new XYLineChartItem(reinterpret_cast<QXYChartSeries*>(series),this);
                     item->updateXYPlotData(d->m_plotDataList.at(0));
                     d->m_items<<item;
                     break;
                 }
+                case QChartSeries::SeriesTypeScatter: {
+                    break;
+                }
+                }
             }
             void QChart::setSize(const QSizeF& size)
             {
                 Q_D(QChart);
                 //TODO refactor to setGeometry
                 d->m_rect = QRect(QPoint(0,0),size.toSize());
                 d->m_rect.adjust(margin(),margin(),-margin(),-margin());
                 d->m_grid->setPos(d->m_rect.topLeft());
                 d->m_grid->setSize(d->m_rect.size());
                 d->m_plotDataList[0].m_viewportRect = d->m_rect;
                 foreach(QGraphicsItem* item , d->m_items)
                 reinterpret_cast<XYLineChartItem*>(item)->updateXYPlotData(d->m_plotDataList.at(0));
                 update();
             }
             int QChart::margin() const
             {
                 Q_D(const QChart);
                 return d->m_marginSize;
             }
             void QChart::setMargin(int margin)
             {
                 Q_D(QChart);
                 d->m_marginSize = margin;
             }
+            QTCOMMERCIALCHART_END_NAMESPACE
-            QCHART_END_NAMESPACE

src/qchart.h +4 -4

             #ifndef CHART_H
             #define CHART_H
-            #include <qchartconfig.h>
+            #include <qchartglobal.h>
             #include <QGraphicsItem>
-            QCHART_BEGIN_NAMESPACE
+            QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class Axis;
             class XYGrid;
             class QChartSeries;
             class XYPlotDomain;
             class QChartPrivate;
-            class QCHART_EXPORT QChart : public QGraphicsItem
+            class QTCOMMERCIALCHART_EXPORT QChart : public QGraphicsItem
             {
             public:
                 QChart(QGraphicsItem* parent = 0);
                 virtual ~QChart();
                 //from QGraphicsItem
                 virtual QRectF boundingRect() const;
                 virtual void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget){};
                 void addSeries(QChartSeries* series);
                 virtual void setSize(const QSizeF& rect);
                 void setMargin(int margin);
                 int margin() const;
             protected:
                 QChartPrivate * const d_ptr;
             private:
                 Q_DISABLE_COPY(QChart)
                 Q_DECLARE_PRIVATE(QChart)
             };
-            QCHART_END_NAMESPACE
+            QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/qchartseries.h +12 -5

             #ifndef QCHARTSERIES_H
             #define QCHARTSERIES_H
-            #include "qchartconfig.h"
+            #include "qchartglobal.h"
             #include <QObject>
-            QCHART_BEGIN_NAMESPACE
+            QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            class QCHART_EXPORT QChartSeries : public QObject
+            class QTCOMMERCIALCHART_EXPORT QChartSeries : public QObject
             {
             public:
-                enum QChartSeriesType {LINE,PIE,BAR};
+                enum QChartSeriesType {
+                    SeriesTypeLine = 0,
+            //        SeriesTypeArea,
+            //        SeriesTypeBar,
+            //        SeriesTypePie,
+                    SeriesTypeScatter
+            //        SeriesTypeSpline
+                };
             protected:
                 QChartSeries(QObject *parent = 0):QObject(parent){};
             public:
                 virtual ~QChartSeries(){};
                 //factory method
                 static QChartSeries* create(QObject* parent = 0 ){ return 0;}
                 //pure virtual
                 virtual QChartSeriesType type() const = 0;
             };
-            QCHART_END_NAMESPACE
+            QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/qchartwidget.cpp +2 -2

             #include "qchartwidget.h"
             #include "qchartseries.h"
             #include <QGraphicsView>
             #include <QGraphicsScene>
             #include <QResizeEvent>
-            QCHART_BEGIN_NAMESPACE
+            QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QChartWidgetPrivate
             {
             public:
                 QChartWidgetPrivate(QChartWidget *parent) :
                 m_view(0),
                 m_scene(0),
                 m_chart(0)
                 {
                     m_scene = new QGraphicsScene();
                     m_view = new QGraphicsView(parent);
                     m_view->setScene(m_scene);
                     m_chart = new QChart();
                     m_scene->addItem(m_chart);
                 }
                 ~QChartWidgetPrivate() {
                 }
                 QGraphicsView *m_view;
                 QGraphicsScene *m_scene;
                 QChart* m_chart;
             };
             ///////////////////////////////////////////////////////////////////////////////////////////////////
             QChartWidget::QChartWidget(QWidget *parent) :
                 QWidget(parent),
                 d_ptr(new QChartWidgetPrivate(this))
             {
                 setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
             }
             QChartWidget::~QChartWidget()
             {
                 delete d_ptr;
             }
             void QChartWidget::resizeEvent(QResizeEvent *event)
             {
                 Q_D(QChartWidget);
                 d->m_view->resize(size().width(),size().height());
                 d->m_scene->setSceneRect(0,0,size().width(),size().height());
                 d->m_chart->setSize(size());
                 QWidget::resizeEvent(event);
             }
             QSize QChartWidget::sizeHint() const
             {
                 // TODO: calculate size hint based on contents?
                 return QSize(100, 100);
             }
             void QChartWidget::addSeries(QChartSeries* series)
             {
                 Q_D(QChartWidget);
                 d->m_chart->addSeries(series);
             }
             #include "moc_qchartwidget.cpp"
-            QCHART_END_NAMESPACE
+            QTCOMMERCIALCHART_END_NAMESPACE

src/qchartwidget.h +4 -4

             #ifndef QCHARTWIDGET_H
             #define QCHARTWIDGET_H
-            #include "qchartconfig.h"
+            #include "qchartglobal.h"
             #include "qchart.h"
             #include <QWidget>
-            QCHART_BEGIN_NAMESPACE
+            QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QChartSeries;
             class QChartWidgetPrivate;
-            class QCHART_EXPORT QChartWidget : public QWidget
+            class QTCOMMERCIALCHART_EXPORT QChartWidget : public QWidget
             {
                 Q_OBJECT
             public:
                 explicit QChartWidget(QWidget *parent = 0);
                 ~QChartWidget();
                 //implement from QWidget
                 void resizeEvent(QResizeEvent *event);
                 QSize sizeHint() const;
                 void addSeries(QChartSeries* series);
             protected:
                 QChartWidgetPrivate * const d_ptr;
             private:
                 Q_DISABLE_COPY(QChartWidget)
                 Q_DECLARE_PRIVATE(QChartWidget)
             };
-            QCHART_END_NAMESPACE
+            QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QCHARTWIDGET_H

src/src.pro +49 -46

@@ -1,46 +1,49
1	TARGET = QChart	1	TARGET = QtCommercialChart
2	TEMPLATE = lib	2	TEMPLATE = lib
3	QT += core \	3	QT += core \
4	gui	4	gui
5	CONFIG += debug_and_release	5	CONFIG += debug_and_release
6	CONFIG(debug, debug\|release):TARGET = QChartd	6	CONFIG(debug, debug\|release):TARGET = QtCommercialChartd
7		7
8	SOURCES += \	8	SOURCES += \
9	xylinechart/qxychartseries.cpp \	9	xylinechart/qxychartseries.cpp \
10	xylinechart/xylinechartitem.cpp \	10	xylinechart/xylinechartitem.cpp \
11	xylinechart/xygrid.cpp \	11	xylinechart/xygrid.cpp \
12	xylinechart/xyplotdomain.cpp \	12	xylinechart/xyplotdomain.cpp \
13	qchart.cpp \	13	qchart.cpp \
14	axis.cpp \	14	axis.cpp \
15	qchartwidget.cpp	15	qchartwidget.cpp
16		16
17	PRIVATE_HEADERS += \	17	PRIVATE_HEADERS += \
18	xylinechart/xylinechartitem_p.h \	18	xylinechart/xylinechartitem_p.h \
19	xylinechart/xyplotdomain_p.h \	19	xylinechart/xyplotdomain_p.h \
20	xylinechart/xygrid_p.h \	20	xylinechart/xygrid_p.h \
21	axis_p.h	21	axis_p.h
22		22
23	PUBLIC_HEADERS += \	23	PUBLIC_HEADERS += \
24	qchartseries.h \	24	qchartseries.h \
25	qchart.h \	25	qchart.h \
26	qchartwidget.h \	26	qchartwidget.h \
27	qchart~~confi~~g.h \	27	qchartglobal.h \
28	xylinechart/qxychartseries.h	28	xylinechart/qxychartseries.h
29		29
30	HEADERS += $$PUBLIC_HEADERS	30	HEADERS += $$PUBLIC_HEADERS
31	HEADERS += $$PRIVATE_HEADERS	31	HEADERS += $$PRIVATE_HEADERS
32		32
33	INCLUDEPATH += xylinechart \	33	INCLUDEPATH += xylinechart \
34	.	34	.
35		35
36	OBJECTS_DIR = ../build/lib	36	OBJECTS_DIR = ../build/lib
37	MOC_DIR = ../build/lib	37	MOC_DIR = ../build/lib
38	UI_DIR = ../build/lib	38	UI_DIR = ../build/lib
39	RCC_DIR = ../build/lib	39	RCC_DIR = ../build/lib
40	DEFINES += QCHART_LIBRARY	40	DEFINES += QTCOMMERCIALCHART_LIBRARY
41		41
42	public_headers.path = $$[QT_INSTALL_HEADERS]/QCharts	42	public_headers.path = $$[QT_INSTALL_HEADERS]/QtCommercialChart
43	public_headers.files = $$PUBLIC_HEADERS	43	public_headers.files = $$PUBLIC_HEADERS
44	target.path = $$[QT_INSTALL_LIBS]	44	target.path = $$[QT_INSTALL_LIBS]
45	INSTALLS += target \	45	INSTALLS += target \
46	public_headers	46	public_headers
		47
		48
		49

src/xylinechart/qxychartseries.cpp +2 -2

             #include "qxychartseries.h"
-            QCHART_BEGIN_NAMESPACE
+            QTCOMMERCIALCHART_BEGIN_NAMESPACE
             QXYChartSeries::QXYChartSeries(QObject* parent):QChartSeries(parent),
                 m_color(Qt::black)
             {
             }
             QXYChartSeries::~QXYChartSeries()
             {
             }
             QXYChartSeries* QXYChartSeries::create(QObject* parent)
             {
                 //TODO: here we take QChartData when it is ready
                 // return null if malformed;
                 return new QXYChartSeries(parent);
             }
             void QXYChartSeries::setColor(const QColor& color)
             {
             	m_color = color;
             }
             void QXYChartSeries::add(qreal x,qreal y)
             {
                 m_x<<x;
                 m_y<<y;
             }
             void QXYChartSeries::clear()
             {
                 m_x.clear();
                 m_y.clear();
             }
             qreal QXYChartSeries::x(int pos) const
             {
                return m_x.at(pos);
             }
             qreal QXYChartSeries::y(int pos) const
             {
                return m_y.at(pos);
             }
             int QXYChartSeries::count() const
             {
             	Q_ASSERT(m_x.size() == m_y.size());
             	return m_x.size();
             }
             QDebug operator<< (QDebug debug, const QXYChartSeries series)
             {
             	Q_ASSERT(series.m_x.size() == series.m_y.size());
                 int size = series.m_x.size();
                 for (int i=0;i<size;i++) {
                 debug.nospace() << "(" << series.m_x.at(i) << ','<< series.m_y.at(i) << ") ";
                 }
                 return debug.space();
             }
-            QCHART_END_NAMESPACE
+            QTCOMMERCIALCHART_END_NAMESPACE

src/xylinechart/qxychartseries.h +5 -5

             #ifndef QXYSERIES_H_
             #define QXYSERIES_H_
-            #include "qchartconfig.h"
+            #include "qchartglobal.h"
             #include "qchartseries.h"
             #include <QDebug>
             #include <QColor>
-            QCHART_BEGIN_NAMESPACE
+            QTCOMMERCIALCHART_BEGIN_NAMESPACE
-            class QCHART_EXPORT QXYChartSeries : public QChartSeries
+            class QTCOMMERCIALCHART_EXPORT QXYChartSeries : public QChartSeries
             {
             private:
                 QXYChartSeries(QObject* parent=0);
             public:
                 virtual ~QXYChartSeries();
                 //implemented from QChartSeries
                 static QXYChartSeries* create(QObject* parent=0);
-                virtual QChartSeriesType type() const { return QChartSeries::LINE;};
+                virtual QChartSeriesType type() const { return QChartSeries::SeriesTypeLine;}
                 void add(qreal x, qreal y);
                 void clear();
                 void setColor(const QColor& color);
                 const QColor& color() const { return m_color;}
                 int count() const;
                 qreal x(int pos) const;
                 qreal y(int pos) const;
                 friend QDebug operator<< (QDebug d, const QXYChartSeries series);
             private:
                 QColor m_color;
                 QList<qreal> m_x;
                 QList<qreal> m_y;
             };
-            QCHART_END_NAMESPACE
+            QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/xylinechart/xygrid.cpp +2 -2

             #include "xygrid_p.h"
             #include <QPainter>
             #include <QDebug>
-            QCHART_BEGIN_NAMESPACE
+            QTCOMMERCIALCHART_BEGIN_NAMESPACE
             XYGrid::XYGrid(QGraphicsItem* parent):QGraphicsItem(parent)
             {
             }
             XYGrid::~XYGrid()
             {
                 // TODO Auto-generated destructor stub
             }
             void XYGrid::setSize(const QSizeF& size)
             {
             	m_rect.setSize(size.toSize());
             }
             void XYGrid::setXYPlotData(const XYPlotDomain& xyPlotData)
             {
                 m_xyPlotData = xyPlotData;
             }
             QRectF XYGrid::boundingRect() const
             {
             	return m_rect;
             }
             void XYGrid::paint(QPainter *painter, const QStyleOptionGraphicsItem *option,QWidget *widget)
             {
                 if (!m_rect.isValid())
                 return;
                 const qreal deltaX = (m_rect.width() -1) / m_xyPlotData.ticksX();
                 const qreal deltaY = (m_rect.height() - 1) / m_xyPlotData.ticksY();
                 for (int i = 0; i <= m_xyPlotData.ticksX(); ++i) {
                     int x = i * deltaX + m_rect.left();
                     qreal label = m_xyPlotData.m_minX + (i * m_xyPlotData.spanX()
                         / m_xyPlotData.ticksX());
                     painter->drawLine(x, m_rect.top()+1, x, m_rect.bottom());
                     //painter->drawLine(x, m_rect.bottom(), x, m_rect.bottom() + 5);
                     painter->drawText(x - 50, m_rect.bottom() + 5, 100, 20,
                         Qt::AlignHCenter | Qt::AlignTop,
                         QString::number(label));
                 }
                 for (int j = 0; j <= m_xyPlotData.ticksY(); ++j) {
                     int y = j * -deltaY + m_rect.bottom();
                     qreal label = m_xyPlotData.m_minY + (j * m_xyPlotData.spanY()
                         / m_xyPlotData.ticksY());
                     painter->drawLine(m_rect.left(), y, m_rect.right()-1, y);
                     //painter->drawLine(m_rect.left() - 5, y, m_rect.left(), y);
                     //TODO : margin = 50 ;
                     painter->drawText(m_rect.left() - 50, y - 10, 50 - 5, 20,
                         Qt::AlignRight | Qt::AlignVCenter,
                         QString::number(label));
                 }
                 //painter->drawRect(m_rect.adjusted(0, 0, -1, -1));
             }
-            QCHART_END_NAMESPACE
+            QTCOMMERCIALCHART_END_NAMESPACE

src/xylinechart/xygrid_p.h +3 -3

             #ifndef XYGRID_H_
             #define XYGRID_H_
-            #include <qchartconfig.h>
+            #include <qchartglobal.h>
             #include <xyplotdomain_p.h>
             #include <QGraphicsItem>
-            QCHART_BEGIN_NAMESPACE
+            QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class XYGrid : public QGraphicsItem
             {
             public:
                 XYGrid(QGraphicsItem* parent = 0);
                 virtual ~XYGrid();
                 //from QGraphicsItem
                 virtual QRectF boundingRect() const;
                 virtual void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
                 //TODO: this is just temporary interface
                 void setXYPlotData(const XYPlotDomain& xyPlotData);
                 void setSize(const QSizeF& rect);
             private:
                 QRectF m_rect;
                 XYPlotDomain m_xyPlotData;
             };
-            QCHART_END_NAMESPACE
+            QTCOMMERCIALCHART_END_NAMESPACE
             #endif /* XYGRID_H_ */

src/xylinechart/xylinechartitem.cpp +2 -2

             #include "xylinechartitem_p.h"
             #include "axis_p.h"
             #include "xygrid_p.h"
             #include "qxychartseries.h"
             #include <QPainter>
             #include <QStyleOptionGraphicsItem>
             #include <QDebug>
-            QCHART_BEGIN_NAMESPACE
+            QTCOMMERCIALCHART_BEGIN_NAMESPACE
             XYLineChartItem::XYLineChartItem(QXYChartSeries* series,QGraphicsItem *parent):QGraphicsItem(parent),
             m_series(series)
             {
             }
             void XYLineChartItem::updateXYPlotData(const XYPlotDomain& data)
             {
                 m_xyPlotData=data;
                 if (!m_xyPlotData.m_viewportRect.isValid())
                 return;
                 const QRect& rect =  m_xyPlotData.m_viewportRect;
                 const qreal deltaX = (rect.width()-1)/m_xyPlotData.spanX();
                 const qreal deltaY = (rect.height()-1)/m_xyPlotData.spanY();
                 m_polyline.clear();
                 m_polyline.resize(m_series->count());
                 for (int j = 0; j < m_series->count(); ++j) {
                     qreal dx = m_series->x(j) - m_xyPlotData.m_minX;
                     qreal dy = m_series->y(j) - m_xyPlotData.m_minY;
                     qreal x = (dx * deltaX) + rect.left();
                     qreal y = - (dy * deltaY) + rect.bottom();
                     m_polyline[j] = QPointF(x, y);
                 }
             }
             QRectF XYLineChartItem::boundingRect() const
             {
             	return m_polyline.boundingRect();
             }
             void XYLineChartItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option,QWidget *widget)
             {
                 painter->setClipRect(m_xyPlotData.m_viewportRect.adjusted(+1, +1, -1, -1));
                 painter->setPen(m_series->color());
                 painter->drawPolyline(m_polyline);
             }
-            QCHART_END_NAMESPACE
+            QTCOMMERCIALCHART_END_NAMESPACE

src/xylinechart/xylinechartitem_p.h +3 -3

             #ifndef XYLINECHARTITEM_H
             #define XYLINECHARTITEM_H
-            #include "qchartconfig.h"
+            #include "qchartglobal.h"
             #include "qchart.h"
             #include "xyplotdomain_p.h"
-            QCHART_BEGIN_NAMESPACE
+            QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QXYChartSeries;
             class XYLineChartItem : public QGraphicsItem
             {
             public:
                 XYLineChartItem(QXYChartSeries* m_series,QGraphicsItem *parent = 0);
                 virtual ~ XYLineChartItem(){};
                 //from QGraphicsItem
                 virtual QRectF boundingRect() const;
                 virtual void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
                 void updateXYPlotData(const XYPlotDomain& data);
             private:
                 QPolygonF m_polyline;
                 QXYChartSeries* m_series;
                 XYPlotDomain m_xyPlotData;
             };
-            QCHART_END_NAMESPACE
+            QTCOMMERCIALCHART_END_NAMESPACE
             #endif

src/xylinechart/xyplotdomain.cpp +2 -2

             #include "xyplotdomain_p.h"
-            QCHART_BEGIN_NAMESPACE
+            QTCOMMERCIALCHART_BEGIN_NAMESPACE
             XYPlotDomain::XYPlotDomain():
             m_ticksX(0),
             m_ticksY(0),
             m_minX(0),
             m_maxX(0),
             m_minY(0),
             m_maxY(0)
             {
             }
             XYPlotDomain::~XYPlotDomain()
             {
             	// TODO Auto-generated destructor stub
             }
             qreal XYPlotDomain::spanX() const
             {
             	Q_ASSERT(m_maxX >= m_minX);
             	return m_maxX - m_minX;
             }
             qreal XYPlotDomain::spanY() const
             {
             	Q_ASSERT(m_maxY >= m_minY);
             	return m_maxY - m_minY;
             }
-            QCHART_END_NAMESPACE
+            QTCOMMERCIALCHART_END_NAMESPACE

src/xylinechart/xyplotdomain_p.h +3 -3

             #ifndef PLOTDOMAIN_H_
             #define PLOTDOMAIN_H_
-            #include "qchartconfig.h"
+            #include "qchartglobal.h"
             #include <QRect>
-            QCHART_BEGIN_NAMESPACE
+            QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class XYPlotDomain {
             public:
             	XYPlotDomain();
             	virtual ~XYPlotDomain();
             	qreal spanX() const;
             	qreal spanY() const;
             	int ticksX() const { return m_ticksX; }
             	int ticksY() const { return m_ticksY; }
             public:
             	int m_ticksX;
             	int m_ticksY;
             	qreal m_minX;
             	qreal m_maxX;
             	qreal m_minY;
             	qreal m_maxY;
             	QRect m_viewportRect;
             };
-            QCHART_END_NAMESPACE
+            QTCOMMERCIALCHART_END_NAMESPACE
             #endif /* PLOTTER_H_ */

test/chartwidgettest/chartwidgettest.pro +1 -1

             TARGET = chartwidgettest
             TEMPLATE = app
             QT += core gui
             contains(QT_MAJOR_VERSION, 5) {
                 QT += widgets
             }
-            CONFIG += charts
+            CONFIG += qtcommercialchart
             OBJECTS_DIR = tmp
             MOC_DIR = tmp
             SOURCES += main.cpp \
                 mainwidget.cpp \
             #    qscatterseries.cpp \
             #    qseriespointgraphicsitem.cpp \
                 dataseriedialog.cpp
             HEADERS += \
                 mainwidget.h \
             #    qscatterseries.h \
             #    qseriespointgraphicsitem.h \
                 dataseriedialog.h

test/chartwidgettest/mainwidget.cpp +16 -14

             #include "mainwidget.h"
             #include "dataseriedialog.h"
             #include <qxychartseries.h>
             #include <QPushButton>
             #include <QComboBox>
             #include <QSpinBox>
             #include <QCheckBox>
             #include <QGridLayout>
             #include <QHBoxLayout>
             #include <QLabel>
             #include <QSpacerItem>
             #include <QMessageBox>
             #include <cmath>
             #include <QDebug>
-            QCHART_USE_NAMESPACE
+            QTCOMMERCIALCHART_USE_NAMESPACE
             MainWidget::MainWidget(QWidget *parent) :
                 QWidget(parent)
             {
-                m_chartWidget = new QChartWidget(this);
-            //    m_chartWidget->resize(QSize(200,200));
-            //    m_chartWidget->setColor(Qt::red);
                 QPushButton *addSeriesButton = new QPushButton("Add series");
                 connect(addSeriesButton, SIGNAL(clicked()), this, SLOT(addSeries()));
                 // Chart background
                 QComboBox *backgroundCombo = new QComboBox(this);
                 backgroundCombo->addItem("None");
                 backgroundCombo->addItem("TODO Grid");
                 backgroundCombo->addItem("TODO Image");
                 connect(backgroundCombo, SIGNAL(currentIndexChanged(int)),
                         this, SLOT(backgroundChanged(int)));
                 // Axis
                 // TODO: multiple axes?
                 m_autoScaleCheck = new QCheckBox("Automatic scaling");
                 connect(m_autoScaleCheck, SIGNAL(stateChanged(int)), this, SLOT(autoScaleChanged(int)));
                 // Allow setting also non-sense values (like -2147483648 and 2147483647)
                 m_xMinSpin = new QSpinBox();
                 m_xMinSpin->setMinimum(INT_MIN);
                 m_xMinSpin->setMaximum(INT_MAX);
                 m_xMinSpin->setValue(0);
                 connect(m_xMinSpin, SIGNAL(valueChanged(int)), this, SLOT(xMinChanged(int)));
                 m_xMaxSpin = new QSpinBox();
                 m_xMaxSpin->setMinimum(INT_MIN);
                 m_xMaxSpin->setMaximum(INT_MAX);
                 m_xMaxSpin->setValue(10);
                 connect(m_xMaxSpin, SIGNAL(valueChanged(int)), this, SLOT(xMaxChanged(int)));
                 m_yMinSpin = new QSpinBox();
                 m_yMinSpin->setMinimum(INT_MIN);
                 m_yMinSpin->setMaximum(INT_MAX);
                 m_yMinSpin->setValue(0);
                 connect(m_yMinSpin, SIGNAL(valueChanged(int)), this, SLOT(yMinChanged(int)));
                 m_yMaxSpin = new QSpinBox();
                 m_yMaxSpin->setMinimum(INT_MIN);
                 m_yMaxSpin->setMaximum(INT_MAX);
                 m_yMaxSpin->setValue(10);
                 connect(m_yMaxSpin, SIGNAL(valueChanged(int)), this, SLOT(yMaxChanged(int)));
                 QGridLayout *grid = new QGridLayout();
                 QHBoxLayout *hbox = new QHBoxLayout();
                 //grid->addWidget(new QLabel("Add series:"), 0, 0);
                 grid->addWidget(addSeriesButton, 0, 1);
                 grid->addWidget(new QLabel("Background:"), 2, 0);
                 grid->addWidget(backgroundCombo, 2, 1);
                 grid->addWidget(m_autoScaleCheck, 3, 0);
                 grid->addWidget(new QLabel("x min:"), 4, 0);
                 grid->addWidget(m_xMinSpin, 4, 1);
                 grid->addWidget(new QLabel("x max:"), 5, 0);
                 grid->addWidget(m_xMaxSpin, 5, 1);
                 grid->addWidget(new QLabel("y min:"), 6, 0);
                 grid->addWidget(m_yMinSpin, 6, 1);
                 grid->addWidget(new QLabel("y max:"), 7, 0);
                 grid->addWidget(m_yMaxSpin, 7, 1);
                 // add row with empty label to make all the other rows static
                 grid->addWidget(new QLabel(""), 8, 0);
                 grid->setRowStretch(8, 1);
                 hbox->addLayout(grid);
+                m_chartWidget = new QChartWidget(this);
+                //m_chartWidget->setColor(Qt::red);
                 hbox->addWidget(m_chartWidget);
-                hbox->setStretch(1, 1);
+            //    hbox->setStretch(1, 1);
                 setLayout(hbox);
                 m_autoScaleCheck->setChecked(true);
                 chartTypeChanged(4);
                 testDataChanged(0);
             }
             void MainWidget::addSeries()
             {
                 DataSerieDialog dialog(m_defaultSeries, this);
                 connect(&dialog, SIGNAL(accepted(QString, QString)), this, SLOT(addSeries(QString, QString)));
                 dialog.exec();
             }
             void MainWidget::addSeries(QString series, QString data)
             {
                 qDebug() << "addSeries: " << series << " data: " << data;
                 m_defaultSeries = series;
+                QXYChartSeries* series0 = 0;
                 // TODO: color of the series
-                QXYChartSeries* series0 = QXYChartSeries::create();
+                if (series == "Scatter") {
+                    series0 = QXYChartSeries::create();
+                } else if (series == "Line") {
+                    series0 = QXYChartSeries::create();
+                } else {
+                    // TODO
+                    series0 = QXYChartSeries::create();
+                }
                 if (data == "linear") {
                     for (int i = 0; i < 10; i++)
                         series0->add(i, 10);
                 } else if (data == "linear, 1M") {
                     for (int i = 0; i < 1000000; i++)
                         series0->add(i, 20);
                 } else if (data == "SIN") {
                     for (int x = 0; x < 100; x++)
                           series0->add(x, abs(sin(3.14159265358979 / 50 * x) * 100));
                     QList<QXYChartSeries*> dataset;
                     dataset << series0;
                 } else if (data == "SIN + random") {
                     for (qreal x = 0; x < 100; x += 0.1) {
                         series0->add(x + (rand() % 5),
                                      abs(sin(3.14159265358979 / 50 * x) * 100) + (rand() % 5));
                     }
                 } else {
                     // TODO: check if data has a valid file name
                 }
-                if (series == "Scatter") {
+                m_chartWidget->addSeries(series0);
-                    m_chartWidget->addSeries(series0);
-                } else if (series == "Line") {
-                    m_chartWidget->addSeries(series0);
-                } else {
-                    // TODO
             }
             void MainWidget::chartTypeChanged(int itemIndex)
             {
                 // TODO: change chart type
                 switch (itemIndex) {
                 case 4:
                     //m_chartWidget->setType(4);
                     break;
                 default: {
                     //m_chartWidget->setType(0);
                     break;
                 }
                 }
             }
             void MainWidget::testDataChanged(int itemIndex)
             {
                 qDebug() << "testDataChanged: " << itemIndex;
             //    switch (itemIndex) {
             //    case 0: {
             //        QList<QChartDataPoint> data;
             //        for (int x = 0; x < 20; x++) {
             //            data.append(QChartDataPoint() << x << x / 2);
             //        }
             //        m_chartWidget->setData(data);
             //        break;
             //    }
             //    case 1: {
             //        QList<QChartDataPoint> data;
             //        for (int x = 0; x < 100; x++) {
             //            data.append(QChartDataPoint() << x - 200 << 2 * (uint(sin(3.14159/50*x)*80) % 100));
             //        }
             //        m_chartWidget->setData(data);
             //        break;
             //    }
             //    case 2: {
             //        QList<QChartDataPoint> data;
             //        for (int x = 0; x < 1000; x++) {
             //            data.append(QChartDataPoint() << x - 200 << 2 * (uint(sin(3.14159/50*x)*80) % 100) + (rand() % 100 * 0.2));
             //            data.append(QChartDataPoint() << x - 200 << 2 * (uint(sin(3.14159/50*x)*80) % 100) + (rand() % 100 * 0.2));
             //            data.append(QChartDataPoint() << x - 200 << 2 * (uint(sin(3.14159/50*x)*80) % 100) + (rand() % 100 * 0.2));
             //        }
             //        m_chartWidget->setData(data);
             //        break;
             //    }
             //    default:
             //        break;
             //    }
             }
             void MainWidget::backgroundChanged(int itemIndex)
             {
                 qDebug() << "backgroundChanged: " << itemIndex;
             }
             void MainWidget::autoScaleChanged(int value)
             {
                 if (value) {
                     // TODO: enable auto scaling
                 } else {
                     // TODO: set scaling manually (and disable auto scaling)
                 }
                 m_xMinSpin->setEnabled(!value);
                 m_xMaxSpin->setEnabled(!value);
                 m_yMinSpin->setEnabled(!value);
                 m_yMaxSpin->setEnabled(!value);
             }
             void MainWidget::xMinChanged(int value)
             {
                 qDebug() << "xMinChanged: " << value;
             }
             void MainWidget::xMaxChanged(int value)
             {
                 qDebug() << "xMaxChanged: " << value;
             }
             void MainWidget::yMinChanged(int value)
             {
                 qDebug() << "yMinChanged: " << value;
             }
             void MainWidget::yMaxChanged(int value)
             {
                 qDebug() << "yMaxChanged: " << value;
             }

test/chartwidgettest/mainwidget.h +2 -2

             #ifndef MAINWIDGET_H
             #define MAINWIDGET_H
-            #include <qchartconfig.h>
+            #include <qchartglobal.h>
             #include <qchartwidget.h>
             #include <QWidget>
             class QSpinBox;
             class QCheckBox;
-            QCHART_USE_NAMESPACE
+            QTCOMMERCIALCHART_USE_NAMESPACE
             class MainWidget : public QWidget
             {
                 Q_OBJECT
             public:
                 explicit MainWidget(QWidget *parent = 0);
             signals:
             private slots:
                 void chartTypeChanged(int itemIndex);
                 void addSeries();
                 void addSeries(QString series, QString data);
                 void testDataChanged(int itemIndex);
                 void backgroundChanged(int itemIndex);
                 void autoScaleChanged(int value);
                 void xMinChanged(int value);
                 void xMaxChanged(int value);
                 void yMinChanged(int value);
                 void yMaxChanged(int value);
             private:
                 QChartWidget *m_chartWidget;
                 QCheckBox *m_autoScaleCheck;
                 QSpinBox *m_xMinSpin;
                 QSpinBox *m_xMaxSpin;
                 QSpinBox *m_yMinSpin;
                 QSpinBox *m_yMaxSpin;
                 QString m_defaultSeries;
             };
             #endif // MAINWIDGET_H

features/charts.prf removed 0 -10

NO CONTENT: file was removed

src/qchartconfig.h removed 0 -25

NO CONTENT: file was removed

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