HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r291:2b7ffa40a22f

Refactors axis layout managment...

Michal Klocek -

r291:2b7ffa40a22f

parent child

Context file:

r291:2b7ffa40a22f

Collapse all files

src/axisanimationitem.cpp created 644 +70 0

@@ -0,0 +1,70
	1	#include "axisanimationitem_p.h"
	2	#include <QPropertyAnimation>
	3
	4	Q_DECLARE_METATYPE(QVector<qreal>)
	5
	6	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	7
	8	const static int duration = 500;
	9
	10	AxisAnimationItem::AxisAnimationItem(AxisType type,QGraphicsItem* parent) :
	11	AxisItem(type,parent)
	12	{
	13	}
	14
	15	AxisAnimationItem::~AxisAnimationItem()
	16	{
	17	}
	18
	19	void AxisAnimationItem::updateItems(QVector<qreal>& vector1)
	20	{
	21	QVector<qreal> vector0 = vector1;
	22	calculateLayout(vector1);
	23	if(vector1.count()==0) return;
	24	vector0.resize(vector1.size());
	25
	26	AxisAnimator *animation = new AxisAnimator(this);
	27	animation->setDuration(duration);
	28	animation->setEasingCurve(QEasingCurve::InOutBack);
	29	animation->setKeyValueAt(0.0, qVariantFromValue(vector0));
	30	animation->setKeyValueAt(1.0, qVariantFromValue(vector1));
	31	animation->start(QAbstractAnimation::DeleteWhenStopped);
	32	}
	33
	34	void AxisAnimationItem::setLabelsAngle(int angle)
	35	{
	36	AxisItem::setLabelsAngle(angle);
	37	}
	38
	39	AxisAnimator::AxisAnimator(AxisItem *axis): m_axis(axis)
	40	{
	41	}
	42
	43	AxisAnimator::~AxisAnimator()
	44	{
	45	}
	46
	47	QVariant AxisAnimator::interpolated(const QVariant &start, const QVariant & end, qreal progress ) const
	48	{
	49	QVector<qreal> startVector = qVariantValue<QVector<qreal> >(start);
	50	QVector<qreal> endVecotr = qVariantValue<QVector<qreal> >(end);
	51	QVector<qreal> result;
	52	Q_ASSERT(startVector.count() == endVecotr.count());
	53
	54	for(int i =0 ;i< startVector.count();i++){
	55	qreal value = startVector[i] + ((endVecotr[i]- startVector[i]) * progress);//qBound(0.0, progress, 1.0));
	56	result << value;
	57	}
	58	return qVariantFromValue(result);
	59	}
	60
	61
	62	void AxisAnimator::updateCurrentValue (const QVariant & value )
	63	{
	64	QVector<qreal> vector = qVariantValue<QVector<qreal> >(value);
	65	m_axis->applyLayout(vector);
	66	}
	67
	68	#include "moc_axisanimationitem_p.cpp"
	69
	70	QTCOMMERCIALCHART_END_NAMESPACE

src/axisanimationitem_p.h created 644 +44 0

@@ -0,0 +1,44
	1	#ifndef AXISANIMATIONITEM_H_
	2	#define AXISANIMATIONITEM_H_
	3
	4	#include "domain_p.h"
	5	#include "axisitem_p.h"
	6	#include <QGraphicsItem>
	7	#include <QVariantAnimation>
	8
	9	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	10
	11	class QChartAxis;
	12
	13	class AxisAnimationItem : public AxisItem
	14	{
	15	Q_OBJECT
	16
	17	public:
	18	AxisAnimationItem(AxisType type = X_AXIS,QGraphicsItem* parent = 0);
	19	~AxisAnimationItem();
	20
	21	void setLabelsAngle(int angle);
	22
	23	protected:
	24	void updateItems(QVector<qreal>& vector);
	25
	26	};
	27
	28	class AxisAnimator: public QVariantAnimation
	29	{
	30	public:
	31	AxisAnimator(AxisItem *axis);
	32	virtual ~AxisAnimator();
	33	protected:
	34	virtual QVariant interpolated (const QVariant & from, const QVariant & to, qreal progress ) const;
	35	virtual void updateCurrentValue (const QVariant & value );
	36	private:
	37	AxisItem* m_axis;
	38	};
	39
	40	QTCOMMERCIALCHART_END_NAMESPACE
	41
	42
	43
	44	#endif /* AXISITEM_H_ */

src/axisitem.cpp +123 -106

             #include "axisitem_p.h"
             #include "qchartaxis.h"
             #include "chartpresenter_p.h"
             #include <QPainter>
             #include <QDebug>
             static int label_padding = 5;
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             AxisItem::AxisItem(AxisType type,QGraphicsItem* parent) :
             ChartItem(parent),
             m_type(type),
             m_labelsAngle(0),
             m_grid(parent),
             m_shades(parent),
             m_labels(parent),
             m_axis(parent)
             {
                 //initial initialization
                 m_axis.setZValue(ChartPresenter::AxisZValue);
                 m_shades.setZValue(ChartPresenter::ShadesZValue);
                 m_grid.setZValue(ChartPresenter::GridZValue);
                 setFlags(QGraphicsItem::ItemHasNoContents);
             }
             AxisItem::~AxisItem()
             {
             }
             QRectF AxisItem::boundingRect() const
             {
-                return m_rect;
+                return QRectF();
             }
             void AxisItem::createItems(int count)
             {
-                m_axis.addToGroup(new QGraphicsLineItem(this));
+                if(m_axis.children().size()==0)
+                       m_axis.addToGroup(new QGraphicsLineItem());
                 for (int i = 0; i < count; ++i) {
-                       m_grid.addToGroup(new QGraphicsLineItem(this));
+                       m_grid.addToGroup(new QGraphicsLineItem());
-                       m_labels.addToGroup(new QGraphicsSimpleTextItem(this));
+                       m_labels.addToGroup(new QGraphicsSimpleTextItem());
-                       if(i%2) m_shades.addToGroup(new QGraphicsRectItem(this));
+                       if(m_grid.childItems().size()%2) m_shades.addToGroup(new QGraphicsRectItem());
-                       m_axis.addToGroup(new QGraphicsLineItem(this));
+                       m_axis.addToGroup(new QGraphicsLineItem());
                    }
             }
-            void AxisItem::clear()
+            void AxisItem::clear(int count)
             {
-                foreach(QGraphicsItem* item , m_shades.childItems()) {
+                QList<QGraphicsItem *> lines = m_grid.childItems();
-                    delete item;
+                QList<QGraphicsItem *> labels = m_labels.childItems();
+                QList<QGraphicsItem *> shades = m_shades.childItems();
+                QList<QGraphicsItem *> axis = m_axis.childItems();
-                foreach(QGraphicsItem* item , m_grid.childItems()) {
-                    delete item;
-                foreach(QGraphicsItem* item , m_labels.childItems()) {
-                    delete item;
-                foreach(QGraphicsItem* item , m_axis.childItems()) {
+                for (int i = 0; i < count; ++i) {
-                        delete item;
+                    delete(lines.takeLast());
+                    delete(labels.takeLast());
+                    if(lines.size()%2) delete(shades.takeLast());
+                    delete(axis.takeLast());
                 }
                 m_thicksList.clear();
             }
             void AxisItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
             {
+                Q_UNUSED(painter);
+                Q_UNUSED(option);
+                Q_UNUSED(widget);
             }
-            void AxisItem::updateItem(int count)
+            void AxisItem::updateItems(QVector<qreal>& vector)
             {
-                if(count ==0) return;
+                calculateLayout(vector);
+                if(vector.count()==0) return;
-                QList<QGraphicsItem *> lines = m_grid.childItems();
+                applyLayout(vector);
-                QList<QGraphicsItem *> labels = m_labels.childItems();
-                QList<QGraphicsItem *> shades = m_shades.childItems();
-                QList<QGraphicsItem *> axis = m_axis.childItems();
-                switch (m_type)
-                      case X_AXIS:
-                          const qreal deltaX = m_rect.width() / (count-1);
-                          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 < count; ++i) {
-                              int x = i * deltaX + m_rect.left();
-                              QGraphicsLineItem *lineItem =  static_cast<QGraphicsLineItem*>(lines.at(i));
-                              lineItem->setLine(x, m_rect.top(), x, m_rect.bottom());
-                              QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem*>(labels.at(i));
-                              labelItem->setText(m_thicksList.at(i));
-                              QPointF center = labelItem->boundingRect().center();
-                              labelItem->setTransformOriginPoint(center.x(), center.y());
-                              labelItem->setPos(x - center.x(), m_rect.bottom() + label_padding);
-                              if(i%2){
-                                  QGraphicsRectItem *rectItem =  static_cast<QGraphicsRectItem*>(shades.at(i/2));
-                                  rectItem->setRect(x,m_rect.top(),deltaX,m_rect.height());
-                              lineItem =  static_cast<QGraphicsLineItem*>(axis.at(i+1));
-                              lineItem->setLine(x,m_rect.bottom(),x,m_rect.bottom()+5);
-                      break;
-                      case Y_AXIS:
-                          const qreal deltaY = m_rect.height()/ (count-1);
-                          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 < count; ++i) {
-                              int y = i * -deltaY + m_rect.bottom();
-                              QGraphicsLineItem *lineItem =  static_cast<QGraphicsLineItem*>(lines.at(i));
-                              lineItem->setLine(m_rect.left() , y, m_rect.right(), y);
-                              QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem*>(labels.at(i));
-                              labelItem->setText(m_thicksList.at(i));
-                              QPointF center = labelItem->boundingRect().center();
-                              labelItem->setTransformOriginPoint(center.x(), center.y());
-                              labelItem->setPos(m_rect.left() -  labelItem->boundingRect().width() - label_padding , y-center.y());
-                              if(i%2){
-                                  QGraphicsRectItem *rectItem =  static_cast<QGraphicsRectItem*>(shades.at(i/2));
-                                  rectItem->setRect(m_rect.left(),y,m_rect.width(),deltaY);
-                              lineItem =  static_cast<QGraphicsLineItem*>(axis.at(i+1));
-                              lineItem->setLine(m_rect.left()-5,y,m_rect.left(),y);
-                      break;
-                      default:
-                      qDebug()<<"Unknown axis type";
-                      break;
             }
             void AxisItem::handleAxisUpdate(QChartAxis* axis)
             {
                 if(axis->isAxisVisible()) {
                     setAxisOpacity(100);
                 }
                 else {
                     setAxisOpacity(0);
                 }
                 if(axis->isGridVisible()) {
                     setGridOpacity(100);
                 }
                 else {
                     setGridOpacity(0);
                 }
                 if(axis->isLabelsVisible())
                 {
                     setLabelsOpacity(100);
                 }
                 else {
                     setLabelsOpacity(0);
                 }
                 if(axis->isShadesVisible()) {
                     setShadesOpacity(axis->shadesOpacity());
                 }
                 else {
                     setShadesOpacity(0);
                 }
                 setLabelsAngle(axis->labelsAngle());
                 setAxisPen(axis->axisPen());
                 setLabelsPen(axis->labelsPen());
                 setLabelsBrush(axis->labelsBrush());
                 setLabelsFont(axis->labelFont());
                 setGridPen(axis->gridPen());
                 setShadesPen(axis->shadesPen());
                 setShadesBrush(axis->shadesBrush());
             }
             void AxisItem::handleLabelsChanged(QChartAxis* axis,const QStringList& labels)
             {
-                m_thicksList=labels;
+                int diff = m_thicksList.size() - labels.size();
-                QList<QGraphicsItem*> items = m_labels.childItems();
-                //if(items.size()!=m_thicksList.size()){
+                if(diff>0){
-                   clear();
+                    clear(diff);
-                   m_thicksList=labels;
+                }else if(diff<0){
-                   createItems(m_thicksList.size());
+                    createItems(-diff);
-                   updateItem(m_thicksList.size());
-                   items = m_labels.childItems();
-                   handleAxisUpdate(axis);
-                // }
-                Q_ASSERT(items.size()==m_thicksList.size());
-                int i=0;
-                foreach(QGraphicsItem* item, items){
-                    static_cast<QGraphicsSimpleTextItem*>(item)->setText(m_thicksList.at(i));
-                    i++;
                 }
-                update();
+                m_thicksList=labels;
+                m_layoutVector.resize(m_thicksList.size());
+                updateItems(m_layoutVector);
+                handleAxisUpdate(axis);
             }
             void AxisItem::handleGeometryChanged(const QRectF& rect)
             {
                 m_rect = rect;
-                updateItem(m_thicksList.size());
+                updateItems(m_layoutVector);
-                update();
             }
             void AxisItem::setAxisOpacity(qreal opacity)
             {
                 m_axis.setOpacity(opacity);
             }
             qreal AxisItem::axisOpacity() const
             {
                 return m_axis.opacity();
             }
             void AxisItem::setGridOpacity(qreal opacity)
             {
                 m_grid.setOpacity(opacity);
             }
             qreal AxisItem::gridOpacity() const
             {
                 return m_grid.opacity();
             }
             void AxisItem::setLabelsOpacity(qreal opacity)
             {
                 m_labels.setOpacity(opacity);
             }
             qreal AxisItem::labelsOpacity() const
             {
                 return m_labels.opacity();
             }
             void AxisItem::setShadesOpacity(qreal opacity)
             {
                 m_shades.setOpacity(opacity);
             }
             qreal AxisItem::shadesOpacity() const
             {
                 return m_shades.opacity();
             }
             void AxisItem::setLabelsAngle(int angle)
             {
                 foreach(QGraphicsItem* item , m_labels.childItems()) {
                       QPointF center = item->boundingRect().center();
                       item->setRotation(angle);
                 }
                 m_labelsAngle=angle;
             }
             void AxisItem::setLabelsPen(const QPen& pen)
             {
                 foreach(QGraphicsItem* item , m_labels.childItems()) {
                     static_cast<QGraphicsSimpleTextItem*>(item)->setPen(pen);
                 }
             }
             void AxisItem::setLabelsBrush(const QBrush& brush)
             {
                 foreach(QGraphicsItem* item , m_labels.childItems()) {
                     static_cast<QGraphicsSimpleTextItem*>(item)->setBrush(brush);
                 }
             }
             void AxisItem::setLabelsFont(const QFont& font)
             {
                 foreach(QGraphicsItem* item , m_labels.childItems()) {
                     static_cast<QGraphicsSimpleTextItem*>(item)->setFont(font);
                 }
             }
             void AxisItem::setShadesBrush(const QBrush& brush)
             {
                 foreach(QGraphicsItem* item , m_shades.childItems()) {
                     static_cast<QGraphicsRectItem*>(item)->setBrush(brush);
                 }
             }
             void AxisItem::setShadesPen(const QPen& pen)
             {
                 foreach(QGraphicsItem* item , m_shades.childItems()) {
                     static_cast<QGraphicsRectItem*>(item)->setPen(pen);
                 }
             }
             void AxisItem::setAxisPen(const QPen& pen)
             {
                 foreach(QGraphicsItem* item , m_axis.childItems()) {
                        static_cast<QGraphicsLineItem*>(item)->setPen(pen);
                 }
             }
             void AxisItem::setGridPen(const QPen& pen)
             {
                 foreach(QGraphicsItem* item , m_grid.childItems()) {
                     static_cast<QGraphicsLineItem*>(item)->setPen(pen);
                 }
             }
+            void AxisItem::calculateLayout(QVector<qreal>& points)
+            {
+                switch (m_type)
+                {
+                    case X_AXIS:
+                    {
+                        const qreal deltaX = m_rect.width()/(m_thicksList.size()-1);
+                        for (int i = 0; i < m_thicksList.size(); ++i) {
+                             int x = i * deltaX + m_rect.left();
+                             points[i]=x;
+                        }
+                    }
+                    break;
+                    case Y_AXIS:
+                    {
+                        const qreal deltaY = m_rect.height()/(m_thicksList.size()-1);
+                        for (int i = 0; i < m_thicksList.size(); ++i) {
+                             int y = i * -deltaY + m_rect.bottom();
+                             points[i]=y;
+                        }
+                    }
+                    break;
+                }
+            }
+            void AxisItem::applyLayout(const QVector<qreal>& points)
+            {
+                Q_ASSERT(points.size() == m_thicksList.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() == m_thicksList.size());
+                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 < points.size(); ++i) {
+                                 QGraphicsLineItem *lineItem =  static_cast<QGraphicsLineItem*>(lines.at(i));
+                                 lineItem->setLine(points[i], m_rect.top(), points[i], m_rect.bottom());
+                                 QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem*>(labels.at(i));
+                                 labelItem->setText(m_thicksList.at(i));
+                                 QPointF center = labelItem->boundingRect().center();
+                                 labelItem->setTransformOriginPoint(center.x(), center.y());
+                                 labelItem->setPos(points[i] - center.x(), m_rect.bottom() + label_padding);
+                                 if(i%2){
+                                     QGraphicsRectItem *rectItem =  static_cast<QGraphicsRectItem*>(shades.at(i/2));
+                                     rectItem->setRect(points[i],m_rect.top(),points[i+1]-points[i],m_rect.height());
+                                 }
+                                 lineItem =  static_cast<QGraphicsLineItem*>(axis.at(i+1));
+                                 lineItem->setLine(points[i],m_rect.bottom(),points[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 < points.size(); ++i) {
+                                 QGraphicsLineItem *lineItem =  static_cast<QGraphicsLineItem*>(lines.at(i));
+                                 lineItem->setLine(m_rect.left() , points[i], m_rect.right(), points[i]);
+                                 QGraphicsSimpleTextItem *labelItem = static_cast<QGraphicsSimpleTextItem*>(labels.at(i));
+                                 labelItem->setText(m_thicksList.at(i));
+                                 QPointF center = labelItem->boundingRect().center();
+                                 labelItem->setTransformOriginPoint(center.x(), center.y());
+                                 labelItem->setPos(m_rect.left() -  labelItem->boundingRect().width() - label_padding , points[i]-center.y());
+                                 if(i%2){
+                                     QGraphicsRectItem *rectItem =  static_cast<QGraphicsRectItem*>(shades.at(i/2));
+                                     rectItem->setRect(m_rect.left(),points[i],m_rect.width(),points[i]-points[i+1]);
+                                 }
+                                 lineItem =  static_cast<QGraphicsLineItem*>(axis.at(i+1));
+                                 lineItem->setLine(m_rect.left()-5,points[i],m_rect.left(),points[i]);
+                             }
+                         }
+                         break;
+                         default:
+                         qDebug()<<"Unknown axis type";
+                         break;
+                     }
+            }
             //TODO "nice numbers algorithm"
             #include "moc_axisitem_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/axisitem_p.h +6 -3

             #ifndef AXISITEM_H_
             #define AXISITEM_H_
             #include "domain_p.h"
             #include "chartitem_p.h"
             #include <QGraphicsItem>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QChartAxis;
             class AxisItem : public QObject, public ChartItem
             {
                 Q_OBJECT
             public:
                 enum AxisType{X_AXIS,Y_AXIS};
                 AxisItem(AxisType type = X_AXIS,QGraphicsItem* parent = 0);
                 ~AxisItem();
                 //from QGraphicsItem
                 QRectF boundingRect() const;
                 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget);
                 AxisType axisType() const {return m_type;};
                 void setAxisOpacity(qreal opacity);
                 qreal axisOpacity() const;
                 void setGridOpacity(qreal opacity);
                 qreal gridOpacity() const;
                 void setLabelsOpacity(qreal opacity);
                 qreal labelsOpacity() const;
                 void setShadesOpacity(qreal opacity);
                 qreal shadesOpacity() const;
                 void setLabelsAngle(int angle);
                 int labelsAngle()const { return m_labelsAngle; }
                 void setShadesBrush(const QBrush& brush);
                 void setShadesPen(const QPen& pen);
                 void setAxisPen(const QPen& pen);
                 void setGridPen(const QPen& pen);
                 void setLabelsPen(const QPen& pen);
                 void setLabelsBrush(const QBrush& brush);
                 void setLabelsFont(const QFont& font);
             public slots:
                 void handleAxisUpdate(QChartAxis* axis); //look and feel
                 void handleLabelsChanged(QChartAxis* axis,const QStringList& labels); //labels from dataset
                 void handleGeometryChanged(const QRectF& size); // geometry from presenter
-            protected:
+            public:
-                void updateItem(int count);
+                virtual void updateItems(QVector<qreal>& points);
+                virtual void calculateLayout(QVector<qreal>& points);
+                virtual void applyLayout(const QVector<qreal>& points);
             private:
-                void clear();
+                void clear(int count);
                 void createItems(int count);
             private:
                 AxisType m_type;
                 QRectF m_rect;
                 int m_labelsAngle;
                 QGraphicsItemGroup m_grid;
                 QGraphicsItemGroup m_shades;
                 QGraphicsItemGroup m_labels;
                 QGraphicsItemGroup m_axis;
                 QStringList m_thicksList;
+                QVector<qreal> m_layoutVector;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif /* AXISITEM_H_ */

src/src.pro +2 0

             !include( ../common.pri ):error( Couldn't find the common.pri file! )
             TARGET = QtCommercialChart
             DESTDIR = $$CHART_BUILD_LIB_DIR
             TEMPLATE = lib
             QT += core \
                 gui
             CONFIG += debug_and_release
             CONFIG(debug, debug|release):TARGET = QtCommercialChartd
             SOURCES += \
                 axisitem.cpp \
+                axisanimationitem.cpp \
                 chartdataset.cpp \
                 chartpresenter.cpp \
                 charttheme.cpp \
                 domain.cpp \
                 qchart.cpp \
                 qchartaxis.cpp \
                 qchartseries.cpp \
                 qchartview.cpp
             PRIVATE_HEADERS += \
                 axisitem_p.h \
+                axisanimationitem_p.h \
                 chartdataset_p.h \
                 chartitem_p.h \
                 chartpresenter_p.h \
                 charttheme_p.h \
                 domain_p.h
             PUBLIC_HEADERS += \
                 qchart.h \
                 qchartaxis.h \
                 qchartglobal.h \
                 qchartseries.h \
                 qchartview.h \
             include(linechart/linechart.pri)
             include(barchart/barchart.pri)
             include(piechart/piechart.pri)
             include(scatterseries/scatter.pri)
             THEMES += themes/chartthemeicy_p.h \
                 themes/chartthemegrayscale_p.h \
                 themes/chartthemescientific_p.h \
                 themes/chartthemevanilla_p.h
             HEADERS += $$PUBLIC_HEADERS
             HEADERS += $$PRIVATE_HEADERS
             HEADERS += $$THEMES
             INCLUDEPATH += linechart \
                 barchart \
                 themes \
                 .
             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
             public_headers.path = $$[QT_INSTALL_HEADERS]/QtCommercialChart
             public_headers.files = $$PUBLIC_HEADERS
             target.path = $$[QT_INSTALL_LIBS]
             INSTALLS += target \
                 public_headers
             install_build_public_headers.name = bild_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 = bild_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
             chartversion.target = qchartversion_p.h
             chartversion.commands = @echo \
                 "build_time" \
                 > \
                 $$chartversion.target;
             chartversion.depends = $$HEADERS \
                 $$SOURCES
             PRE_TARGETDEPS += qchartversion_p.h
             QMAKE_CLEAN += 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

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