HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/qtcharts Commit - r2274:2d2a1c8b0f36

QLogValueAxis added. Log domain missing

Marek Rosa -

r2274:2d2a1c8b0f36

parent child

Context file:

r2274:2d2a1c8b0f36

Collapse all files

src/axis/logvalueaxis/chartlogvalueaxisx.cpp created 644 +122 0

@@ -0,0 +1,122
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2012 Digia Plc
	4	** All rights reserved.
	5	** For any questions to Digia, please use contact form at http://qt.digia.com
	6	**
	7	** This file is part of the Qt Commercial Charts Add-on.
	8	**
	9	** $QT_BEGIN_LICENSE$
	10	** Licensees holding valid Qt Commercial licenses may use this file in
	11	** accordance with the Qt Commercial License Agreement provided with the
	12	** Software or, alternatively, in accordance with the terms contained in
	13	** a written agreement between you and Digia.
	14	**
	15	** If you have questions regarding the use of this file, please use
	16	** contact form at http://qt.digia.com
	17	** $QT_END_LICENSE$
	18	**
	19	****************************************************************************/
	20
	21	#include "chartlogvalueaxisx_p.h"
	22	#include "chartpresenter_p.h"
	23	#include "qlogvalueaxis.h"
	24	#include "chartlayout_p.h"
	25	#include <QGraphicsLayout>
	26	#include <QFontMetrics>
	27	#include <qmath.h>
	28
	29	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	30
	31	ChartLogValueAxisX::ChartLogValueAxisX(QLogValueAxis axis, QGraphicsItem item)
	32	: HorizontalAxis(axis, item),
	33	m_axis(axis)
	34	{
	35	}
	36
	37	ChartLogValueAxisX::~ChartLogValueAxisX()
	38	{
	39	}
	40
	41	QVector<qreal> ChartLogValueAxisX::calculateLayout() const
	42	{
	43	QVector<qreal> points;
	44
	45	qreal logMax = log10(m_axis->max()) / log10(m_axis->base());
	46	qreal logMin = log10(m_axis->min()) / log10(m_axis->base());
	47	int tickCount = qAbs(qRound(logMax - logMin));
	48
	49	points.resize(tickCount);
	50	const QRectF &gridRect = gridGeometry();
	51	const qreal deltaX = gridRect.width() / qAbs(logMax - logMin);
	52	for (int i = 0; i < tickCount; ++i)
	53	if (logMax > logMin)
	54	points[i] = ((int)logMin + i) * deltaX - logMin * deltaX + gridRect.left();
	55	else
	56	points[i] = ((int)logMax + i) * deltaX - logMax * deltaX + gridRect.left();
	57
	58	return points;
	59	}
	60
	61	void ChartLogValueAxisX::updateGeometry()
	62	{
	63	const QVector<qreal>& layout = ChartAxis::layout();
	64	if (layout.isEmpty())
	65	return;
	66	setLabels(createLogValueLabels(m_axis->min(), m_axis->max(), m_axis->base(), layout.size(), m_axis->labelFormat()));
	67	HorizontalAxis::updateGeometry();
	68	}
	69
	70	//void ChartLogValueAxisX::handleAxisUpdated()
	71	//{
	72	// ChartAxis::handleAxisUpdated();
	73	//}
	74
	75	QSizeF ChartLogValueAxisX::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const
	76	{
	77	Q_UNUSED(constraint)
	78
	79	QFontMetrics fn(font());
	80	QSizeF sh;
	81
	82	QSizeF base = HorizontalAxis::sizeHint(which, constraint);
	83	QStringList ticksList;
	84	qreal logMax = log10(m_axis->max()) / log10(m_axis->base());
	85	qreal logMin = log10(m_axis->min()) / log10(m_axis->base());
	86	int tickCount = qAbs(qRound(logMax - logMin));
	87
	88	if (m_axis->max() > m_axis->min() && tickCount > 1)
	89	ticksList = createLogValueLabels(m_axis->min(), m_axis->max(), m_axis->base(), tickCount, m_axis->labelFormat());
	90	else
	91	ticksList.append(QString(" "));
	92	qreal width = 0;
	93	qreal height = 0;
	94
	95
	96	switch (which) {
	97	case Qt::MinimumSize:{
	98	int count = qMax(ticksList.last().count(),ticksList.first().count());
	99	width = fn.averageCharWidth() * count;
	100	height = fn.height() + labelPadding();
	101	width = qMax(width,base.width());
	102	height += base.height();
	103	sh = QSizeF(width,height);
	104	break;
	105	}
	106	case Qt::PreferredSize: {
	107	int count = qMax(ticksList.last().count(),ticksList.first().count());
	108	width=fn.averageCharWidth() * count;
	109	height=fn.height()+labelPadding();
	110	width=qMax(width,base.width());
	111	height+=base.height();
	112	sh = QSizeF(width,height);
	113	break;
	114	}
	115	default:
	116	break;
	117	}
	118
	119	return sh;
	120	}
	121
	122	QTCOMMERCIALCHART_END_NAMESPACE

src/axis/logvalueaxis/chartlogvalueaxisx_p.h created 644 +59 0

@@ -0,0 +1,59
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2012 Digia Plc
	4	** All rights reserved.
	5	** For any questions to Digia, please use contact form at http://qt.digia.com
	6	**
	7	** This file is part of the Qt Commercial Charts Add-on.
	8	**
	9	** $QT_BEGIN_LICENSE$
	10	** Licensees holding valid Qt Commercial licenses may use this file in
	11	** accordance with the Qt Commercial License Agreement provided with the
	12	** Software or, alternatively, in accordance with the terms contained in
	13	** a written agreement between you and Digia.
	14	**
	15	** If you have questions regarding the use of this file, please use
	16	** contact form at http://qt.digia.com
	17	** $QT_END_LICENSE$
	18	**
	19	****************************************************************************/
	20
	21	// W A R N I N G
	22	// -------------
	23	//
	24	// This file is not part of the QtCommercial Chart API. It exists purely as an
	25	// implementation detail. This header file may change from version to
	26	// version without notice, or even be removed.
	27	//
	28	// We mean it.
	29
	30	#ifndef CHARTLOGVALUEAXISX_H
	31	#define CHARTLOGVALUEAXISX_H
	32
	33	#include "horizontalaxis_p.h"
	34
	35	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	36
	37	class QLogValueAxis;
	38	class ChartPresenter;
	39
	40	class ChartLogValueAxisX : public HorizontalAxis
	41	{
	42	public:
	43	ChartLogValueAxisX(QLogValueAxis axis, QGraphicsItem item);
	44	~ChartLogValueAxisX();
	45
	46	QSizeF sizeHint(Qt::SizeHint which, const QSizeF &constraint) const;
	47
	48	protected:
	49	void handleAxisUpdated();
	50	QVector<qreal> calculateLayout() const;
	51	void updateGeometry();
	52
	53	private:
	54	QLogValueAxis *m_axis;
	55	};
	56
	57	QTCOMMERCIALCHART_END_NAMESPACE
	58
	59	#endif /* CHARTLOGVALUEAXISX_H */

src/axis/logvalueaxis/chartlogvalueaxisy.cpp created 644 +119 0

@@ -0,0 +1,119
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2012 Digia Plc
	4	** All rights reserved.
	5	** For any questions to Digia, please use contact form at http://qt.digia.com
	6	**
	7	** This file is part of the Qt Commercial Charts Add-on.
	8	**
	9	** $QT_BEGIN_LICENSE$
	10	** Licensees holding valid Qt Commercial licenses may use this file in
	11	** accordance with the Qt Commercial License Agreement provided with the
	12	** Software or, alternatively, in accordance with the terms contained in
	13	** a written agreement between you and Digia.
	14	**
	15	** If you have questions regarding the use of this file, please use
	16	** contact form at http://qt.digia.com
	17	** $QT_END_LICENSE$
	18	**
	19	****************************************************************************/
	20
	21	#include "chartlogvalueaxisy_p.h"
	22	#include "chartpresenter_p.h"
	23	#include "qlogvalueaxis.h"
	24	#include "chartlayout_p.h"
	25	#include <QGraphicsLayout>
	26	#include <QFontMetrics>
	27	#include <qmath.h>
	28
	29	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	30
	31	ChartLogValueAxisY::ChartLogValueAxisY(QLogValueAxis axis, QGraphicsItem item)
	32	: VerticalAxis(axis, item),
	33	m_axis(axis)
	34	{
	35	}
	36
	37	ChartLogValueAxisY::~ChartLogValueAxisY()
	38	{
	39	}
	40
	41	QVector<qreal> ChartLogValueAxisY::calculateLayout() const
	42	{
	43	QVector<qreal> points;
	44	qreal logMax = log10(m_axis->max()) / log10(m_axis->base());
	45	qreal logMin = log10(m_axis->min()) / log10(m_axis->base());
	46	int tickCount = qAbs(qRound(logMax - logMin));
	47
	48	points.resize(tickCount);
	49	const QRectF &gridRect = gridGeometry();
	50	const qreal deltaY = gridRect.height() / qAbs(logMax - logMin);
	51	for (int i = 0; i < tickCount; ++i)
	52	if (logMax > logMin)
	53	points[i] = ((int)logMin + i) * -deltaY - logMin * -deltaY + gridRect.bottom();
	54	else
	55	points[i] = ((int)logMax + i) * -deltaY - logMax * -deltaY + gridRect.bottom();
	56
	57	return points;
	58	}
	59
	60
	61	void ChartLogValueAxisY::updateGeometry()
	62	{
	63	const QVector<qreal> &layout = ChartAxis::layout();
	64	if (layout.isEmpty())
	65	return;
	66	setLabels(createLogValueLabels(m_axis->min(), m_axis->max(), m_axis->base(), layout.size(), m_axis->labelFormat()));
	67	VerticalAxis::updateGeometry();
	68	}
	69
	70	//void ChartLogValueAxisY::handleAxisUpdated()
	71	//{
	72	// ChartAxis::handleAxisUpdated();
	73	//}
	74
	75	QSizeF ChartLogValueAxisY::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const
	76	{
	77	Q_UNUSED(constraint)
	78
	79	QFontMetrics fn(font());
	80	QSizeF sh;
	81
	82	QSizeF base = VerticalAxis::sizeHint(which, constraint);
	83	QStringList ticksList;
	84	qreal logMax = log10(m_axis->max()) / log10(m_axis->base());
	85	qreal logMin = log10(m_axis->min()) / log10(m_axis->base());
	86	int tickCount = qAbs(qRound(logMax - logMin));
	87	if (m_axis->max() > m_axis->min() && tickCount > 1)
	88	ticksList = createLogValueLabels(m_axis->min(), m_axis->max(), m_axis->base(), tickCount, m_axis->labelFormat());
	89	else
	90	ticksList.append(QString(" "));
	91	qreal width = 0;
	92	qreal height = 0;
	93
	94	switch (which) {
	95	case Qt::MinimumSize: {
	96	width = fn.boundingRect("...").width() + labelPadding();
	97	width += base.width();
	98	height = fn.height();
	99	height = qMax(height,base.height());
	100	sh = QSizeF(width,height);
	101	break;
	102	}
	103	case Qt::PreferredSize: {
	104	int count = qMax(ticksList.first().count() , ticksList.last().count());
	105	width = count*fn.averageCharWidth() + labelPadding() + 2; //two pixels of tolerance
	106	width += base.width();
	107	height = fn.height() * ticksList.count();
	108	height = qMax(height,base.height());
	109	sh = QSizeF(width,height);
	110	break;
	111	}
	112	default:
	113	break;
	114	}
	115
	116	return sh;
	117	}
	118
	119	QTCOMMERCIALCHART_END_NAMESPACE

src/axis/logvalueaxis/chartlogvalueaxisy_p.h created 644 +59 0

@@ -0,0 +1,59
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2012 Digia Plc
	4	** All rights reserved.
	5	** For any questions to Digia, please use contact form at http://qt.digia.com
	6	**
	7	** This file is part of the Qt Commercial Charts Add-on.
	8	**
	9	** $QT_BEGIN_LICENSE$
	10	** Licensees holding valid Qt Commercial licenses may use this file in
	11	** accordance with the Qt Commercial License Agreement provided with the
	12	** Software or, alternatively, in accordance with the terms contained in
	13	** a written agreement between you and Digia.
	14	**
	15	** If you have questions regarding the use of this file, please use
	16	** contact form at http://qt.digia.com
	17	** $QT_END_LICENSE$
	18	**
	19	****************************************************************************/
	20
	21	// W A R N I N G
	22	// -------------
	23	//
	24	// This file is not part of the QtCommercial Chart API. It exists purely as an
	25	// implementation detail. This header file may change from version to
	26	// version without notice, or even be removed.
	27	//
	28	// We mean it.
	29
	30	#ifndef CHARTLOGVALUEAXISY_H
	31	#define CHARTLOGVALUEAXISY_H
	32
	33	#include "verticalaxis_p.h"
	34
	35	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	36
	37	class QLogValueAxis;
	38	class ChartPresenter;
	39
	40	class ChartLogValueAxisY : public VerticalAxis
	41	{
	42	public:
	43	ChartLogValueAxisY(QLogValueAxis axis, QGraphicsItem item);
	44	~ChartLogValueAxisY();
	45
	46	QSizeF sizeHint(Qt::SizeHint which, const QSizeF &constraint) const;
	47
	48	protected:
	49	void handleAxisUpdated();
	50	QVector<qreal> calculateLayout() const;
	51	void updateGeometry();
	52
	53	private:
	54	QLogValueAxis *m_axis;
	55	};
	56
	57	QTCOMMERCIALCHART_END_NAMESPACE
	58
	59	#endif /* CHARTLOGVALUEAXISY_H */

src/axis/logvalueaxis/qlogvalueaxis.cpp created 644 +315 0

@@ -0,0 +1,315
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2012 Digia Plc
	4	** All rights reserved.
	5	** For any questions to Digia, please use contact form at http://qt.digia.com
	6	**
	7	** This file is part of the Qt Commercial Charts Add-on.
	8	**
	9	** $QT_BEGIN_LICENSE$
	10	** Licensees holding valid Qt Commercial licenses may use this file in
	11	** accordance with the Qt Commercial License Agreement provided with the
	12	** Software or, alternatively, in accordance with the terms contained in
	13	** a written agreement between you and Digia.
	14	**
	15	** If you have questions regarding the use of this file, please use
	16	** contact form at http://qt.digia.com
	17	** $QT_END_LICENSE$
	18	**
	19	****************************************************************************/
	20
	21	#include "qlogvalueaxis.h"
	22	#include "qlogvalueaxis_p.h"
	23	#include "chartlogvalueaxisx_p.h"
	24	#include "chartlogvalueaxisy_p.h"
	25	#include "domain_p.h"
	26	#include <float.h>
	27	#include <cmath>
	28
	29	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	30	/*!
	31	\class QLogValueAxis
	32	\brief The QLogValueAxis class is used for manipulating chart's axis.
	33	\mainclass
	34	*/
	35
	36	/*!
	37	\qmlclass DateTimeAxis QLogValueAxis
	38	\brief The DateTimeAxis element is used for manipulating chart's axes
	39	\inherits AbstractAxis
	40	*/
	41
	42	/*!
	43	\property QLogValueAxis::min
	44	Defines the minimum value on the axis.
	45	When setting this property the max is adjusted if necessary, to ensure that the range remains valid.
	46	*/
	47	/*!
	48	\qmlproperty real ValuesAxis::min
	49	Defines the minimum value on the axis.
	50	When setting this property the max is adjusted if necessary, to ensure that the range remains valid.
	51	*/
	52
	53	/*!
	54	\property QLogValueAxis::max
	55	Defines the maximum value on the axis.
	56	When setting this property the min is adjusted if necessary, to ensure that the range remains valid.
	57	*/
	58	/*!
	59	\qmlproperty real ValuesAxis::max
	60	Defines the maximum value on the axis.
	61	When setting this property the min is adjusted if necessary, to ensure that the range remains valid.
	62	*/
	63
	64	/*!
	65	\fn void QLogValueAxis::minChanged(qreal min)
	66	Axis emits signal when \a min of axis has changed.
	67	*/
	68	/*!
	69	\qmlsignal ValuesAxis::onMinChanged(qreal min)
	70	Axis emits signal when \a min of axis has changed.
	71	*/
	72
	73	/*!
	74	\fn void QLogValueAxis::maxChanged(qreal max)
	75	Axis emits signal when \a max of axis has changed.
	76	*/
	77	/*!
	78	\qmlsignal ValuesAxis::onMaxChanged(qreal max)
	79	Axis emits signal when \a max of axis has changed.
	80	*/
	81
	82	/*!
	83	\fn void QLogValueAxis::rangeChanged(qreal min, qreal max)
	84	Axis emits signal when \a min or \a max of axis has changed.
	85	*/
	86
	87	/*!
	88	Constructs an axis object which is a child of \a parent.
	89	*/
	90	QLogValueAxis::QLogValueAxis(QObject *parent) :
	91	QAbstractAxis(*new QLogValueAxisPrivate(this), parent)
	92	{
	93
	94	}
	95
	96	/*!
	97	\internal
	98	*/
	99	QLogValueAxis::QLogValueAxis(QLogValueAxisPrivate &d, QObject *parent) : QAbstractAxis(d, parent)
	100	{
	101
	102	}
	103
	104	/*!
	105	Destroys the object
	106	*/
	107	QLogValueAxis::~QLogValueAxis()
	108	{
	109
	110	}
	111
	112	void QLogValueAxis::setMin(qreal min)
	113	{
	114	Q_D(QLogValueAxis);
	115	setRange(min, qMax(d->m_max, min));
	116	}
	117
	118	qreal QLogValueAxis::min() const
	119	{
	120	Q_D(const QLogValueAxis);
	121	return d->m_min;
	122	}
	123
	124	void QLogValueAxis::setMax(qreal max)
	125	{
	126	Q_D(QLogValueAxis);
	127	setRange(qMin(d->m_min, max), max);
	128	}
	129
	130	qreal QLogValueAxis::max() const
	131	{
	132	Q_D(const QLogValueAxis);
	133	return d->m_max;
	134	}
	135
	136	/*!
	137	Sets range from \a min to \a max on the axis.
	138	If min is greater than max then this function returns without making any changes.
	139	*/
	140	void QLogValueAxis::setRange(qreal min, qreal max)
	141	{
	142	Q_D(QLogValueAxis);
	143	bool changed = false;
	144
	145	if (min > max)
	146	return;
	147
	148	if (min > 0) {
	149	if (!qFuzzyCompare(d->m_min, min)) {
	150	d->m_min = min;
	151	changed = true;
	152	emit minChanged(min);
	153	}
	154
	155	if (!qFuzzyCompare(d->m_max, max)) {
	156	d->m_max = max;
	157	changed = true;
	158	emit maxChanged(max);
	159	}
	160
	161	if (changed) {
	162	emit rangeChanged(min, max);
	163	emit d->rangeChanged(min,max);
	164	}
	165	}
	166	}
	167
	168	void QLogValueAxis::setLabelFormat(const QString &format)
	169	{
	170	Q_D(QLogValueAxis);
	171	d->m_format = format;
	172	}
	173
	174	QString QLogValueAxis::labelFormat() const
	175	{
	176	Q_D(const QLogValueAxis);
	177	return d->m_format;
	178	}
	179
	180	void QLogValueAxis::setBase(qreal base)
	181	{
	182	// check if base is correct
	183	if (base <= 0 \|\| qFuzzyCompare(base, 1))
	184	return;
	185
	186	Q_D(QLogValueAxis);
	187	d->m_base = base;
	188	}
	189
	190	qreal QLogValueAxis::base() const
	191	{
	192	Q_D(const QLogValueAxis);
	193	return d->m_base;
	194	}
	195
	196	/*!
	197	Returns the type of the axis
	198	*/
	199	QAbstractAxis::AxisType QLogValueAxis::type() const
	200	{
	201	return AxisTypeLogValue;
	202	}
	203
	204	/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	205
	206	QLogValueAxisPrivate::QLogValueAxisPrivate(QLogValueAxis *q)
	207	: QAbstractAxisPrivate(q),
	208	m_min(1),
	209	m_max(10),
	210	m_base(10),
	211	m_format(QString::null)
	212	{
	213	}
	214
	215	QLogValueAxisPrivate::~QLogValueAxisPrivate()
	216	{
	217
	218	}
	219
	220	void QLogValueAxisPrivate::setMin(const QVariant &min)
	221	{
	222	Q_Q(QLogValueAxis);
	223	bool ok;
	224	qreal value = min.toReal(&ok);
	225	if (ok)
	226	q->setMin(value);
	227	}
	228
	229	void QLogValueAxisPrivate::setMax(const QVariant &max)
	230	{
	231
	232	Q_Q(QLogValueAxis);
	233	bool ok;
	234	qreal value = max.toReal(&ok);
	235	if (ok)
	236	q->setMax(value);
	237	}
	238
	239	void QLogValueAxisPrivate::setRange(const QVariant &min, const QVariant &max)
	240	{
	241	Q_Q(QLogValueAxis);
	242	bool ok1;
	243	bool ok2;
	244	qreal value1 = min.toReal(&ok1);
	245	qreal value2 = max.toReal(&ok2);
	246	if (ok1 && ok2)
	247	q->setRange(value1, value2);
	248	}
	249
	250	void QLogValueAxisPrivate::setRange(qreal min, qreal max)
	251	{
	252	Q_Q(QLogValueAxis);
	253	bool changed = false;
	254
	255	if (min > max)
	256	return;
	257
	258	if (min > 0) {
	259	if (!qFuzzyCompare(m_min, min)) {
	260	m_min = min;
	261	changed = true;
	262	emit q->minChanged(min);
	263	}
	264
	265	if (!qFuzzyCompare(m_max, max)) {
	266	m_max = max;
	267	changed = true;
	268	emit q->maxChanged(max);
	269	}
	270
	271	if (changed) {
	272	emit q->rangeChanged(min, max);
	273	emit rangeChanged(min,max);
	274	}
	275	}
	276	}
	277
	278	void QLogValueAxisPrivate::initializeGraphics(QGraphicsItem* parent)
	279	{
	280	Q_Q(QLogValueAxis);
	281	ChartAxis* axis(0);
	282	if (orientation() == Qt::Vertical)
	283	axis = new ChartLogValueAxisY(q,parent);
	284	if (orientation() == Qt::Horizontal)
	285	axis = new ChartLogValueAxisX(q,parent);
	286
	287	m_item.reset(axis);
	288	QAbstractAxisPrivate::initializeGraphics(parent);
	289	}
	290
	291
	292	void QLogValueAxisPrivate::initializeDomain(Domain *domain)
	293	{
	294	if (orientation() == Qt::Vertical) {
	295	if(!qFuzzyCompare(m_max, m_min)) {
	296	domain->setRangeY(m_min, m_max);
	297	}
	298	else {
	299	setRange(domain->minY() + 1, domain->maxY());
	300	}
	301	}
	302	if (orientation() == Qt::Horizontal) {
	303	if(!qFuzzyCompare(m_max, m_min)) {
	304	domain->setRangeX(m_min, m_max);
	305	}
	306	else {
	307	setRange(domain->minX() + 1, domain->maxX());
	308	}
	309	}
	310	}
	311
	312	#include "moc_qlogvalueaxis.cpp"
	313	#include "moc_qlogvalueaxis_p.cpp"
	314
	315	QTCOMMERCIALCHART_END_NAMESPACE

src/axis/logvalueaxis/qlogvalueaxis.h created 644 +74 0

@@ -0,0 +1,74
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2012 Digia Plc
	4	** All rights reserved.
	5	** For any questions to Digia, please use contact form at http://qt.digia.com
	6	**
	7	** This file is part of the Qt Commercial Charts Add-on.
	8	**
	9	** $QT_BEGIN_LICENSE$
	10	** Licensees holding valid Qt Commercial licenses may use this file in
	11	** accordance with the Qt Commercial License Agreement provided with the
	12	** Software or, alternatively, in accordance with the terms contained in
	13	** a written agreement between you and Digia.
	14	**
	15	** If you have questions regarding the use of this file, please use
	16	** contact form at http://qt.digia.com
	17	** $QT_END_LICENSE$
	18	**
	19	****************************************************************************/
	20
	21	#ifndef QLOGVALUEAXIS_H
	22	#define QLOGVALUEAXIS_H
	23
	24	#include "qabstractaxis.h"
	25
	26	class QDateTime;
	27
	28	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	29
	30	class QLogValueAxisPrivate;
	31
	32	class QTCOMMERCIALCHART_EXPORT QLogValueAxis : public QAbstractAxis
	33	{
	34	Q_OBJECT
	35	Q_PROPERTY(qreal min READ min WRITE setMin NOTIFY minChanged)
	36	Q_PROPERTY(qreal max READ max WRITE setMax NOTIFY maxChanged)
	37	Q_PROPERTY(QString labelFormat READ labelFormat WRITE setLabelFormat)
	38
	39	public:
	40	explicit QLogValueAxis(QObject *parent = 0);
	41	~QLogValueAxis();
	42
	43	protected:
	44	QLogValueAxis(QLogValueAxisPrivate &d, QObject *parent = 0);
	45
	46	public:
	47	AxisType type() const;
	48
	49	//range handling
	50	void setMin(qreal min);
	51	qreal min() const;
	52	void setMax(qreal max);
	53	qreal max() const;
	54	void setRange(qreal min, qreal max);
	55
	56	void setLabelFormat(const QString &format);
	57	QString labelFormat() const;
	58
	59	void setBase(qreal base);
	60	qreal base() const;
	61
	62	Q_SIGNALS:
	63	void minChanged(qreal min);
	64	void maxChanged(qreal max);
	65	void rangeChanged(qreal min, qreal max);
	66
	67	private:
	68	Q_DECLARE_PRIVATE(QLogValueAxis)
	69	Q_DISABLE_COPY(QLogValueAxis)
	70	};
	71
	72	QTCOMMERCIALCHART_END_NAMESPACE
	73
	74	#endif // QLOGVALUEAXIS_H

src/axis/logvalueaxis/qlogvalueaxis_p.h created 644 +69 0

@@ -0,0 +1,69
	1	/****************************************************************************
	2	**
	3	** Copyright (C) 2012 Digia Plc
	4	** All rights reserved.
	5	** For any questions to Digia, please use contact form at http://qt.digia.com
	6	**
	7	** This file is part of the Qt Commercial Charts Add-on.
	8	**
	9	** $QT_BEGIN_LICENSE$
	10	** Licensees holding valid Qt Commercial licenses may use this file in
	11	** accordance with the Qt Commercial License Agreement provided with the
	12	** Software or, alternatively, in accordance with the terms contained in
	13	** a written agreement between you and Digia.
	14	**
	15	** If you have questions regarding the use of this file, please use
	16	** contact form at http://qt.digia.com
	17	** $QT_END_LICENSE$
	18	**
	19	****************************************************************************/
	20
	21	// W A R N I N G
	22	// -------------
	23	//
	24	// This file is not part of the QtCommercial Chart API. It exists purely as an
	25	// implementation detail. This header file may change from version to
	26	// version without notice, or even be removed.
	27	//
	28	// We mean it.
	29
	30	#ifndef QLOGVALUEAXIS_P_H
	31	#define QLOGVALUEAXIS_P_H
	32
	33	#include "qlogvalueaxis.h"
	34	#include "qabstractaxis_p.h"
	35
	36	QTCOMMERCIALCHART_BEGIN_NAMESPACE
	37
	38	class QLogValueAxisPrivate : public QAbstractAxisPrivate
	39	{
	40	Q_OBJECT
	41	public:
	42	QLogValueAxisPrivate(QLogValueAxis *q);
	43	~QLogValueAxisPrivate();
	44
	45	public:
	46	void initializeGraphics(QGraphicsItem* parent);
	47	void initializeDomain(Domain *domain);
	48
	49	qreal min() { return m_min; }
	50	qreal max() { return m_max; }
	51	void setRange(qreal min,qreal max);
	52
	53	protected:
	54	void setMin(const QVariant &min);
	55	void setMax(const QVariant &max);
	56	void setRange(const QVariant &min, const QVariant &max);
	57	int tickCount() const;
	58
	59	protected:
	60	qreal m_min;
	61	qreal m_max;
	62	qreal m_base;
	63	QString m_format;
	64	Q_DECLARE_PUBLIC(QLogValueAxis)
	65	};
	66
	67	QTCOMMERCIALCHART_END_NAMESPACE
	68
	69	#endif // QLOGVALUEAXIS_P_H

src/axis/axis.pri +15 -5

             #Subdirectiores are defined here, because qt creator doesn't handle nested include(foo.pri) chains very well.
             INCLUDEPATH += $$PWD \
                 $$PWD/valueaxis \
                 $$PWD/barcategoryaxis \
-                $$PWD/categoryaxis
+                $$PWD/categoryaxis \
+                $$PWD/logvalueaxis
             DEPENDPATH += $$PWD \
                 $$PWD/valueaxis \
                 $$PWD/barcategoryaxis \
-                $$PWD/categoryaxis
+                $$PWD/categoryaxis \
+                $$PWD/logvalueaxis
             SOURCES += \
                 $$PWD/chartaxis.cpp \
                 $$PWD/qabstractaxis.cpp \
                 $$PWD/verticalaxis.cpp \
                 $$PWD/horizontalaxis.cpp \
                 $$PWD/valueaxis/chartvalueaxisx.cpp \
                 $$PWD/valueaxis/chartvalueaxisy.cpp \
                 $$PWD/valueaxis/qvalueaxis.cpp \
                 $$PWD/barcategoryaxis/chartbarcategoryaxisx.cpp \
                 $$PWD/barcategoryaxis/chartbarcategoryaxisy.cpp \
                 $$PWD/barcategoryaxis/qbarcategoryaxis.cpp \
                 $$PWD/categoryaxis/chartcategoryaxisx.cpp \
                 $$PWD/categoryaxis/chartcategoryaxisy.cpp \
-                $$PWD/categoryaxis/qcategoryaxis.cpp
+                $$PWD/categoryaxis/qcategoryaxis.cpp \
+                $$PWD/logvalueaxis/chartlogvalueaxisx.cpp \
+                $$PWD/logvalueaxis/chartlogvalueaxisy.cpp \
+                $$PWD/logvalueaxis/qlogvalueaxis.cpp
             PRIVATE_HEADERS += \
                 $$PWD/chartaxis_p.h \
                 $$PWD/qabstractaxis_p.h \
                 $$PWD/verticalaxis_p.h \
                 $$PWD/horizontalaxis_p.h \
                 $$PWD/valueaxis/chartvalueaxisx_p.h \
                 $$PWD/valueaxis/chartvalueaxisy_p.h \
                 $$PWD/valueaxis/qvalueaxis_p.h \
                 $$PWD/barcategoryaxis/chartbarcategoryaxisx_p.h \
                 $$PWD/barcategoryaxis/chartbarcategoryaxisy_p.h \
                 $$PWD/barcategoryaxis/qbarcategoryaxis_p.h \
                 $$PWD/categoryaxis/chartcategoryaxisx_p.h \
                 $$PWD/categoryaxis/chartcategoryaxisy_p.h \
-                $$PWD/categoryaxis/qcategoryaxis_p.h
+                $$PWD/categoryaxis/qcategoryaxis_p.h \
+                $$PWD/logvalueaxis/chartlogvalueaxisx_p.h \
+                $$PWD/logvalueaxis/chartlogvalueaxisy_p.h \
+                $$PWD/logvalueaxis/qlogvalueaxis_p.h
             PUBLIC_HEADERS += \
                 $$PWD/qabstractaxis.h \
                 $$PWD/valueaxis/qvalueaxis.h \
                 $$PWD/barcategoryaxis/qbarcategoryaxis.h \
-                $$PWD/categoryaxis/qcategoryaxis.h
+                $$PWD/categoryaxis/qcategoryaxis.h \
+                $$PWD/logvalueaxis/qlogvalueaxis.h \
             !linux-arm*: {
             INCLUDEPATH += \
                 $$PWD/datetimeaxis
             DEPENDPATH += \
                 $$PWD/datetimeaxis
             SOURCES += \
                 $$PWD/datetimeaxis/chartdatetimeaxisx.cpp \
                 $$PWD/datetimeaxis/chartdatetimeaxisy.cpp \
                 $$PWD/datetimeaxis/qdatetimeaxis.cpp
             PRIVATE_HEADERS += \
                 $$PWD/datetimeaxis/chartdatetimeaxisx_p.h \
                 $$PWD/datetimeaxis/chartdatetimeaxisy_p.h \
                 $$PWD/datetimeaxis/qdatetimeaxis_p.h
             PUBLIC_HEADERS += \
                 $$PWD/datetimeaxis/qdatetimeaxis.h
             }

src/axis/chartaxis.cpp +39 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 "chartaxis_p.h"
             #include "qabstractaxis.h"
             #include "qabstractaxis_p.h"
             #include "chartpresenter_p.h"
             #include "chartlayout_p.h"
             #include "domain_p.h"
             #include <qmath.h>
             #include <QDateTime>
             #include <QValueAxis>
+            #include <QLogValueAxis>
             #include <QGraphicsLayout>
             #include <QFontMetrics>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             ChartAxis::ChartAxis(QAbstractAxis *axis, QGraphicsItem* item , bool intervalAxis)
                 : ChartElement(item),
                   m_axis(axis),
                   m_labelsAngle(0),
                   m_grid(new QGraphicsItemGroup(item)),
                   m_arrow(new QGraphicsItemGroup(item)),
                   m_shades(new QGraphicsItemGroup(item)),
                   m_labels(new QGraphicsItemGroup(item)),
                   m_title(new QGraphicsSimpleTextItem(item)),
                   m_animation(0),
                   m_labelPadding(5),
                   m_intervalAxis(intervalAxis)
             {
                 Q_ASSERT(item);
                 //initial initialization
                 m_arrow->setHandlesChildEvents(false);
                 m_arrow->setZValue(ChartPresenter::AxisZValue);
                 m_arrow->setVisible(m_axis->isLineVisible());
                 m_labels->setZValue(ChartPresenter::AxisZValue);
                 m_labels->setVisible(m_axis->labelsVisible());
                 m_shades->setZValue(ChartPresenter::ShadesZValue);
                 m_shades->setVisible(m_axis->shadesVisible());
                 m_grid->setZValue(ChartPresenter::GridZValue);
                 m_grid->setVisible(m_axis->isGridLineVisible());
                 m_title->setZValue(ChartPresenter::GridZValue);
                 connectSlots();
                 setFlag(QGraphicsItem::ItemHasNoContents,true);
             }
             void ChartAxis::connectSlots()
             {
                 QObject::connect(m_axis,SIGNAL(visibleChanged(bool)),this,SLOT(handleVisibleChanged(bool)));
                 QObject::connect(m_axis,SIGNAL(lineVisibleChanged(bool)),this,SLOT(handleArrowVisibleChanged(bool)));
                 QObject::connect(m_axis,SIGNAL(gridLineVisibleChanged(bool)),this,SLOT(handleGridVisibleChanged(bool)));
                 QObject::connect(m_axis,SIGNAL(labelsVisibleChanged(bool)),this,SLOT(handleLabelsVisibleChanged(bool)));
                 QObject::connect(m_axis,SIGNAL(shadesVisibleChanged(bool)),this,SLOT(handleShadesVisibleChanged(bool)));
                 QObject::connect(m_axis,SIGNAL(labelsAngleChanged(int)),this,SLOT(handleLabelsAngleChanged(int)));
                 QObject::connect(m_axis,SIGNAL(linePenChanged(const QPen&)),this,SLOT(handleArrowPenChanged(const QPen&)));
                 QObject::connect(m_axis,SIGNAL(labelsPenChanged(const QPen&)),this,SLOT(handleLabelsPenChanged(const QPen&)));
                 QObject::connect(m_axis,SIGNAL(labelsBrushChanged(const QBrush&)),this,SLOT(handleLabelsBrushChanged(const QBrush&)));
                 QObject::connect(m_axis,SIGNAL(labelsFontChanged(const QFont&)),this,SLOT(handleLabelsFontChanged(const QFont&)));
                 QObject::connect(m_axis,SIGNAL(gridLinePenChanged(const QPen&)),this,SLOT(handleGridPenChanged(const QPen&)));
                 QObject::connect(m_axis,SIGNAL(shadesPenChanged(const QPen&)),this,SLOT(handleShadesPenChanged(const QPen&)));
                 QObject::connect(m_axis,SIGNAL(shadesBrushChanged(const QBrush&)),this,SLOT(handleShadesBrushChanged(const QBrush&)));
                 QObject::connect(m_axis,SIGNAL(titleTextChanged(const QString&)),this,SLOT(handleTitleTextChanged(const QString&)));
                 QObject::connect(m_axis,SIGNAL(titleFontChanged(const QFont&)),this,SLOT(handleTitleFontChanged(const QFont&)));
                 QObject::connect(m_axis,SIGNAL(titlePenChanged(const QPen&)),this,SLOT(handleTitlePenChanged(const QPen&)));
                 QObject::connect(m_axis,SIGNAL(titleBrushChanged(const QBrush&)),this,SLOT(handleTitleBrushChanged(const QBrush&)));
                 QObject::connect(m_axis->d_ptr.data(),SIGNAL(rangeChanged(qreal,qreal)),this,SLOT(handleRangeChanged(qreal,qreal)));
             }
             ChartAxis::~ChartAxis()
             {
             }
             void ChartAxis::setAnimation(AxisAnimation *animation)
             {
                 m_animation = animation;
             }
             void ChartAxis::setLayout(QVector<qreal> &layout)
             {
                 m_layoutVector = layout;
             }
             void ChartAxis::createItems(int count)
             {
                 if (m_arrow->children().size() == 0){
                     QGraphicsLineItem* arrow = new ArrowItem(this, this);
                     arrow->setPen(m_axis->linePen());
                     m_arrow->addToGroup(arrow);
                 }
                 if (m_intervalAxis && m_grid->children().size() == 0) {
                     for (int i = 0 ; i < 2 ; i  ++){
                     	QGraphicsLineItem* item = new QGraphicsLineItem(this);
                     	item->setPen(m_axis->gridLinePen());
                         m_grid->addToGroup(item);
                     }
                 }
                 for (int i = 0; i < count; ++i) {
                     QGraphicsLineItem* arrow = new QGraphicsLineItem(this);
                     arrow->setPen(m_axis->linePen());
                 	QGraphicsLineItem* grid = new QGraphicsLineItem(this);
                 	grid->setPen(m_axis->gridLinePen());
                 	QGraphicsSimpleTextItem* label = new QGraphicsSimpleTextItem(this);
                 	label->setFont(m_axis->labelsFont());
                 	label->setPen(m_axis->labelsPen());
                 	label->setBrush(m_axis->labelsBrush());
                 	m_arrow->addToGroup(arrow);
                     m_grid->addToGroup(grid);
                     m_labels->addToGroup(label);
                     if ((m_grid->childItems().size()) % 2 && m_grid->childItems().size() > 2){
                     	QGraphicsRectItem* shades = new QGraphicsRectItem(this);
                     	shades->setPen(m_axis->shadesPen());
                      	shades->setBrush(m_axis->shadesBrush());
                         m_shades->addToGroup(shades);
                     }
                 }
             }
             void ChartAxis::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_arrow->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 ChartAxis::updateLayout(QVector<qreal> &layout)
             {
                 int diff = m_layoutVector.size() - layout.size();
                 if (diff > 0)
                     deleteItems(diff);
                 else if (diff < 0)
                     createItems(-diff);
                 if (m_animation) {
                     switch (presenter()->state()) {
                     case ChartPresenter::ZoomInState:
                         m_animation->setAnimationType(AxisAnimation::ZoomInAnimation);
                         m_animation->setAnimationPoint(presenter()->statePoint());
                         break;
                     case ChartPresenter::ZoomOutState:
                         m_animation->setAnimationType(AxisAnimation::ZoomOutAnimation);
                         m_animation->setAnimationPoint(presenter()->statePoint());
                         break;
                     case ChartPresenter::ScrollUpState:
                     case ChartPresenter::ScrollLeftState:
                         m_animation->setAnimationType(AxisAnimation::MoveBackwordAnimation);
                         break;
                     case ChartPresenter::ScrollDownState:
                     case ChartPresenter::ScrollRightState:
                         m_animation->setAnimationType(AxisAnimation::MoveForwardAnimation);
                         break;
                     case ChartPresenter::ShowState:
                         m_animation->setAnimationType(AxisAnimation::DefaultAnimation);
                         break;
                     }
                     m_animation->setValues(m_layoutVector, layout);
                     presenter()->startAnimation(m_animation);
                 } else {
                     setLayout(layout);
                     updateGeometry();
                 }
             }
             void ChartAxis::setLabelPadding(int padding)
             {
                 m_labelPadding = padding;
             }
             bool ChartAxis::isEmpty()
             {
                 return m_axisRect.isEmpty() || m_gridRect.isEmpty() ||  qFuzzyCompare(min(),max());
             }
             void ChartAxis::setGeometry(const QRectF &axis, const QRectF &grid)
             {
                 m_gridRect = grid;
                 m_axisRect = axis;
                 if (isEmpty())
                     return;
                 QVector<qreal> layout = calculateLayout();
                 updateLayout(layout);
             }
             qreal ChartAxis::min() const
             {
             	return m_axis->d_ptr->min();
             }
             qreal ChartAxis::max() const
             {
             	return m_axis->d_ptr->max();
             }
             QFont ChartAxis::font() const
             {
             	return m_axis->labelsFont();
             }
             QFont ChartAxis::titleFont() const
             {
             	return m_axis->titleFont();
             }
             QString ChartAxis::titleText() const
             {
             	return m_axis->titleText();
             }
             void ChartAxis::axisSelected()
             {
             	emit clicked();
             }
             Qt::Orientation ChartAxis::orientation() const
             {
                 return m_axis->orientation();
             }
             Qt::Alignment ChartAxis::alignment() const
             {
                 return m_axis->alignment();
             }
             void ChartAxis::setLabels(const QStringList &labels)
             {
                 m_labelsList = labels;
             }
             QSizeF ChartAxis::sizeHint(Qt::SizeHint which, const QSizeF &constraint) const
             {
                 Q_UNUSED(which);
                 Q_UNUSED(constraint);
                 return QSizeF();
             }
             //handlers
             void ChartAxis::handleArrowVisibleChanged(bool visible)
             {
                 m_arrow->setVisible(visible);
             }
             void ChartAxis::handleGridVisibleChanged(bool visible)
             {
                 m_grid->setVisible(visible);
             }
             void ChartAxis::handleLabelsVisibleChanged(bool visible)
             {
                 m_labels->setVisible(visible);
             }
             void ChartAxis::handleShadesVisibleChanged(bool visible)
             {
                 m_shades->setVisible(visible);
             }
             void ChartAxis::handleLabelsAngleChanged(int angle)
             {
                 foreach (QGraphicsItem *item, m_labels->childItems())
                     item->setRotation(angle);
                 m_labelsAngle = angle;
             }
             void ChartAxis::handleLabelsPenChanged(const QPen &pen)
             {
                 foreach (QGraphicsItem *item , m_labels->childItems())
                     static_cast<QGraphicsSimpleTextItem *>(item)->setPen(pen);
             }
             void ChartAxis::handleLabelsBrushChanged(const QBrush &brush)
             {
                 foreach (QGraphicsItem *item , m_labels->childItems())
                     static_cast<QGraphicsSimpleTextItem *>(item)->setBrush(brush);
             }
             void ChartAxis::handleLabelsFontChanged(const QFont &font)
             {
             	foreach (QGraphicsItem *item , m_labels->childItems())
             	static_cast<QGraphicsSimpleTextItem *>(item)->setFont(font);
             	QGraphicsLayoutItem::updateGeometry();
             	presenter()->layout()->invalidate();
             }
             void ChartAxis::handleShadesBrushChanged(const QBrush &brush)
             {
                 foreach (QGraphicsItem *item , m_shades->childItems())
                     static_cast<QGraphicsRectItem *>(item)->setBrush(brush);
             }
             void ChartAxis::handleShadesPenChanged(const QPen &pen)
             {
                 foreach (QGraphicsItem *item , m_shades->childItems())
                     static_cast<QGraphicsRectItem *>(item)->setPen(pen);
             }
             void ChartAxis::handleArrowPenChanged(const QPen &pen)
             {
                 foreach (QGraphicsItem *item , m_arrow->childItems())
                     static_cast<QGraphicsLineItem *>(item)->setPen(pen);
             }
             void ChartAxis::handleGridPenChanged(const QPen &pen)
             {
                 foreach (QGraphicsItem *item , m_grid->childItems())
                     static_cast<QGraphicsLineItem *>(item)->setPen(pen);
             }
             void ChartAxis::handleTitleTextChanged(const QString &title)
             {
             	Q_UNUSED(title)
             	QGraphicsLayoutItem::updateGeometry();
             	presenter()->layout()->invalidate();
             }
             void ChartAxis::handleTitlePenChanged(const QPen &pen)
             {
                 m_title->setPen(pen);
             }
             void ChartAxis::handleTitleBrushChanged(const QBrush &brush)
             {
                 m_title->setBrush(brush);
             }
             void ChartAxis::handleTitleFontChanged(const QFont &font)
             {
                 if(m_title->font() != font){
                     m_title->setFont(font);
                     QGraphicsLayoutItem::updateGeometry();
                     presenter()->layout()->invalidate();
                 }
             }
             void ChartAxis::handleVisibleChanged(bool visible)
             {
             	setVisible(visible);
             }
             void ChartAxis::handleRangeChanged(qreal min, qreal max)
             {
             	Q_UNUSED(min);
             	Q_UNUSED(max);
             	if (!isEmpty()) {
             		QVector<qreal> layout = calculateLayout();
             		updateLayout(layout);
             		QSizeF before = effectiveSizeHint(Qt::PreferredSize);
             		QSizeF after = sizeHint(Qt::PreferredSize);
             		if (before != after) {
             			QGraphicsLayoutItem::updateGeometry();
             			//we don't want to call invalidate on layout, since it will change minimum size of component,
             			//which we would like to avoid since it causes nasty flips when scrolling or zooming,
             			//instead recalculate layout and use plotArea for extra space.
             			presenter()->layout()->setGeometry(presenter()->layout()->geometry());
             		}
             	}
             }
             //helpers
             QStringList ChartAxis::createValueLabels(qreal min, qreal max, int ticks,const QString& format)
             {
                 //TODO: Q_ASSERT(m_max > m_min);
                 //TODO: Q_ASSERT(ticks > 1);
                 QStringList labels;
                 if(max <= min || ticks < 1){
                     return labels;
                 }
                 int n = qMax(int(-qFloor(log10((max - min) / (ticks - 1)))), 0);
                 n++;
                 if (format.isNull()) {
                     for (int i = 0; i < ticks; i++) {
                         qreal value = min + (i * (max - min) / (ticks - 1));
                         labels << QString::number(value, 'f', n);
                     }
                 } else {
                     QByteArray array = format.toLatin1();
                     for (int i = 0; i < ticks; i++) {
                         qreal value = min + (i * (max - min) / (ticks - 1));
                         if (format.contains("d")
                                 || format.contains("i")
                                 || format.contains("c"))
                             labels << QString().sprintf(array, (qint64)value);
                         else if (format.contains("u")
                                  || format.contains("o")
                                  || format.contains("x", Qt::CaseInsensitive))
                             labels << QString().sprintf(array, (quint64)value);
                         else if (format.contains("f", Qt::CaseInsensitive)
                                   || format.contains("e", Qt::CaseInsensitive)
                                   || format.contains("g", Qt::CaseInsensitive))
                             labels << QString().sprintf(array, value);
                     }
                 }
                 return labels;
             }
+            QStringList ChartAxis::createLogValueLabels(qreal min, qreal max, qreal base, int ticks, const QString& format)
+            {
+            //    Q_ASSERT(m_max > m_min);
+                //    Q_ASSERT(ticks > 1);
+                QStringList labels;
+                int n = 0;
+                if (ticks > 1)
+                    n = qMax(int(-qFloor(log10((max - min) / (ticks - 1)))), 0);
+                n++;
+            //    QLogValueAxis *axis = qobject_cast<QLogValueAxis *>(m_chartAxis);
+            //    QString format = axis->labelFormat();
+                int firstTick;
+                if (base > 1)
+                    firstTick = (int)(log10(min) / log10(base));
+                else
+                    firstTick = (int)(log10(max) / log10(base));
+                if (format.isNull()) {
+                    for (int i = firstTick; i < ticks + firstTick; i++) {
+                        qreal value = qPow(base, i);
+                        labels << QString::number(value, 'f', n);
+                    }
+                } else {
+                    QByteArray array = format.toAscii();
+                    for (int i = firstTick; i < ticks + firstTick; i++) {
+                        qreal value = qPow(base, i);
+                        labels << QString().sprintf(array, value);
+                    }
+                }
+                return labels;
+            }
             QStringList ChartAxis::createDateTimeLabels(qreal min, qreal max,int ticks,const QString& format)
             {
                 //TODO: Q_ASSERT(m_max > m_min);
                 //TODO: Q_ASSERT(ticks > 1);
                 QStringList labels;
                 if(max <= min || ticks < 1) {
                     return labels;
                 }
                 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 << QDateTime::fromMSecsSinceEpoch(value).toString(format);
                 }
                 return labels;
             }
             #include "moc_chartaxis_p.cpp"
             QTCOMMERCIALCHART_END_NAMESPACE

src/axis/chartaxis_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 CHARTAXIS_H
             #define CHARTAXIS_H
             #include "qchartglobal.h"
             #include "chartelement_p.h"
             #include "axisanimation_p.h"
             #include <QGraphicsItem>
             #include <QGraphicsLayoutItem>
             #include <QFont>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QAbstractAxis;
             class ChartPresenter;
             class ChartAxis : public ChartElement, public QGraphicsLayoutItem
             {
                 Q_OBJECT
                 Q_INTERFACES(QGraphicsLayoutItem)
             public:
                 ChartAxis(QAbstractAxis *axis, QGraphicsItem* item = 0, bool intervalAxis = false);
                 ~ChartAxis();
                 QAbstractAxis* axis() const { return m_axis; }
                 void setLabelPadding(int padding);
                 int labelPadding() const { return m_labelPadding;};
                 QFont titleFont() const;
                 QString titleText() const;
                 void setLayout(QVector<qreal> &layout);
                 QVector<qreal> layout() const { return m_layoutVector; }
                 void setAnimation(AxisAnimation *animation);
                 ChartAnimation *animation() const { return m_animation; };
                 Qt::Orientation orientation() const;
                 Qt::Alignment alignment() const;
                 void setGeometry(const QRectF &axis, const QRectF &grid);
                 QRectF axisGeometry() const { return m_axisRect; }
                 QRectF gridGeometry() const { return m_gridRect; }
                 void setLabels(const QStringList &labels);
                 QStringList labels() const { return m_labelsList; }
                 //this flag indicates that axis is used to show intervals it means labels are in between ticks
                 bool intervalAxis() const { return m_intervalAxis; }
                 virtual QSizeF sizeHint(Qt::SizeHint which, const QSizeF &constraint = QSizeF()) const;
                 QRectF boundingRect() const{
                     return QRectF();
                 }
                 void paint(QPainter*, const QStyleOptionGraphicsItem*, QWidget*)
                 {
                 }
             //helpers
                 static QStringList createValueLabels(qreal max, qreal min, int ticks, const QString &format);
+                static QStringList createLogValueLabels(qreal min, qreal max, qreal base, int ticks, const QString& format);
                 static QStringList createDateTimeLabels(qreal max, qreal min, int ticks, const QString &format);
             protected:
                 void setGeometry(const QRectF &size) { Q_UNUSED(size);};
                 virtual void updateGeometry() = 0;
                 virtual QVector<qreal> calculateLayout() const = 0;
                 QList<QGraphicsItem *> lineItems() { return m_grid->childItems(); };
                 QList<QGraphicsItem *> labelItems() { return m_labels->childItems();};
                 QList<QGraphicsItem *> shadeItems() { return m_shades->childItems();};
                 QList<QGraphicsItem *> arrowItems() { return m_arrow->childItems();};
                 QGraphicsSimpleTextItem* titleItem() const { return m_title.data();}
                 QFont font() const;
                 qreal min() const;
                 qreal max() const;
             //handlers
             public Q_SLOTS:
             	void handleVisibleChanged(bool visible);
             	void handleArrowVisibleChanged(bool visible);
             	void handleGridVisibleChanged(bool visible);
             	void handleLabelsVisibleChanged(bool visible);
             	void handleShadesVisibleChanged(bool visible);
             	void handleLabelsAngleChanged(int angle);
             	void handleShadesBrushChanged(const QBrush &brush);
             	void handleShadesPenChanged(const QPen &pen);
             	void handleArrowPenChanged(const QPen &pen);
             	void handleGridPenChanged(const QPen &pen);
             	void handleLabelsPenChanged(const QPen &pen);
             	void handleLabelsBrushChanged(const QBrush &brush);
             	void handleLabelsFontChanged(const QFont &font);
                 void handleTitlePenChanged(const QPen &pen);
                 void handleTitleBrushChanged(const QBrush &brush);
                 void handleTitleFontChanged(const QFont &font);
                 void handleTitleTextChanged(const QString &title);
                 void handleRangeChanged(qreal min , qreal max);
             Q_SIGNALS:
             	void clicked();
             private:
                 inline bool isEmpty();
                 void createItems(int count);
                 void deleteItems(int count);
                 void updateLayout(QVector<qreal> &layout);
                 void axisSelected();
                 void connectSlots();
             private:
                 QAbstractAxis *m_axis;
                 int m_labelsAngle;
                 QRectF m_axisRect;
                 QRectF m_gridRect;
                 QScopedPointer<QGraphicsItemGroup> m_grid;
                 QScopedPointer<QGraphicsItemGroup> m_arrow;
                 QScopedPointer<QGraphicsItemGroup> m_shades;
                 QScopedPointer<QGraphicsItemGroup> m_labels;
                 QScopedPointer<QGraphicsSimpleTextItem> m_title;
                 QVector<qreal> m_layoutVector;
                 AxisAnimation *m_animation;
                 int m_labelPadding;
                 QStringList m_labelsList;
                 bool m_intervalAxis;
                 friend class AxisAnimation;
                 friend class ArrowItem;
             };
             class ArrowItem: public QGraphicsLineItem
             {
             public:
                 explicit ArrowItem(ChartAxis *axis, QGraphicsItem *parent = 0) : QGraphicsLineItem(parent), m_axis(axis) {}
             protected:
                 void mousePressEvent(QGraphicsSceneMouseEvent *event) {
                     Q_UNUSED(event)
                     m_axis->axisSelected();
                 }
                 QRectF boundingRect() const {
                     return shape().boundingRect();
                 }
                 QPainterPath shape() const {
                     QPainterPath path = QGraphicsLineItem::shape();
                     QRectF rect = path.boundingRect();
                     path.addRect(rect.adjusted(0, 0, m_axis->orientation() != Qt::Horizontal ? 8 : 0, m_axis->orientation() != Qt::Vertical ? 8 : 0));
                     return path;
                 }
             private:
                 ChartAxis *m_axis;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif /* CHARTAXI_H */

src/axis/qabstractaxis.h +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$
             **
             ****************************************************************************/
             #ifndef QABSTRACTAXIS_H
             #define QABSTRACTAXIS_H
             #include <qchartglobal.h>
             #include <QPen>
             #include <QFont>
             #include <QVariant>
             QTCOMMERCIALCHART_BEGIN_NAMESPACE
             class QAbstractAxisPrivate;
             class QTCOMMERCIALCHART_EXPORT QAbstractAxis : public QObject
             {
                 Q_OBJECT
                 //visibility
                 Q_PROPERTY(bool visible READ isVisible WRITE setVisible NOTIFY visibleChanged)
                 //arrow
                 Q_PROPERTY(bool lineVisible READ isLineVisible WRITE setLineVisible NOTIFY lineVisibleChanged)
                 Q_PROPERTY(QPen linePen READ linePen WRITE setLinePen NOTIFY linePenChanged)
                 //TODO: make wrapping of color for qml
                 Q_PROPERTY(QColor color READ linePenColor WRITE setLinePenColor NOTIFY colorChanged)
                 //labels
                 Q_PROPERTY(bool labelsVisible READ labelsVisible WRITE setLabelsVisible NOTIFY labelsVisibleChanged)
                 Q_PROPERTY(QPen lablesPen READ labelsPen WRITE setLabelsPen NOTIFY labelsPenChanged)
                 Q_PROPERTY(QBrush lablesBrush READ labelsBrush WRITE setLabelsBrush NOTIFY labelsBrushChanged)
                 //TODO: fix labels angles to work with layout
                 Q_PROPERTY(int labelsAngle READ labelsAngle WRITE setLabelsAngle NOTIFY labelsAngleChanged)
                 Q_PROPERTY(QFont labelsFont READ labelsFont WRITE setLabelsFont NOTIFY labelsFontChanged)
                 //TODO: make wrapping of color for qml
                 Q_PROPERTY(QColor labelsColor READ labelsColor WRITE setLabelsColor NOTIFY labelsColorChanged)
                 //grid
                 Q_PROPERTY(bool gridVisible READ isGridLineVisible WRITE setGridLineVisible NOTIFY gridLineVisibleChanged)
                 Q_PROPERTY(QPen girdLinePen READ gridLinePen WRITE setGridLinePen NOTIFY gridLinePenChanged)
                 //shades
                 Q_PROPERTY(bool shadesVisible READ shadesVisible WRITE setShadesVisible NOTIFY shadesVisibleChanged)
                 //TODO: make wrapping of color for qml
                 Q_PROPERTY(QColor shadesColor READ shadesColor WRITE setShadesColor NOTIFY shadesColorChanged)
                 //TODO: make wrapping of border for qml
                 Q_PROPERTY(QColor shadesBorderColor READ shadesBorderColor WRITE setShadesBorderColor NOTIFY shadesBorderColorChanged)
                 Q_PROPERTY(QPen shadesPen READ shadesPen WRITE setShadesPen NOTIFY shadesPenChanged)
                 Q_PROPERTY(QBrush shadesBrush READ shadesBrush WRITE setShadesBrush NOTIFY shadesBrushChanged)
                 //title
                 Q_PROPERTY(QString titleText READ titleText WRITE setTitleText NOTIFY titleTextChanged)
                 Q_PROPERTY(QPen titlePen READ titlePen WRITE setTitlePen NOTIFY titlePenChanged)
                 Q_PROPERTY(QBrush titleBrush READ titleBrush WRITE setTitleBrush NOTIFY titleBrushChanged)
                 Q_PROPERTY(bool titleVisible READ titleVisible WRITE setTitleVisible)
                 Q_PROPERTY(QFont titleFont READ titleFont WRITE setTitleFont)
             public:
                 enum AxisType {
                     AxisTypeNoAxis = 0x0,
                     AxisTypeValue = 0x1,
                     AxisTypeBarCategory = 0x2,
                     AxisTypeCategory = 0x3,
-                    AxisTypeDateTime = 0x4
+                    AxisTypeDateTime = 0x4,
+                    AxisTypeLogValue = 0x5
                 };
                 Q_DECLARE_FLAGS(AxisTypes, AxisType)
             protected:
                 explicit QAbstractAxis(QAbstractAxisPrivate &d, QObject *parent = 0);
             public:
                 ~QAbstractAxis();
                 virtual AxisType type() const = 0;
                 //visibility handling
                 bool isVisible() const;
                 void setVisible(bool visible = true);
                 void show();
                 void hide();
                 //arrow handling
                 bool isLineVisible() const;
                 void setLineVisible(bool visible = true);
                 void setLinePen(const QPen &pen);
                 QPen linePen() const;
                 void setLinePenColor(QColor color);
                 QColor linePenColor() const;
                 //grid handling
                 bool isGridLineVisible() const;
                 void setGridLineVisible(bool visible = true);
                 void setGridLinePen(const QPen &pen);
                 QPen gridLinePen() const;
                 //labels handling
                 bool labelsVisible() const;
                 void setLabelsVisible(bool visible = true);
                 void setLabelsPen(const QPen &pen);
                 QPen labelsPen() const;
                 void setLabelsBrush(const QBrush &brush);
                 QBrush labelsBrush() const;
                 void setLabelsFont(const QFont &font);
                 QFont labelsFont() const;
                 void setLabelsAngle(int angle);
                 int labelsAngle() const;
                 void setLabelsColor(QColor color);
                 QColor labelsColor() const;
                 //title handling
                 bool titleVisible() const;
                 void setTitleVisible(bool visible = true);
                 void setTitlePen(const QPen &pen);
                 QPen titlePen() const;
                 void setTitleBrush(const QBrush &brush);
                 QBrush titleBrush() const;
                 void setTitleFont(const QFont &font);
                 QFont titleFont() const;
                 void setTitleText(const QString &title);
                 QString titleText() const;
                 //shades handling
                 bool shadesVisible() const;
                 void setShadesVisible(bool visible = true);
                 void setShadesPen(const QPen &pen);
                 QPen shadesPen() const;
                 void setShadesBrush(const QBrush &brush);
                 QBrush shadesBrush() const;
                 void setShadesColor(QColor color);
                 QColor shadesColor() const;
                 void setShadesBorderColor(QColor color);
                 QColor shadesBorderColor() const;
                 Qt::Orientation orientation(); //TODO: missing const <- BC
                 Qt::Alignment alignment() const;
                 //range handling
                 void setMin(const QVariant &min);
                 void setMax(const QVariant &max);
                 void setRange(const QVariant &min, const QVariant &max);
             Q_SIGNALS:
                 void visibleChanged(bool visible);
                 void linePenChanged(const QPen& pen);
                 void lineVisibleChanged(bool visible);
                 void labelsVisibleChanged(bool visible);
                 void labelsPenChanged(const QPen& pen);
                 void labelsBrushChanged(const QBrush& brush);
                 void labelsFontChanged(const QFont& pen);
                 void labelsAngleChanged(int angle);
                 void gridLinePenChanged(const QPen& pen);
                 void gridLineVisibleChanged(bool visible);
                 void colorChanged(QColor color);
                 void labelsColorChanged(QColor color);
                 void titleTextChanged(const QString& title);
                 void titlePenChanged(const QPen& pen);
                 void titleBrushChanged(const QBrush brush);
                 void titleVisibleChanged(bool visible);
                 void titleFontChanged(const QFont& font);
                 void shadesVisibleChanged(bool visible);
                 void shadesColorChanged(QColor color);
                 void shadesBorderColorChanged(QColor color);
                 void shadesPenChanged(const QPen& pen);
                 void shadesBrushChanged(const QBrush brush);
             protected:
                 QScopedPointer<QAbstractAxisPrivate> d_ptr;
                 Q_DISABLE_COPY(QAbstractAxis)
                 friend class ChartDataSet;
                 friend class ChartAxis;
                 friend class ChartPresenter;
                 friend class ChartThemeManager;
             };
             QTCOMMERCIALCHART_END_NAMESPACE
             #endif // QABSTRACTAXIS_H

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