#include "KChartEnums.h"
/**
* @brief base class for prerendered elements like labels, pixmaps, markers, etc.
*/
class PrerenderedElement {
public:
PrerenderedElement();
virtual ~PrerenderedElement() {}
/** Returns the rendered element.
If any of the properties have change, the element will be
regenerated. */
virtual const QPixmap& pixmap() const = 0;
/** Return the location of the reference point relatively to the
pixmap's origin. */
virtual QPointF referencePointLocation( KChartEnums::PositionValue ) const = 0;
/** Set the position of the element. */
void setPosition( const QPointF& position );
/** Get the position of the element. */
const QPointF& position() const;
/** Set the reference point of the element.
Every element has nine possible reference points (all compass
directions, plus the center.
*/
void setReferencePoint( KChartEnums::PositionValue );
/** Get the reference point of the element. */
KChartEnums::PositionValue referencePoint() const;
protected:
/** invalidate() needs to be called if any of the properties that
determine the visual appearance of the prerendered element
change.
It can be called for a const object, as objects may need to
force recalculation of the pixmap.
*/
virtual void invalidate() const = 0;
private:
QPointF m_position;
KChartEnums::PositionValue m_referencePoint;
};
-/**
+/**
@brief PrerenderedLabel is an internal KChart class that simplifies creation
and caching of cached text labels.
-
+
It provides referenze points to anchor the text to other
elements. Reference points use the positions defined in
KChartEnums.
Usage:
qreal angle = 90.0;
CachedLabel label;
label.paint( font, tr("Label"), angle );
*/
// FIXME this is merely a prototype
// FIXME caching could be done by a second layer that can be used to,
// e.g., query for a prerendered element by id or name, or by changing
// the pixmap() method to do lazy evaluation.
class PrerenderedLabel : public PrerenderedElement
{
public:
PrerenderedLabel();
~PrerenderedLabel();
+
+ /**
+ * Sets the label's font to \a font.
+ */
void setFont( const QFont& font );
+
+ /**
+ * @return the label's font.
+ */
const QFont& font() const;
+
+ /**
+ * Sets the label's text to \a text
+ */
void setText( const QString& text );
+
+ /**
+ * @return the label's text
+ */
const QString& text() const;
+
+ /**
+ * Sets the label's brush to \a brush
+ */
void setBrush( const QBrush& brush );
+
+ /**
+ * @return the label's brush
+ */
const QBrush& brush() const;
void setPen( const QPen& );
const QPen& pen() const;
+
+ /**
+ * Sets the angle of the label to \a angle degrees
+ */
void setAngle( qreal angle );
+
+ /**
+ * @return the label's angle in degrees
+ */
qreal angle() const;
// reimpl PrerenderedElement:
const QPixmap& pixmap() const override;
QPointF referencePointLocation( KChartEnums::PositionValue position ) const override;
// overload: return location of referencePoint():
QPointF referencePointLocation() const;
protected:
+
+ /**
+ * Invalidates the preredendered data, forces re-rendering.
+ */
void invalidate() const override;
private:
/** Create a label with the given text and the given rotation
angle. Needs to be const, otherwise the pixmap() method cannot
update when needed. */
void paint() const;
// store the settings (these are used for the painting):
mutable bool m_dirty;
QFont m_font;
QString m_text;
QBrush m_brush;
QPen m_pen;
qreal m_angle;
// these are valid once the label has been rendered:
mutable QPixmap m_pixmap;
mutable QPointF m_referenceBottomLeft;
mutable QPointF m_textBaseLineVector;
mutable QPointF m_textAscendVector;
};
#endif
diff --git a/src/KChart/KChartWidget.cpp b/src/KChart/KChartWidget.cpp
index 6bd11cd..c1e7d48 100644
--- a/src/KChart/KChartWidget.cpp
+++ b/src/KChart/KChartWidget.cpp
@@ -1,625 +1,551 @@
/*
* Copyright (C) 2001-2015 Klaralvdalens Datakonsult AB. All rights reserved.
*
* This file is part of the KD Chart library.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation; either version 2 of
* the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see .
*/
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include "KChartMath_p.h"
#include
#define d d_func()
using namespace KChart;
Widget::Private::Private( Widget * qq )
: q( qq ),
layout( q ),
m_model( q ),
m_chart( q ),
m_cartPlane( &m_chart ),
m_polPlane( &m_chart ),
usedDatasetWidth( 0 )
{
KDAB_SET_OBJECT_NAME( layout );
KDAB_SET_OBJECT_NAME( m_model );
KDAB_SET_OBJECT_NAME( m_chart );
layout.addWidget( &m_chart );
}
Widget::Private::~Private() {}
-/**
-* \class Widget KChartWidget.h
-* \brief The KChart widget for usage without Interwiev.
-*
-* If you want to use KChart with Interview, use KChart::Chart instead.
-*/
-
-/**
- * Constructor. Creates a new widget with all data initialized empty.
- *
- * \param parent the widget parent; passed on to QWidget
- */
+
Widget::Widget( QWidget* parent ) :
QWidget(parent), _d( new Private( this ) )
{
// as default we have a cartesian coordinate plane ...
// ... and a line diagram
setType( Line );
}
-/**
- * Destructor.
- */
Widget::~Widget()
{
delete _d; _d = nullptr;
}
void Widget::init()
{
}
void Widget::setDataset( int column, const QVector< qreal > & data, const QString& title )
{
if ( ! checkDatasetWidth( 1 ) )
return;
QStandardItemModel & model = d->m_model;
justifyModelSize( data.size(), column + 1 );
for ( int i = 0; i < data.size(); ++i )
{
const QModelIndex index = model.index( i, column );
model.setData( index, QVariant( data[i] ), Qt::DisplayRole );
}
if ( ! title.isEmpty() )
model.setHeaderData( column, Qt::Horizontal, QVariant( title ) );
}
void Widget::setDataset( int column, const QVector< QPair< qreal, qreal > > & data, const QString& title )
{
if ( ! checkDatasetWidth( 2 ))
return;
QStandardItemModel & model = d->m_model;
justifyModelSize( data.size(), (column + 1) * 2 );
for ( int i = 0; i < data.size(); ++i )
{
QModelIndex index = model.index( i, column * 2 );
model.setData( index, QVariant( data[i].first ), Qt::DisplayRole );
index = model.index( i, column * 2 + 1 );
model.setData( index, QVariant( data[i].second ), Qt::DisplayRole );
}
if ( ! title.isEmpty() ) {
model.setHeaderData( column, Qt::Horizontal, QVariant( title ) );
}
}
void Widget::setDataCell( int row, int column, qreal data )
{
if ( ! checkDatasetWidth( 1 ) )
return;
QStandardItemModel & model = d->m_model;
justifyModelSize( row + 1, column + 1 );
const QModelIndex index = model.index( row, column );
model.setData( index, QVariant( data ), Qt::DisplayRole );
}
void Widget::setDataCell( int row, int column, QPair< qreal, qreal > data )
{
if ( ! checkDatasetWidth( 2 ))
return;
QStandardItemModel & model = d->m_model;
justifyModelSize( row + 1, (column + 1) * 2 );
QModelIndex index = model.index( row, column * 2 );
model.setData( index, QVariant( data.first ), Qt::DisplayRole );
index = model.index( row, column * 2 + 1 );
model.setData( index, QVariant( data.second ), Qt::DisplayRole );
}
/*
* Resets all data.
*/
void Widget::resetData()
{
d->m_model.clear();
d->usedDatasetWidth = 0;
}
-/**
- * Sets all global leadings (borders).
- */
void Widget::setGlobalLeading( int left, int top, int right, int bottom )
{
d->m_chart.setGlobalLeading( left, top, right, bottom );
}
-/**
- * Sets the left leading (border).
- */
void Widget::setGlobalLeadingLeft( int leading )
{
d->m_chart.setGlobalLeadingLeft( leading );
}
-/**
- * Returns the left leading (border).
- */
int Widget::globalLeadingLeft() const
{
return d->m_chart.globalLeadingLeft();
}
-/**
- * Sets the top leading (border).
- */
void Widget::setGlobalLeadingTop( int leading )
{
d->m_chart.setGlobalLeadingTop( leading );
}
-/**
- * Returns the top leading (border).
- */
int Widget::globalLeadingTop() const
{
return d->m_chart.globalLeadingTop();
}
-/**
- * Sets the right leading (border).
- */
void Widget::setGlobalLeadingRight( int leading )
{
d->m_chart.setGlobalLeadingRight( leading );
}
-/**
- * Returns the right leading (border).
- */
int Widget::globalLeadingRight() const
{
return d->m_chart.globalLeadingRight();
}
-/**
- * Sets the bottom leading (border).
- */
void Widget::setGlobalLeadingBottom( int leading )
{
d->m_chart.setGlobalLeadingBottom( leading );
}
-/**
- * Returns the bottom leading (border).
- */
int Widget::globalLeadingBottom() const
{
return d->m_chart.globalLeadingBottom();
}
-/**
- * Returns the first of all headers.
- */
KChart::HeaderFooter* Widget::firstHeaderFooter()
{
return d->m_chart.headerFooter();
}
-/**
- * Returns a list with all headers.
- */
QList Widget::allHeadersFooters()
{
return d->m_chart.headerFooters();
}
-/**
- * Adds a new header/footer with the given text to the position.
- */
void Widget::addHeaderFooter( const QString& text,
HeaderFooter::HeaderFooterType type,
Position position)
{
HeaderFooter* newHeader = new HeaderFooter( &d->m_chart );
newHeader->setType( type );
newHeader->setPosition( position );
newHeader->setText( text );
d->m_chart.addHeaderFooter( newHeader ); // we need this explicit call !
}
-/**
- * Adds an existing header / footer object.
- */
void Widget::addHeaderFooter( HeaderFooter* header )
{
header->setParent( &d->m_chart );
d->m_chart.addHeaderFooter( header ); // we need this explicit call !
}
void Widget::replaceHeaderFooter( HeaderFooter* header, HeaderFooter* oldHeader )
{
header->setParent( &d->m_chart );
d->m_chart.replaceHeaderFooter( header, oldHeader );
}
void Widget::takeHeaderFooter( HeaderFooter* header )
{
d->m_chart.takeHeaderFooter( header );
}
-/**
- * Returns the first of all legends.
- */
KChart::Legend* Widget::legend()
{
return d->m_chart.legend();
}
-/**
- * Returns a list with all legends.
- */
QList Widget::allLegends()
{
return d->m_chart.legends();
}
-/**
- * Adds an empty legend on the given position.
- */
void Widget::addLegend( Position position )
{
Legend* legend = new Legend( diagram(), &d->m_chart );
legend->setPosition( position );
d->m_chart.addLegend( legend );
}
-/**
- * Adds a new, already existing, legend.
- */
void Widget::addLegend( Legend* legend )
{
legend->setDiagram( diagram() );
legend->setParent( &d->m_chart );
d->m_chart.addLegend( legend );
}
void Widget::replaceLegend( Legend* legend, Legend* oldLegend )
{
legend->setDiagram( diagram() );
legend->setParent( &d->m_chart );
d->m_chart.replaceLegend( legend, oldLegend );
}
void Widget::takeLegend( Legend* legend )
{
d->m_chart.takeLegend( legend );
}
AbstractDiagram* Widget::diagram()
{
if ( coordinatePlane() == nullptr )
qDebug() << "diagram(): coordinatePlane() was NULL";
return coordinatePlane()->diagram();
}
BarDiagram* Widget::barDiagram()
{
return dynamic_cast( diagram() );
}
LineDiagram* Widget::lineDiagram()
{
return dynamic_cast( diagram() );
}
Plotter* Widget::plotter()
{
return dynamic_cast( diagram() );
}
PieDiagram* Widget::pieDiagram()
{
return dynamic_cast( diagram() );
}
RingDiagram* Widget::ringDiagram()
{
return dynamic_cast( diagram() );
}
PolarDiagram* Widget::polarDiagram()
{
return dynamic_cast( diagram() );
}
AbstractCoordinatePlane* Widget::coordinatePlane()
{
return d->m_chart.coordinatePlane();
}
static bool isCartesian( KChart::Widget::ChartType type )
{
return (type == KChart::Widget::Bar) || (type == KChart::Widget::Line);
}
static bool isPolar( KChart::Widget::ChartType type )
{
return (type == KChart::Widget::Pie)
|| (type == KChart::Widget::Ring)
|| (type == KChart::Widget::Polar);
}
void Widget::setType( ChartType chartType, SubType chartSubType )
{
AbstractDiagram* diag = nullptr;
const ChartType oldType = type();
if ( chartType != oldType ) {
if ( chartType != NoType ) {
if ( isCartesian( chartType ) && ! isCartesian( oldType ) )
{
if ( coordinatePlane() == &d->m_polPlane ) {
d->m_chart.takeCoordinatePlane( &d->m_polPlane );
d->m_chart.addCoordinatePlane( &d->m_cartPlane );
} else {
d->m_chart.replaceCoordinatePlane( &d->m_cartPlane );
}
}
else if ( isPolar( chartType ) && ! isPolar( oldType ) )
{
if ( coordinatePlane() == &d->m_cartPlane ) {
d->m_chart.takeCoordinatePlane( &d->m_cartPlane );
d->m_chart.addCoordinatePlane( &d->m_polPlane );
} else {
d->m_chart.replaceCoordinatePlane( &d->m_polPlane );
}
}
}
switch ( chartType ) {
case Bar:
diag = new BarDiagram( &d->m_chart, &d->m_cartPlane );
break;
case Line:
diag = new LineDiagram( &d->m_chart, &d->m_cartPlane );
break;
case Plot:
diag = new Plotter( &d->m_chart, &d->m_cartPlane );
break;
case Pie:
diag = new PieDiagram( &d->m_chart, &d->m_polPlane );
break;
case Polar:
diag = new PolarDiagram( &d->m_chart, &d->m_polPlane );
break;
case Ring:
diag = new RingDiagram( &d->m_chart, &d->m_polPlane );
break;
case NoType:
break;
}
if ( diag != nullptr ) {
if ( isCartesian( oldType ) && isCartesian( chartType ) ) {
AbstractCartesianDiagram *oldDiag =
qobject_cast( coordinatePlane()->diagram() );
AbstractCartesianDiagram *newDiag =
qobject_cast( diag );
Q_FOREACH( CartesianAxis* axis, oldDiag->axes() ) {
oldDiag->takeAxis( axis );
newDiag->addAxis ( axis );
}
}
Q_FOREACH( Legend* l, d->m_chart.legends() ) {
l->setDiagram( diag );
}
diag->setModel( &d->m_model );
coordinatePlane()->replaceDiagram( diag );
//checkDatasetWidth( d->usedDatasetWidth );
}
//coordinatePlane()->setGridNeedsRecalculate();
}
if ( chartType != NoType ) {
if ( chartType != oldType || chartSubType != subType() )
setSubType( chartSubType );
d->m_chart.resize( size() ); // triggering immediate update
}
}
template< class DiagramType, class Subtype >
void setSubtype( AbstractDiagram *_dia, Subtype st)
{
if ( DiagramType *dia = qobject_cast< DiagramType * >( _dia ) ) {
dia->setType( st );
}
}
void Widget::setSubType( SubType subType )
{
// ### at least PieDiagram, PolarDiagram and RingDiagram are unhandled here
AbstractDiagram *dia = diagram();
switch ( subType ) {
case Normal:
setSubtype< BarDiagram >( dia, BarDiagram::Normal );
setSubtype< LineDiagram >( dia, LineDiagram::Normal );
setSubtype< Plotter >( dia, Plotter::Normal );
break;
case Stacked:
setSubtype< BarDiagram >( dia, BarDiagram::Stacked );
setSubtype< LineDiagram >( dia, LineDiagram::Stacked );
// setSubtype< Plotter >( dia, Plotter::Stacked );
break;
case Percent:
setSubtype< BarDiagram >( dia, BarDiagram::Percent );
setSubtype< LineDiagram >( dia, LineDiagram::Percent );
setSubtype< Plotter >( dia, Plotter::Percent );
break;
case Rows:
setSubtype< BarDiagram >( dia, BarDiagram::Rows );
break;
default:
Q_ASSERT_X ( false, "Widget::setSubType", "Sub-type not supported!" );
break;
}
}
-/**
- * Returns the type of the chart.
- */
Widget::ChartType Widget::type() const
{
// PENDING(christoph) save the type out-of-band:
AbstractDiagram * const dia = const_cast( this )->diagram();
if ( qobject_cast< BarDiagram* >( dia ) )
return Bar;
else if ( qobject_cast< LineDiagram* >( dia ) )
return Line;
else if ( qobject_cast< Plotter* >( dia ) )
return Plot;
else if ( qobject_cast< PieDiagram* >( dia ) )
return Pie;
else if ( qobject_cast< PolarDiagram* >( dia ) )
return Polar;
else if ( qobject_cast< RingDiagram* >( dia ) )
return Ring;
else
return NoType;
}
Widget::SubType Widget::subType() const
{
// PENDING(christoph) save the type out-of-band:
Widget::SubType retVal = Normal;
AbstractDiagram * const dia = const_cast( this )->diagram();
BarDiagram* barDia = qobject_cast< BarDiagram* >( dia );
LineDiagram* lineDia = qobject_cast< LineDiagram* >( dia );
Plotter* plotterDia = qobject_cast< Plotter* >( dia );
//FIXME(khz): Add the impl for these chart types - or remove them from here:
// PieDiagram* pieDia = qobject_cast< PieDiagram* >( diagram() );
// PolarDiagram* polarDia = qobject_cast< PolarDiagram* >( diagram() );
// RingDiagram* ringDia = qobject_cast< RingDiagram* >( diagram() );
#define TEST_SUB_TYPE(DIAGRAM, INTERNALSUBTYPE, SUBTYPE) \
{ \
if ( DIAGRAM && DIAGRAM->type() == INTERNALSUBTYPE ) \
retVal = SUBTYPE; \
}
const Widget::ChartType mainType = type();
switch ( mainType )
{
case Bar:
TEST_SUB_TYPE( barDia, BarDiagram::Normal, Normal );
TEST_SUB_TYPE( barDia, BarDiagram::Stacked, Stacked );
TEST_SUB_TYPE( barDia, BarDiagram::Percent, Percent );
TEST_SUB_TYPE( barDia, BarDiagram::Rows, Rows );
break;
case Line:
TEST_SUB_TYPE( lineDia, LineDiagram::Normal, Normal );
TEST_SUB_TYPE( lineDia, LineDiagram::Stacked, Stacked );
TEST_SUB_TYPE( lineDia, LineDiagram::Percent, Percent );
break;
case Plot:
TEST_SUB_TYPE( plotterDia, Plotter::Normal, Normal );
TEST_SUB_TYPE( plotterDia, Plotter::Percent, Percent );
break;
case Pie:
// no impl. yet
break;
case Polar:
// no impl. yet
break;
case Ring:
// no impl. yet
break;
default:
Q_ASSERT_X ( false,
"Widget::subType", "Chart type not supported!" );
break;
}
return retVal;
}
-/**
- * Checks whether the given width matches with the one used until now.
- */
bool Widget::checkDatasetWidth( int width )
{
if ( width == diagram()->datasetDimension() )
{
d->usedDatasetWidth = width;
return true;
}
qDebug() << "The current diagram type doesn't support this data dimension.";
return false;
/* if ( d->usedDatasetWidth == width || d->usedDatasetWidth == 0 ) {
d->usedDatasetWidth = width;
diagram()->setDatasetDimension( width );
return true;
}
qDebug() << "It's impossible to mix up the different setDataset() methods on the same widget.";
return false;*/
}
-/**
- * Justifies the model, so that the given rows and columns fit into it.
- */
void Widget::justifyModelSize( int rows, int columns )
{
QAbstractItemModel & model = d->m_model;
const int currentRows = model.rowCount();
const int currentCols = model.columnCount();
if ( currentCols < columns )
if ( ! model.insertColumns( currentCols, columns - currentCols ))
qDebug() << "justifyModelSize: could not increase model size.";
if ( currentRows < rows )
if ( ! model.insertRows( currentRows, rows - currentRows ))
qDebug() << "justifyModelSize: could not increase model size.";
Q_ASSERT( model.rowCount() >= rows );
Q_ASSERT( model.columnCount() >= columns );
}
diff --git a/src/KChart/KChartWidget.h b/src/KChart/KChartWidget.h
index fe3f255..6472050 100644
--- a/src/KChart/KChartWidget.h
+++ b/src/KChart/KChartWidget.h
@@ -1,239 +1,239 @@
/*
* Copyright (C) 2001-2015 Klaralvdalens Datakonsult AB. All rights reserved.
*
* This file is part of the KD Chart library.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation; either version 2 of
* the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see .
*/
#ifndef __KCHARTWIDGET_H__
#define __KCHARTWIDGET_H__
#include "KChartGlobal.h"
#include
#include "KChartEnums.h"
#include "KChartHeaderFooter.h"
QT_BEGIN_NAMESPACE
template class QVector;
template struct QPair;
QT_END_NAMESPACE
namespace KChart {
// some forward declarations
class AbstractDiagram;
class Chart;
class AbstractCoordinatePlane;
class TableModel;
class BarDiagram;
class LineDiagram;
class Plotter;
class PieDiagram;
class RingDiagram;
class PolarDiagram;
class Legend;
class Position;
/**
- * \class Widget KChartWidget.h
- * \brief The KChart widget for usage without Model/View.
- *
- * If you want to use KChart with Model/View, use KChart::Chart instead.
- */
- class KCHART_EXPORT Widget : public QWidget
+ * \class Widget KChartWidget.h
+ * \brief The KChart widget for usage without Interwiev.
+ *
+ * If you want to use KChart with Interview, use KChart::Chart instead.
+ */
+ class KCHART_EXPORT Widget : public QWidget
{
Q_OBJECT
Q_DISABLE_COPY( Widget )
KCHART_DECLARE_PRIVATE_BASE_POLYMORPHIC_QWIDGET( Widget )
public:
/**
* Standard Qt-style Constructor
*
* Creates a new widget with all data initialized empty.
*
* \param parent the widget parent; passed on to QWidget
*/
- explicit Widget( QWidget* parent = nullptr );
+ explicit Widget( QWidget* parent = nullptr );
/** Destructor. */
- ~Widget();
+ ~Widget();
/** Sets the data in the given column using a QVector of qreal for the Y values. */
void setDataset( int column, const QVector< qreal > & data, const QString& title = QString() );
/** Sets the data in the given column using a QVector of QPairs
* of qreal for the (X, Y) values. */
void setDataset( int column, const QVector< QPair< qreal, qreal > > & data, const QString& title = QString() );
/** Sets the Y value data for a given cell. */
void setDataCell( int row, int column, qreal data );
/** Sets the data for a given column using an (X, Y) QPair of qreals. */
void setDataCell( int row, int column, QPair< qreal, qreal > data );
/** Resets all data. */
void resetData();
public Q_SLOTS:
/** Sets all global leadings (borders). */
void setGlobalLeading( int left, int top, int right, int bottom );
/** Sets the left leading (border). */
- void setGlobalLeadingLeft( int leading );
+ void setGlobalLeadingLeft( int leading );
/** Sets the top leading (border). */
- void setGlobalLeadingTop( int leading );
+ void setGlobalLeadingTop( int leading );
/** Sets the right leading (border). */
- void setGlobalLeadingRight( int leading );
+ void setGlobalLeadingRight( int leading );
/** Sets the bottom leading (border). */
- void setGlobalLeadingBottom( int leading );
+ void setGlobalLeadingBottom( int leading );
public:
/** Returns the left leading (border). */
int globalLeadingLeft() const;
/** Returns the top leading (border). */
int globalLeadingTop() const;
/** Returns the right leading (border). */
int globalLeadingRight() const;
/** Returns the bottom leading (border). */
int globalLeadingBottom() const;
/** Returns the first of all headers. */
HeaderFooter* firstHeaderFooter();
/** Returns a list with all headers. */
QList allHeadersFooters();
/** Adds a new header/footer with the given text to the position. */
void addHeaderFooter( const QString& text,
HeaderFooter::HeaderFooterType type,
Position position );
/**
* Adds the existing header / footer object \a header.
* \sa replaceHeaderFooter, takeHeaderFooter
*/
void addHeaderFooter( HeaderFooter* header );
/**
* Replaces the old header (or footer, resp.), or appends the
* new header or footer, it there is none yet.
*
* @param header The header or footer to be used instead of the old one.
* This parameter must not be zero, or the method will do nothing.
*
* @param oldHeader The header or footer to be removed by the new one. This
* header or footer will be deleted automatically. If the parameter is omitted,
* the very first header or footer will be replaced. In case, there was no
* header and no footer yet, the new header or footer will just be added.
*
* \note If you want to re-use the old header or footer, call takeHeaderFooter and
* addHeaderFooter, instead of using replaceHeaderFooter.
*
* \sa addHeaderFooter, takeHeaderFooter
*/
void replaceHeaderFooter( HeaderFooter* header,
HeaderFooter* oldHeader = nullptr );
/** Remove the header (or footer, resp.) from the widget,
* without deleting it.
* The chart no longer owns the header or footer, so it is
* the caller's responsibility to delete the header or footer.
*
* \sa addHeaderFooter, replaceHeaderFooter
*/
void takeHeaderFooter( HeaderFooter* header );
/** Returns the first of all legends. */
Legend* legend();
/** Returns a list with all legends. */
QList allLegends();
/** Adds an empty legend on the given position. */
void addLegend( Position position );
/** Adds a new, already existing, legend. */
void addLegend (Legend* legend );
void replaceLegend( Legend* legend, Legend* oldLegend = nullptr );
void takeLegend( Legend* legend );
/** Returns a pointer to the current diagram. */
AbstractDiagram* diagram();
/** If the current diagram is a BarDiagram, it is returnd; otherwise 0 is returned.
* This function provides type-safe casting.
*/
BarDiagram* barDiagram();
/** If the current diagram is a LineDiagram, it is returnd; otherwise 0 is returned.
* This function provides type-safe casting.
*/
LineDiagram* lineDiagram();
/** If the current diagram is a LineDiagram, it is returnd; otherwise 0 is returned.
* This function provides type-safe casting.
*
* \note Do not use lineDiagram for multi-dimensional diagrams, but use plotter instead
*
* \sa plotter
*/
Plotter* plotter();
/** If the current diagram is a Plotter, it is returnd; otherwise 0 is returned.
* This function provides type-safe casting.
*/
PieDiagram* pieDiagram();
/** If the current diagram is a RingDiagram, it is returnd; otherwise 0 is returned.
* This function provides type-safe casting.
*/
RingDiagram* ringDiagram();
/** If the current diagram is a PolarDiagram, it is returnd; otherwise 0 is returned.
* This function provides type-safe casting.
*/
PolarDiagram* polarDiagram();
/** Returns a pointer to the current coordinate plane. */
AbstractCoordinatePlane* coordinatePlane();
enum ChartType { NoType, Bar, Line, Plot, Pie, Ring, Polar };
/** Returns the type of the chart. */
ChartType type() const;
/** Sub type values, matching the values defines for the respective Diagram classes. */
enum SubType { Normal, Stacked, Percent, Rows };
/** Returns the sub-type of the chart. */
SubType subType() const;
public Q_SLOTS:
/** Sets the type of the chart. */
void setType( ChartType chartType, SubType subType=Normal );
/** \brief Sets the type of the chart without changing the main type.
*
* Make sure to use a sub-type that matches the main type,
* so e.g. setting sub-type Rows makes sense for Bar charts only,
* and it will be ignored for all other chart types.
*
* \sa KChart::BarDiagram::BarType, KChart::LineDiagram::LineType
* \sa KChart::PieDiagram::PieType, KChart::RingDiagram::RingType
* \sa KChart::PolarDiagram::PolarType
*/
void setSubType( SubType subType );
private:
/** Justifies the model, so that the given rows and columns fit into it. */
void justifyModelSize( int rows, int columns );
/** Checks whether the given width matches with the one used until now. */
- bool checkDatasetWidth( int width );
+ bool checkDatasetWidth( int width );
};
}
#endif // KChartWidget_H
diff --git a/src/KChart/Polar/KChartPieDiagram.cpp b/src/KChart/Polar/KChartPieDiagram.cpp
index a7db17d..0cb2fe2 100644
--- a/src/KChart/Polar/KChartPieDiagram.cpp
+++ b/src/KChart/Polar/KChartPieDiagram.cpp
@@ -1,966 +1,901 @@
/*
* Copyright (C) 2001-2015 Klaralvdalens Datakonsult AB. All rights reserved.
*
* This file is part of the KD Chart library.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation; either version 2 of
* the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see .
*/
#include "KChartPieDiagram.h"
#include "KChartPieDiagram_p.h"
#include "KChartPaintContext.h"
#include "KChartPieAttributes.h"
#include "KChartPolarCoordinatePlane_p.h"
#include "KChartThreeDPieAttributes.h"
#include "KChartPainterSaver_p.h"
#include "KChartMath_p.h"
#include
#include
#include
using namespace KChart;
PieDiagram::Private::Private()
: labelDecorations( PieDiagram::NoDecoration ),
isCollisionAvoidanceEnabled( false )
{
}
PieDiagram::Private::~Private() {}
#define d d_func()
PieDiagram::PieDiagram( QWidget* parent, PolarCoordinatePlane* plane ) :
AbstractPieDiagram( new Private(), parent, plane )
{
init();
}
PieDiagram::~PieDiagram()
{
}
void PieDiagram::init()
{
}
-/**
- * Creates an exact copy of this diagram.
- */
PieDiagram * PieDiagram::clone() const
{
return new PieDiagram( new Private( *d ) );
}
void PieDiagram::setLabelDecorations( LabelDecorations decorations )
{
d->labelDecorations = decorations;
}
PieDiagram::LabelDecorations PieDiagram::labelDecorations() const
{
return d->labelDecorations;
}
void PieDiagram::setLabelCollisionAvoidanceEnabled( bool enabled )
{
d->isCollisionAvoidanceEnabled = enabled;
}
bool PieDiagram::isLabelCollisionAvoidanceEnabled() const
{
return d->isCollisionAvoidanceEnabled;
}
const QPair PieDiagram::calculateDataBoundaries () const
{
if ( !checkInvariants( true ) || model()->rowCount() < 1 ) return QPair( QPointF( 0, 0 ), QPointF( 0, 0 ) );
const PieAttributes attrs( pieAttributes() );
QPointF bottomLeft( QPointF( 0, 0 ) );
QPointF topRight;
// If we explode, we need extra space for the slice that has the largest explosion distance.
if ( attrs.explode() ) {
const int colCount = columnCount();
qreal maxExplode = 0.0;
for ( int j = 0; j < colCount; ++j ) {
const PieAttributes columnAttrs( pieAttributes( model()->index( 0, j, rootIndex() ) ) ); // checked
maxExplode = qMax( maxExplode, columnAttrs.explodeFactor() );
}
topRight = QPointF( 1.0 + maxExplode, 1.0 + maxExplode );
} else {
topRight = QPointF( 1.0, 1.0 );
}
return QPair ( bottomLeft, topRight );
}
void PieDiagram::paintEvent( QPaintEvent* )
{
QPainter painter ( viewport() );
PaintContext ctx;
ctx.setPainter ( &painter );
ctx.setRectangle( QRectF ( 0, 0, width(), height() ) );
paint ( &ctx );
}
void PieDiagram::resizeEvent( QResizeEvent* )
{
}
void PieDiagram::resize( const QSizeF& size )
{
AbstractPieDiagram::resize(size);
}
void PieDiagram::paint( PaintContext* ctx )
{
// Painting is a two stage process
// In the first stage we figure out how much space is needed
// for text labels.
// In the second stage, we make use of that information and
// perform the actual painting.
placeLabels( ctx );
paintInternal( ctx );
}
void PieDiagram::calcSliceAngles()
{
// determine slice positions and sizes
const qreal sum = valueTotals();
const qreal sectorsPerValue = 360.0 / sum;
const PolarCoordinatePlane* plane = polarCoordinatePlane();
qreal currentValue = plane ? plane->startPosition() : 0.0;
const int colCount = columnCount();
d->startAngles.resize( colCount );
d->angleLens.resize( colCount );
bool atLeastOneValue = false; // guard against completely empty tables
for ( int iColumn = 0; iColumn < colCount; ++iColumn ) {
bool isOk;
const qreal cellValue = qAbs( model()->data( model()->index( 0, iColumn, rootIndex() ) ) // checked
.toReal( &isOk ) );
// toReal() returns 0.0 if there was no value or a non-numeric value
atLeastOneValue = atLeastOneValue || isOk;
d->startAngles[ iColumn ] = currentValue;
d->angleLens[ iColumn ] = cellValue * sectorsPerValue;
currentValue = d->startAngles[ iColumn ] + d->angleLens[ iColumn ];
}
// If there was no value at all, this is the sign for other code to bail out
if ( !atLeastOneValue ) {
d->startAngles.clear();
d->angleLens.clear();
}
}
void PieDiagram::calcPieSize( const QRectF &contentsRect )
{
d->size = qMin( contentsRect.width(), contentsRect.height() );
// if any slice explodes, the whole pie needs additional space so we make the basic size smaller
qreal maxExplode = 0.0;
const int colCount = columnCount();
for ( int j = 0; j < colCount; ++j ) {
const PieAttributes columnAttrs( pieAttributes( model()->index( 0, j, rootIndex() ) ) ); // checked
maxExplode = qMax( maxExplode, columnAttrs.explodeFactor() );
}
d->size /= ( 1.0 + 1.0 * maxExplode );
if ( d->size < 0.0 ) {
d->size = 0;
}
}
// this is the rect of the top surface of the pie, i.e. excluding the "3D" rim effect.
QRectF PieDiagram::twoDPieRect( const QRectF &contentsRect, const ThreeDPieAttributes& threeDAttrs ) const
{
QRectF pieRect;
if ( !threeDAttrs.isEnabled() ) {
qreal x = ( contentsRect.width() - d->size ) / 2.0;
qreal y = ( contentsRect.height() - d->size ) / 2.0;
pieRect = QRectF( contentsRect.left() + x, contentsRect.top() + y, d->size, d->size );
} else {
// threeD: width is the maximum possible width; height is 1/2 of that
qreal sizeFor3DEffect = 0.0;
qreal x = ( contentsRect.width() - d->size ) / 2.0;
qreal height = d->size;
// make sure that the height plus the threeDheight is not more than the
// available size
if ( threeDAttrs.depth() >= 0.0 ) {
// positive pie height: absolute value
sizeFor3DEffect = threeDAttrs.depth();
height = d->size - sizeFor3DEffect;
} else {
// negative pie height: relative value
sizeFor3DEffect = - threeDAttrs.depth() / 100.0 * height;
height = d->size - sizeFor3DEffect;
}
qreal y = ( contentsRect.height() - height - sizeFor3DEffect ) / 2.0;
pieRect = QRectF( contentsRect.left() + x, contentsRect.top() + y, d->size, height );
}
return pieRect;
}
void PieDiagram::placeLabels( PaintContext* paintContext )
{
if ( !checkInvariants(true) || model()->rowCount() < 1 ) {
return;
}
if ( paintContext->rectangle().isEmpty() || valueTotals() == 0.0 ) {
return;
}
const ThreeDPieAttributes threeDAttrs( threeDPieAttributes() );
const int colCount = columnCount();
d->reverseMapper.clear(); // on first call, this sets up the internals of the ReverseMapper.
calcSliceAngles();
if ( d->startAngles.isEmpty() ) {
return;
}
calcPieSize( paintContext->rectangle() );
// keep resizing the pie until the labels and the pie fit into paintContext->rectangle()
bool tryAgain = true;
while ( tryAgain ) {
tryAgain = false;
QRectF pieRect = twoDPieRect( paintContext->rectangle(), threeDAttrs );
d->forgetAlreadyPaintedDataValues();
d->labelPaintCache.clear();
for ( int slice = 0; slice < colCount; slice++ ) {
if ( d->angleLens[ slice ] != 0.0 ) {
const QRectF explodedPieRect = explodedDrawPosition( pieRect, slice );
addSliceLabel( &d->labelPaintCache, explodedPieRect, slice );
}
}
QRectF textBoundingRect;
d->paintDataValueTextsAndMarkers( paintContext, d->labelPaintCache, false, true,
&textBoundingRect );
if ( d->isCollisionAvoidanceEnabled ) {
shuffleLabels( &textBoundingRect );
}
if ( !textBoundingRect.isEmpty() && d->size > 0.0 ) {
const QRectF &clipRect = paintContext->rectangle();
// see by how many pixels the text is clipped on each side
qreal right = qMax( qreal( 0.0 ), textBoundingRect.right() - clipRect.right() );
qreal left = qMax( qreal( 0.0 ), clipRect.left() - textBoundingRect.left() );
// attention here - y coordinates in Qt are inverted compared to the convention in maths
qreal top = qMax( qreal( 0.0 ), clipRect.top() - textBoundingRect.top() );
qreal bottom = qMax( qreal( 0.0 ), textBoundingRect.bottom() - clipRect.bottom() );
qreal maxOverhang = qMax( qMax( right, left ), qMax( top, bottom ) );
if ( maxOverhang > 0.0 ) {
// subtract 2x as much because every side only gets half of the total diameter reduction
// and we have to make up for the overhang on one particular side.
d->size -= qMin( d->size, maxOverhang * 2.0 );
tryAgain = true;
}
}
}
}
static int wraparound( int i, int size )
{
while ( i < 0 ) {
i += size;
}
while ( i >= size ) {
i -= size;
}
return i;
}
//#define SHUFFLE_DEBUG
void PieDiagram::shuffleLabels( QRectF* textBoundingRect )
{
// things that could be improved here:
// - use a variable number (chosen using angle information) of neighbors to check
// - try harder to arrange the labels to look nice
// ideas:
// - leave labels that don't collide alone (only if they their offset is zero)
// - use a graphics view for collision detection
LabelPaintCache& lpc = d->labelPaintCache;
const int n = lpc.paintReplay.size();
bool modified = false;
qreal direction = 5.0;
QVector< qreal > offsets;
offsets.fill( 0.0, n );
for ( bool lastRoundModified = true; lastRoundModified; ) {
lastRoundModified = false;
for ( int i = 0; i < n; i++ ) {
const int neighborsToCheck = qMax( 10, lpc.paintReplay.size() - 1 );
const int minComp = wraparound( i - neighborsToCheck / 2, n );
const int maxComp = wraparound( i + ( neighborsToCheck + 1 ) / 2, n );
QPainterPath& path = lpc.paintReplay[ i ].labelArea;
for ( int j = minComp; j != maxComp; j = wraparound( j + 1, n ) ) {
if ( i == j ) {
continue;
}
QPainterPath& otherPath = lpc.paintReplay[ j ].labelArea;
while ( ( offsets[ i ] + direction > 0 ) && otherPath.intersects( path ) ) {
#ifdef SHUFFLE_DEBUG
qDebug() << "collision involving" << j << "and" << i << " -- n =" << n;
TextAttributes ta = lpc.paintReplay[ i ].attrs.textAttributes();
ta.setPen( QPen( Qt::white ) );
lpc.paintReplay[ i ].attrs.setTextAttributes( ta );
#endif
uint slice = lpc.paintReplay[ i ].index.column();
qreal angle = DEGTORAD( d->startAngles[ slice ] + d->angleLens[ slice ] / 2.0 );
qreal dx = cos( angle ) * direction;
qreal dy = -sin( angle ) * direction;
offsets[ i ] += direction;
path.translate( dx, dy );
lastRoundModified = true;
}
}
}
direction *= -1.07; // this can "overshoot", but avoids getting trapped in local minimums
modified = modified || lastRoundModified;
}
if ( modified ) {
for ( int i = 0; i < lpc.paintReplay.size(); i++ ) {
*textBoundingRect |= lpc.paintReplay[ i ].labelArea.boundingRect();
}
}
}
static QPolygonF polygonFromPainterPath( const QPainterPath &pp )
{
QPolygonF ret;
for ( int i = 0; i < pp.elementCount(); i++ ) {
const QPainterPath::Element& el = pp.elementAt( i );
Q_ASSERT( el.type == QPainterPath::MoveToElement || el.type == QPainterPath::LineToElement );
ret.append( el );
}
return ret;
}
// you can call it "normalizedProjectionLength" if you like
static qreal normProjection( const QLineF &l1, const QLineF &l2 )
{
const qreal dotProduct = l1.dx() * l2.dx() + l1.dy() * l2.dy();
return qAbs( dotProduct / ( l1.length() * l2.length() ) );
}
static QLineF labelAttachmentLine( const QPointF ¢er, const QPointF &start, const QPainterPath &label )
{
Q_ASSERT ( label.elementCount() == 5 );
// start is assumed to lie on the outer rim of the slice(!), making it possible to derive the
// radius of the pie
const qreal pieRadius = QLineF( center, start ).length();
// don't draw a line at all when the label is connected to its slice due to at least one of its
// corners falling inside the slice.
for ( int i = 0; i < 4; i++ ) { // point 4 is just a duplicate of point 0
if ( QLineF( label.elementAt( i ), center ).length() < pieRadius ) {
return QLineF();
}
}
// find the closest edge in the polygon, and its two neighbors
QPointF closeCorners[3];
{
QPointF closest = QPointF( 1000000, 1000000 );
int closestIndex = 0; // better misbehave than crash
for ( int i = 0; i < 4; i++ ) { // point 4 is just a duplicate of point 0
QPointF p = label.elementAt( i );
if ( QLineF( p, center ).length() < QLineF( closest, center ).length() ) {
closest = p;
closestIndex = i;
}
}
closeCorners[ 0 ] = label.elementAt( wraparound( closestIndex - 1, 4 ) );
closeCorners[ 1 ] = closest;
closeCorners[ 2 ] = label.elementAt( wraparound( closestIndex + 1, 4 ) );
}
QLineF edge1 = QLineF( closeCorners[ 0 ], closeCorners[ 1 ] );
QLineF edge2 = QLineF( closeCorners[ 1 ], closeCorners[ 2 ] );
QLineF connection1 = QLineF( ( closeCorners[ 0 ] + closeCorners[ 1 ] ) / 2.0, center );
QLineF connection2 = QLineF( ( closeCorners[ 1 ] + closeCorners[ 2 ] ) / 2.0, center );
QLineF ret;
// prefer the connecting line meeting its edge at a more perpendicular angle
if ( normProjection( edge1, connection1 ) < normProjection( edge2, connection2 ) ) {
ret = connection1;
} else {
ret = connection2;
}
// This tends to look a bit better than not doing it *shrug*
ret.setP2( ( start + center ) / 2.0 );
// make the line end at the rim of the slice (not 100% accurate because the line is not precisely radial)
qreal p1Radius = QLineF( ret.p1(), center ).length();
ret.setLength( p1Radius - pieRadius );
return ret;
}
void PieDiagram::paintInternal( PaintContext* paintContext )
{
// note: Not having any data model assigned is no bug
// but we can not draw a diagram then either.
if ( !checkInvariants( true ) || model()->rowCount() < 1 ) {
return;
}
if ( d->startAngles.isEmpty() || paintContext->rectangle().isEmpty() || valueTotals() == 0.0 ) {
return;
}
const ThreeDPieAttributes threeDAttrs( threeDPieAttributes() );
const int colCount = columnCount();
// Paint from back to front ("painter's algorithm") - first draw the backmost slice,
// then the slices on the left and right from back to front, then the frontmost one.
QRectF pieRect = twoDPieRect( paintContext->rectangle(), threeDAttrs );
const int backmostSlice = findSliceAt( 90, colCount );
const int frontmostSlice = findSliceAt( 270, colCount );
int currentLeftSlice = backmostSlice;
int currentRightSlice = backmostSlice;
drawSlice( paintContext->painter(), pieRect, backmostSlice );
if ( backmostSlice == frontmostSlice ) {
const int rightmostSlice = findSliceAt( 0, colCount );
const int leftmostSlice = findSliceAt( 180, colCount );
if ( backmostSlice == leftmostSlice ) {
currentLeftSlice = findLeftSlice( currentLeftSlice, colCount );
}
if ( backmostSlice == rightmostSlice ) {
currentRightSlice = findRightSlice( currentRightSlice, colCount );
}
}
while ( currentLeftSlice != frontmostSlice ) {
if ( currentLeftSlice != backmostSlice ) {
drawSlice( paintContext->painter(), pieRect, currentLeftSlice );
}
currentLeftSlice = findLeftSlice( currentLeftSlice, colCount );
}
while ( currentRightSlice != frontmostSlice ) {
if ( currentRightSlice != backmostSlice ) {
drawSlice( paintContext->painter(), pieRect, currentRightSlice );
}
currentRightSlice = findRightSlice( currentRightSlice, colCount );
}
// if the backmost slice is not the frontmost slice, we draw the frontmost one last
if ( backmostSlice != frontmostSlice || ! threeDPieAttributes().isEnabled() ) {
drawSlice( paintContext->painter(), pieRect, frontmostSlice );
}
d->paintDataValueTextsAndMarkers( paintContext, d->labelPaintCache, false, false );
// it's safer to do this at the beginning of placeLabels, but we can save some memory here.
d->forgetAlreadyPaintedDataValues();
// ### maybe move this into AbstractDiagram, also make ReverseMapper deal better with multiple polygons
const QPointF center = paintContext->rectangle().center();
const PainterSaver painterSaver( paintContext->painter() );
paintContext->painter()->setBrush( Qt::NoBrush );
Q_FOREACH( const LabelPaintInfo &pi, d->labelPaintCache.paintReplay ) {
// we expect the PainterPath to be a rectangle
if ( pi.labelArea.elementCount() != 5 ) {
continue;
}
paintContext->painter()->setPen( pen( pi.index ) );
if ( d->labelDecorations & LineFromSliceDecoration ) {
paintContext->painter()->drawLine( labelAttachmentLine( center, pi.markerPos, pi.labelArea ) );
}
if ( d->labelDecorations & FrameDecoration ) {
paintContext->painter()->drawPath( pi.labelArea );
}
d->reverseMapper.addPolygon( pi.index.row(), pi.index.column(),
polygonFromPainterPath( pi.labelArea ) );
}
d->labelPaintCache.clear();
d->startAngles.clear();
d->angleLens.clear();
}
#if defined ( Q_OS_WIN)
#define trunc(x) ((int)(x))
#endif
QRectF PieDiagram::explodedDrawPosition( const QRectF& drawPosition, uint slice ) const
{
const QModelIndex index( model()->index( 0, slice, rootIndex() ) ); // checked
const PieAttributes attrs( pieAttributes( index ) );
QRectF adjustedDrawPosition = drawPosition;
if ( attrs.explode() ) {
qreal startAngle = d->startAngles[ slice ];
qreal angleLen = d->angleLens[ slice ];
qreal explodeAngle = ( DEGTORAD( startAngle + angleLen / 2.0 ) );
qreal explodeDistance = attrs.explodeFactor() * d->size / 2.0;
adjustedDrawPosition.translate( explodeDistance * cos( explodeAngle ),
explodeDistance * - sin( explodeAngle ) );
}
return adjustedDrawPosition;
}
-/**
- Internal method that draws one of the slices in a pie chart.
-
- \param painter the QPainter to draw in
- \param dataset the dataset to draw the pie for
- \param slice the slice to draw
- \param threeDPieHeight the height of the three dimensional effect
- */
void PieDiagram::drawSlice( QPainter* painter, const QRectF& drawPosition, uint slice)
{
// Is there anything to draw at all?
if ( d->angleLens[ slice ] == 0.0 ) {
return;
}
const QRectF adjustedDrawPosition = explodedDrawPosition( drawPosition, slice );
draw3DEffect( painter, adjustedDrawPosition, slice );
drawSliceSurface( painter, adjustedDrawPosition, slice );
}
-/**
- Internal method that draws the surface of one of the slices in a pie chart.
-
- \param painter the QPainter to draw in
- \param dataset the dataset to draw the slice for
- \param slice the slice to draw
- */
void PieDiagram::drawSliceSurface( QPainter* painter, const QRectF& drawPosition, uint slice )
{
// Is there anything to draw at all?
const qreal angleLen = d->angleLens[ slice ];
const qreal startAngle = d->startAngles[ slice ];
const QModelIndex index( model()->index( 0, slice, rootIndex() ) ); // checked
const PieAttributes attrs( pieAttributes( index ) );
const ThreeDPieAttributes threeDAttrs( threeDPieAttributes( index ) );
painter->setRenderHint ( QPainter::Antialiasing );
QBrush br = brush( index );
if ( threeDAttrs.isEnabled() ) {
br = threeDAttrs.threeDBrush( br, drawPosition );
}
painter->setBrush( br );
QPen pen = this->pen( index );
if ( threeDAttrs.isEnabled() ) {
pen.setColor( Qt::black );
}
painter->setPen( pen );
if ( angleLen == 360 ) {
// full circle, avoid nasty line in the middle
painter->drawEllipse( drawPosition );
//Add polygon to Reverse mapper for showing tool tips.
QPolygonF poly( drawPosition );
d->reverseMapper.addPolygon( index.row(), index.column(), poly );
} else {
// draw the top of this piece
// Start with getting the points for the arc.
const int arcPoints = static_cast(trunc( angleLen / granularity() ));
QPolygonF poly( arcPoints + 2 );
qreal degree = 0.0;
int iPoint = 0;
bool perfectMatch = false;
while ( degree <= angleLen ) {
poly[ iPoint ] = pointOnEllipse( drawPosition, startAngle + degree );
//qDebug() << degree << angleLen << poly[ iPoint ];
perfectMatch = ( degree == angleLen );
degree += granularity();
++iPoint;
}
// if necessary add one more point to fill the last small gap
if ( !perfectMatch ) {
poly[ iPoint ] = pointOnEllipse( drawPosition, startAngle + angleLen );
// add the center point of the piece
poly.append( drawPosition.center() );
} else {
poly[ iPoint ] = drawPosition.center();
}
//find the value and paint it
//fix value position
d->reverseMapper.addPolygon( index.row(), index.column(), poly );
painter->drawPolygon( poly );
}
}
// calculate the position points for the label and pass them to addLabel()
void PieDiagram::addSliceLabel( LabelPaintCache* lpc, const QRectF& drawPosition, uint slice )
{
const qreal angleLen = d->angleLens[ slice ];
const qreal startAngle = d->startAngles[ slice ];
const QModelIndex index( model()->index( 0, slice, rootIndex() ) ); // checked
const qreal sum = valueTotals();
// Position points are calculated relative to the slice.
// They are calculated as if the slice was 'standing' on its tip and the rim was up,
// so North is the middle (also highest part) of the rim and South is the tip of the slice.
const QPointF south = drawPosition.center();
const QPointF southEast = south;
const QPointF southWest = south;
const QPointF north = pointOnEllipse( drawPosition, startAngle + angleLen / 2.0 );
const QPointF northEast = pointOnEllipse( drawPosition, startAngle );
const QPointF northWest = pointOnEllipse( drawPosition, startAngle + angleLen );
QPointF center = ( south + north ) / 2.0;
const QPointF east = ( south + northEast ) / 2.0;
const QPointF west = ( south + northWest ) / 2.0;
PositionPoints points( center, northWest, north, northEast, east, southEast, south, southWest, west );
qreal topAngle = startAngle - 90;
if ( topAngle < 0.0 ) {
topAngle += 360.0;
}
points.setDegrees( KChartEnums::PositionEast, topAngle );
points.setDegrees( KChartEnums::PositionNorthEast, topAngle );
points.setDegrees( KChartEnums::PositionWest, topAngle + angleLen );
points.setDegrees( KChartEnums::PositionNorthWest, topAngle + angleLen );
points.setDegrees( KChartEnums::PositionCenter, topAngle + angleLen / 2.0 );
points.setDegrees( KChartEnums::PositionNorth, topAngle + angleLen / 2.0 );
qreal favoriteTextAngle = 0.0;
if ( autoRotateLabels() ) {
favoriteTextAngle = - ( startAngle + angleLen / 2 ) + 90.0;
while ( favoriteTextAngle <= 0.0 ) {
favoriteTextAngle += 360.0;
}
// flip the label when upside down
if ( favoriteTextAngle > 90.0 && favoriteTextAngle < 270.0 ) {
favoriteTextAngle = favoriteTextAngle - 180.0;
}
// negative angles can have special meaning in addLabel; otherwise they work fine
if ( favoriteTextAngle <= 0.0 ) {
favoriteTextAngle += 360.0;
}
}
d->addLabel( lpc, index, nullptr, points, Position::Center, Position::Center,
angleLen * sum / 360, favoriteTextAngle );
}
static bool doSpansOverlap( qreal s1Start, qreal s1End, qreal s2Start, qreal s2End )
{
if ( s1Start < s2Start ) {
return s1End >= s2Start;
} else {
return s1Start <= s2End;
}
}
static bool doArcsOverlap( qreal a1Start, qreal a1End, qreal a2Start, qreal a2End )
{
Q_ASSERT( a1Start >= 0 && a1Start <= 360 && a1End >= 0 && a1End <= 360 &&
a2Start >= 0 && a2Start <= 360 && a2End >= 0 && a2End <= 360 );
// all of this could probably be done better...
if ( a1End < a1Start ) {
a1End += 360;
}
if ( a2End < a2Start ) {
a2End += 360;
}
if ( doSpansOverlap( a1Start, a1End, a2Start, a2End ) ) {
return true;
}
if ( a1Start > a2Start ) {
return doSpansOverlap( a1Start - 360.0, a1End - 360.0, a2Start, a2End );
} else {
return doSpansOverlap( a1Start + 360.0, a1End + 360.0, a2Start, a2End );
}
}
-/**
- Internal method that draws the shadow creating the 3D effect of a pie
-
- \param painter the QPainter to draw in
- \param drawPosition the position to draw at
- \param slice the slice to draw the shadow for
- */
void PieDiagram::draw3DEffect( QPainter* painter, const QRectF& drawPosition, uint slice )
{
const QModelIndex index( model()->index( 0, slice, rootIndex() ) ); // checked
const ThreeDPieAttributes threeDAttrs( threeDPieAttributes( index ) );
if ( ! threeDAttrs.isEnabled() ) {
return;
}
// NOTE: We cannot optimize away drawing some of the effects (even
// when not exploding), because some of the pies might be left out
// in future versions which would make some of the normally hidden
// pies visible. Complex hidden-line algorithms would be much more
// expensive than just drawing for nothing.
// No need to save the brush, will be changed on return from this
// method anyway.
const QBrush brush = this->brush( model()->index( 0, slice, rootIndex() ) ); // checked
if ( threeDAttrs.useShadowColors() ) {
painter->setBrush( QBrush( brush.color().darker() ) );
} else {
painter->setBrush( brush );
}
qreal startAngle = d->startAngles[ slice ];
qreal endAngle = startAngle + d->angleLens[ slice ];
// Normalize angles
while ( startAngle >= 360 )
startAngle -= 360;
while ( endAngle >= 360 )
endAngle -= 360;
Q_ASSERT( startAngle >= 0 && startAngle <= 360 );
Q_ASSERT( endAngle >= 0 && endAngle <= 360 );
// positive pie height: absolute value
// negative pie height: relative value
const int depth = threeDAttrs.depth() >= 0.0 ? threeDAttrs.depth() : -threeDAttrs.depth() / 100.0 * drawPosition.height();
if ( startAngle == endAngle || startAngle == endAngle - 360 ) { // full circle
draw3dOuterRim( painter, drawPosition, depth, 180, 360 );
} else {
if ( doArcsOverlap( startAngle, endAngle, 180, 360 ) ) {
draw3dOuterRim( painter, drawPosition, depth, startAngle, endAngle );
}
if ( startAngle >= 270 || startAngle <= 90 ) {
draw3dCutSurface( painter, drawPosition, depth, startAngle );
}
if ( endAngle >= 90 && endAngle <= 270 ) {
draw3dCutSurface( painter, drawPosition, depth, endAngle );
}
}
}
-/**
- Internal method that draws the cut surface of a slice (think of a real pie cut into slices)
- in 3D mode, for surfaces that are facing the observer.
-
- \param painter the QPainter to draw in
- \param rect the position to draw at
- \param threeDHeight the height of the shadow
- \param angle the angle of the segment
- */
void PieDiagram::draw3dCutSurface( QPainter* painter,
const QRectF& rect,
qreal threeDHeight,
qreal angle )
{
QPolygonF poly( 4 );
const QPointF center = rect.center();
const QPointF circlePoint = pointOnEllipse( rect, angle );
poly[0] = center;
poly[1] = circlePoint;
poly[2] = QPointF( circlePoint.x(), circlePoint.y() + threeDHeight );
poly[3] = QPointF( center.x(), center.y() + threeDHeight );
// TODO: add polygon to ReverseMapper
painter->drawPolygon( poly );
}
-/**
- Internal method that draws the outer rim of a slice when the rim is facing the observer.
-
- \param painter the QPainter to draw in
- \param rect the position to draw at
- \param threeDHeight the height of the shadow
- \param startAngle the starting angle of the segment
- \param endAngle the ending angle of the segment
- */
void PieDiagram::draw3dOuterRim( QPainter* painter,
const QRectF& rect,
qreal threeDHeight,
qreal startAngle,
qreal endAngle )
{
// Start with getting the points for the inner arc.
if ( endAngle < startAngle ) {
endAngle += 360;
}
startAngle = qMax( startAngle, qreal( 180.0 ) );
endAngle = qMin( endAngle, qreal( 360.0 ) );
int numHalfPoints = trunc( ( endAngle - startAngle ) / granularity() ) + 1;
if ( numHalfPoints < 2 ) {
return;
}
QPolygonF poly( numHalfPoints );
qreal degree = endAngle;
int iPoint = 0;
bool perfectMatch = false;
while ( degree >= startAngle ) {
poly[ numHalfPoints - iPoint - 1 ] = pointOnEllipse( rect, degree );
perfectMatch = (degree == startAngle);
degree -= granularity();
++iPoint;
}
// if necessary add one more point to fill the last small gap
if ( !perfectMatch ) {
poly.prepend( pointOnEllipse( rect, startAngle ) );
++numHalfPoints;
}
poly.resize( numHalfPoints * 2 );
// Now copy these arcs again into the final array, but in the
// opposite direction and moved down by the 3D height.
for ( int i = numHalfPoints - 1; i >= 0; --i ) {
QPointF pointOnFirstArc( poly[ i ] );
pointOnFirstArc.setY( pointOnFirstArc.y() + threeDHeight );
poly[ numHalfPoints * 2 - i - 1 ] = pointOnFirstArc;
}
// TODO: Add polygon to ReverseMapper
painter->drawPolygon( poly );
}
-/**
- Internal method that finds the slice that is located at the position specified by \c angle.
-
- \param angle the angle at which to search for a slice
- \return the number of the slice found
- */
uint PieDiagram::findSliceAt( qreal angle, int colCount )
{
for ( int i = 0; i < colCount; ++i ) {
qreal endseg = d->startAngles[ i ] + d->angleLens[ i ];
if ( d->startAngles[ i ] <= angle && endseg >= angle ) {
return i;
}
}
// If we have not found it, try wrap around
// but only if the current searched angle is < 360 degree
if ( angle < 360 )
return findSliceAt( angle + 360, colCount );
// otherwise - what ever went wrong - we return 0
return 0;
}
-/**
- Internal method that finds the slice that is located to the left of \c slice.
-
- \param slice the slice to start the search from
- \return the number of the pie to the left of \c pie
- */
uint PieDiagram::findLeftSlice( uint slice, int colCount )
{
if ( slice == 0 ) {
if ( colCount > 1 ) {
return colCount - 1;
} else {
return 0;
}
} else {
return slice - 1;
}
}
-/**
- Internal method that finds the slice that is located to the right of \c slice.
-
- \param slice the slice to start the search from
- \return the number of the slice to the right of \c slice
- */
uint PieDiagram::findRightSlice( uint slice, int colCount )
{
int rightSlice = slice + 1;
if ( rightSlice == colCount ) {
rightSlice = 0;
}
return rightSlice;
}
-/**
- * Auxiliary method returning a point to a given boundary
- * rectangle of the enclosed ellipse and an angle.
- */
QPointF PieDiagram::pointOnEllipse( const QRectF& boundingBox, qreal angle )
{
qreal angleRad = DEGTORAD( angle );
qreal cosAngle = cos( angleRad );
qreal sinAngle = -sin( angleRad );
qreal posX = cosAngle * boundingBox.width() / 2.0;
qreal posY = sinAngle * boundingBox.height() / 2.0;
return QPointF( posX + boundingBox.center().x(),
posY + boundingBox.center().y() );
}
/*virtual*/
qreal PieDiagram::valueTotals() const
{
if ( !model() )
return 0;
const int colCount = columnCount();
qreal total = 0.0;
// non-empty models need a row with data
Q_ASSERT( colCount == 0 || model()->rowCount() >= 1 );
for ( int j = 0; j < colCount; ++j ) {
total += qAbs(model()->data( model()->index( 0, j, rootIndex() ) ).toReal()); // checked
}
return total;
}
/*virtual*/
qreal PieDiagram::numberOfValuesPerDataset() const
{
return model() ? model()->columnCount( rootIndex() ) : 0.0;
}
/*virtual*/
qreal PieDiagram::numberOfGridRings() const
{
return 1;
}
diff --git a/src/KChart/Polar/KChartPieDiagram.h b/src/KChart/Polar/KChartPieDiagram.h
index e4b1105..cf7dae3 100644
--- a/src/KChart/Polar/KChartPieDiagram.h
+++ b/src/KChart/Polar/KChartPieDiagram.h
@@ -1,123 +1,198 @@
/*
* Copyright (C) 2001-2015 Klaralvdalens Datakonsult AB. All rights reserved.
*
* This file is part of the KD Chart library.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation; either version 2 of
* the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see .
*/
#ifndef KCHARTPIEDIAGRAM_H
#define KCHARTPIEDIAGRAM_H
#include "KChartAbstractPieDiagram.h"
namespace KChart {
class LabelPaintCache;
/**
* @brief PieDiagram defines a common pie diagram
*/
class KCHART_EXPORT PieDiagram : public AbstractPieDiagram
{
Q_OBJECT
Q_DISABLE_COPY( PieDiagram )
KCHART_DECLARE_DERIVED_DIAGRAM( PieDiagram, PolarCoordinatePlane )
public:
explicit PieDiagram(
QWidget* parent = nullptr, PolarCoordinatePlane* plane = nullptr );
virtual ~PieDiagram();
protected:
// Implement AbstractDiagram
/** \reimpl */
void paint( PaintContext* paintContext ) override;
public:
/**
* Describes which decorations are painted around data labels.
*/
enum LabelDecoration {
NoDecoration = 0, ///< No decoration
FrameDecoration = 1, ///< A rectangular frame is painted around the label text
LineFromSliceDecoration = 2 ///< A line is drawn from the pie slice to its label
};
Q_DECLARE_FLAGS( LabelDecorations, LabelDecoration )
/// Set the decorations to be painted around data labels according to @p decorations.
void setLabelDecorations( LabelDecorations decorations );
/// Return the decorations to be painted around data labels.
LabelDecorations labelDecorations() const;
/// If @p enabled is set to true, labels that would overlap will be shuffled to avoid overlap.
/// \note Collision avoidance may allow labels to be closer than AbstractDiagram with
/// allowOverlappingDataValueTexts() == false, so you should usually also call
/// setAllowOverlappingDataValueTexts( true ) if you enable this feature.
void setLabelCollisionAvoidanceEnabled( bool enabled );
/// Return whether overlapping labels will be moved to until they don't overlap anymore.
bool isLabelCollisionAvoidanceEnabled() const;
/** \reimpl */
void resize ( const QSizeF& area ) override;
// Implement AbstractPolarDiagram
/** \reimpl */
qreal valueTotals () const override;
/** \reimpl */
qreal numberOfValuesPerDataset() const override;
/** \reimpl */
qreal numberOfGridRings() const override;
- virtual PieDiagram * clone() const;
+
+ /**
+ * Creates an exact copy of this diagram.
+ */
+ virtual PieDiagram * clone() const;
protected:
/** \reimpl */
const QPair calculateDataBoundaries() const override;
void paintEvent( QPaintEvent* ) override;
void resizeEvent( QResizeEvent* ) override;
private:
// ### move to private class?
void placeLabels( PaintContext* paintContext );
// Solve problems with label overlap by changing label positions inside d->labelPaintCache.
void shuffleLabels( QRectF* textBoundingRect );
void paintInternal( PaintContext* paintContext );
+
+ /**
+ Internal method that draws one of the slices in a pie chart.
+
+ \param painter the QPainter to draw in
+ \param dataset the dataset to draw the pie for
+ \param slice the slice to draw
+ \param threeDPieHeight the height of the three dimensional effect
+ */
void drawSlice( QPainter* painter, const QRectF& drawPosition, uint slice );
+
+ /**
+ Internal method that draws the surface of one of the slices in a pie chart.
+
+ \param painter the QPainter to draw in
+ \param dataset the dataset to draw the slice for
+ \param slice the slice to draw
+ */
void drawSliceSurface( QPainter* painter, const QRectF& drawPosition, uint slice );
void addSliceLabel( LabelPaintCache* lpc, const QRectF& drawPosition, uint slice );
+
+ /**
+ Internal method that draws the shadow creating the 3D effect of a pie
+
+ \param painter the QPainter to draw in
+ \param drawPosition the position to draw at
+ \param slice the slice to draw the shadow for
+ */
void draw3DEffect( QPainter* painter, const QRectF& drawPosition, uint slice );
+
+ /**
+ Internal method that draws the cut surface of a slice (think of a real pie cut into slices)
+ in 3D mode, for surfaces that are facing the observer.
+
+ \param painter the QPainter to draw in
+ \param rect the position to draw at
+ \param threeDHeight the height of the shadow
+ \param angle the angle of the segment
+ */
void draw3dCutSurface( QPainter* painter,
const QRectF& rect,
qreal threeDHeight,
qreal angle );
+
+ /**
+ Internal method that draws the outer rim of a slice when the rim is facing the observer.
+
+ \param painter the QPainter to draw in
+ \param rect the position to draw at
+ \param threeDHeight the height of the shadow
+ \param startAngle the starting angle of the segment
+ \param endAngle the ending angle of the segment
+ */
void draw3dOuterRim( QPainter* painter,
const QRectF& rect,
qreal threeDHeight,
qreal startAngle,
qreal endAngle );
void calcSliceAngles();
void calcPieSize( const QRectF &contentsRect );
QRectF twoDPieRect( const QRectF &contentsRect, const ThreeDPieAttributes& threeDAttrs ) const;
QRectF explodedDrawPosition( const QRectF& drawPosition, uint slice ) const;
+
+ /**
+ Internal method that finds the slice that is located at the position specified by \c angle.
+
+ \param angle the angle at which to search for a slice
+ \return the number of the slice found
+ */
uint findSliceAt( qreal angle, int columnCount );
+
+ /**
+ Internal method that finds the slice that is located to the left of \c slice.
+
+ \param slice the slice to start the search from
+ \return the number of the pie to the left of \c pie
+ */
uint findLeftSlice( uint slice, int columnCount );
+
+ /**
+ Internal method that finds the slice that is located to the right of \c slice.
+
+ \param slice the slice to start the search from
+ \return the number of the slice to the right of \c slice
+ */
uint findRightSlice( uint slice, int columnCount );
+
+ /**
+ * Auxiliary method returning a point to a given boundary
+ * rectangle of the enclosed ellipse and an angle.
+ */
QPointF pointOnEllipse( const QRectF& boundingBox, qreal angle );
}; // End of class KChartPieDiagram
Q_DECLARE_OPERATORS_FOR_FLAGS( PieDiagram::LabelDecorations )
}
#endif // KCHARTPIEDIAGRAM_H
diff --git a/src/KChart/Polar/KChartPolarDiagram.cpp b/src/KChart/Polar/KChartPolarDiagram.cpp
index 00cf49b..93c8835 100644
--- a/src/KChart/Polar/KChartPolarDiagram.cpp
+++ b/src/KChart/Polar/KChartPolarDiagram.cpp
@@ -1,306 +1,303 @@
/*
* Copyright (C) 2001-2015 Klaralvdalens Datakonsult AB. All rights reserved.
*
* This file is part of the KD Chart library.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation; either version 2 of
* the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see .
*/
#include "KChartPolarDiagram.h"
#include "KChartPolarDiagram_p.h"
#include "KChartPaintContext.h"
#include "KChartPainterSaver_p.h"
#include "KChartMath_p.h"
#include
using namespace KChart;
PolarDiagram::Private::Private() :
rotateCircularLabels( false ),
closeDatasets( false )
{
}
PolarDiagram::Private::~Private() {}
#define d d_func()
PolarDiagram::PolarDiagram( QWidget* parent, PolarCoordinatePlane* plane ) :
AbstractPolarDiagram( new Private( ), parent, plane )
{
//init();
}
PolarDiagram::~PolarDiagram()
{
}
void PolarDiagram::init()
{
setShowDelimitersAtPosition( Position::Unknown, false );
setShowDelimitersAtPosition( Position::Center, false );
setShowDelimitersAtPosition( Position::NorthWest, false );
setShowDelimitersAtPosition( Position::North, true );
setShowDelimitersAtPosition( Position::NorthEast, false );
setShowDelimitersAtPosition( Position::West, false );
setShowDelimitersAtPosition( Position::East, false );
setShowDelimitersAtPosition( Position::SouthWest, false );
setShowDelimitersAtPosition( Position::South, true );
setShowDelimitersAtPosition( Position::SouthEast, false );
setShowDelimitersAtPosition( Position::Floating, false );
setShowLabelsAtPosition( Position::Unknown, false );
setShowLabelsAtPosition( Position::Center, false );
setShowLabelsAtPosition( Position::NorthWest, false );
setShowLabelsAtPosition( Position::North, true );
setShowLabelsAtPosition( Position::NorthEast, false );
setShowLabelsAtPosition( Position::West, false );
setShowLabelsAtPosition( Position::East, false );
setShowLabelsAtPosition( Position::SouthWest, false );
setShowLabelsAtPosition( Position::South, true );
setShowLabelsAtPosition( Position::SouthEast, false );
setShowLabelsAtPosition( Position::Floating, false );
}
-/**
- * Creates an exact copy of this diagram.
- */
PolarDiagram * PolarDiagram::clone() const
{
PolarDiagram* newDiagram = new PolarDiagram( new Private( *d ) );
// This needs to be copied after the fact
newDiagram->d->showDelimitersAtPosition = d->showDelimitersAtPosition;
newDiagram->d->showLabelsAtPosition = d->showLabelsAtPosition;
newDiagram->d->rotateCircularLabels = d->rotateCircularLabels;
newDiagram->d->closeDatasets = d->closeDatasets;
return newDiagram;
}
const QPair PolarDiagram::calculateDataBoundaries () const
{
if ( !checkInvariants(true) ) return QPair( QPointF( 0, 0 ), QPointF( 0, 0 ) );
const int rowCount = model()->rowCount(rootIndex());
const int colCount = model()->columnCount(rootIndex());
qreal xMin = 0.0;
qreal xMax = colCount;
qreal yMin = 0, yMax = 0;
for ( int iCol=0; iColdata( model()->index( iRow, iCol, rootIndex() ) ).toReal(); // checked
yMax = qMax( yMax, value );
yMin = qMin( yMin, value );
}
}
QPointF bottomLeft ( QPointF( xMin, yMin ) );
QPointF topRight ( QPointF( xMax, yMax ) );
return QPair ( bottomLeft, topRight );
}
void PolarDiagram::paintEvent ( QPaintEvent*)
{
QPainter painter ( viewport() );
PaintContext ctx;
ctx.setPainter ( &painter );
ctx.setRectangle( QRectF ( 0, 0, width(), height() ) );
paint ( &ctx );
}
void PolarDiagram::resizeEvent ( QResizeEvent*)
{
}
void PolarDiagram::paintPolarMarkers( PaintContext* ctx, const QPolygonF& polygon )
{
Q_UNUSED(ctx);
Q_UNUSED(polygon);
// obsolete, since we are using real markers now!
}
void PolarDiagram::paint( PaintContext* ctx )
{
qreal dummy1, dummy2;
paint( ctx, true, dummy1, dummy2 );
paint( ctx, false, dummy1, dummy2 );
}
void PolarDiagram::paint( PaintContext* ctx,
bool calculateListAndReturnScale,
qreal& newZoomX, qreal& newZoomY )
{
// note: Not having any data model assigned is no bug
// but we can not draw a diagram then either.
if ( !checkInvariants(true) )
return;
d->reverseMapper.clear();
const int rowCount = model()->rowCount( rootIndex() );
const int colCount = model()->columnCount( rootIndex() );
if ( calculateListAndReturnScale ) {
// Check if all of the data value texts / data comments fit into the available space...
d->labelPaintCache.clear();
for ( int iCol = 0; iCol < colCount; ++iCol ) {
for ( int iRow=0; iRow < rowCount; ++iRow ) {
QModelIndex index = model()->index( iRow, iCol, rootIndex() ); // checked
const qreal value = model()->data( index ).toReal();
QPointF point = coordinatePlane()->translate(
QPointF( value, iRow ) ) + ctx->rectangle().topLeft();
//qDebug() << point;
d->addLabel( &d->labelPaintCache, index, nullptr, PositionPoints( point ),
Position::Center, Position::Center, value );
}
}
newZoomX = coordinatePlane()->zoomFactorX();
newZoomY = coordinatePlane()->zoomFactorY();
if ( d->labelPaintCache.paintReplay.count() ) {
// ...and zoom out if necessary
const qreal oldZoomX = newZoomX;
const qreal oldZoomY = newZoomY;
QRectF txtRectF;
d->paintDataValueTextsAndMarkers( ctx, d->labelPaintCache, true, true, &txtRectF );
const QRect txtRect = txtRectF.toRect();
const QRect curRect = coordinatePlane()->geometry();
const qreal gapX = qMin( txtRect.left() - curRect.left(), curRect.right() - txtRect.right() );
const qreal gapY = qMin( txtRect.top() - curRect.top(), curRect.bottom() - txtRect.bottom() );
if ( gapX < 0.0 ) {
newZoomX = oldZoomX * ( 1.0 + ( gapX - 1.0 ) / curRect.width() );
}
if ( gapY < 0.0 ) {
newZoomY = oldZoomY * ( 1.0 + ( gapY - 1.0 ) / curRect.height() );
}
}
} else {
// Paint the data sets
for ( int iCol = 0; iCol < colCount; ++iCol ) {
//TODO(khz): As of yet PolarDiagram can not show per-segment line attributes
// but it draws every polyline in one go - using one color.
// This needs to be enhanced to allow for cell-specific settings
// in the same way as LineDiagram does it.
QBrush brush = d->datasetAttrs( iCol, KChart::DatasetBrushRole ).value();
QPolygonF polygon;
for ( int iRow = 0; iRow < rowCount; ++iRow ) {
QModelIndex index = model()->index( iRow, iCol, rootIndex() ); // checked
const qreal value = model()->data( index ).toReal();
QPointF point = coordinatePlane()->translate( QPointF( value, iRow ) )
+ ctx->rectangle().topLeft();
polygon.append( point );
//qDebug() << point;
}
if ( closeDatasets() && !polygon.isEmpty() ) {
// close the circle by connecting the last data point to the first
polygon.append( polygon.first() );
}
PainterSaver painterSaver( ctx->painter() );
ctx->painter()->setRenderHint ( QPainter::Antialiasing );
ctx->painter()->setBrush( brush );
QPen p = d->datasetAttrs( iCol, KChart::DatasetPenRole ).value< QPen >();
if ( p.style() != Qt::NoPen )
{
ctx->painter()->setPen( PrintingParameters::scalePen( p ) );
ctx->painter()->drawPolyline( polygon );
}
}
d->paintDataValueTextsAndMarkers( ctx, d->labelPaintCache, true );
}
}
void PolarDiagram::resize ( const QSizeF& size )
{
AbstractPolarDiagram::resize(size);
}
/*virtual*/
qreal PolarDiagram::valueTotals () const
{
return model()->rowCount(rootIndex());
}
/*virtual*/
qreal PolarDiagram::numberOfValuesPerDataset() const
{
return model() ? model()->rowCount(rootIndex()) : 0.0;
}
/*virtual*/
qreal PolarDiagram::numberOfGridRings() const
{
return 5; // FIXME
}
void PolarDiagram::setZeroDegreePosition( int degrees )
{
Q_UNUSED( degrees );
qWarning() << "Deprecated PolarDiagram::setZeroDegreePosition() called, setting ignored.";
}
int PolarDiagram::zeroDegreePosition() const
{
qWarning() << "Deprecated PolarDiagram::zeroDegreePosition() called.";
return 0;
}
void PolarDiagram::setRotateCircularLabels( bool rotateCircularLabels )
{
d->rotateCircularLabels = rotateCircularLabels;
}
bool PolarDiagram::rotateCircularLabels() const
{
return d->rotateCircularLabels;
}
void PolarDiagram::setCloseDatasets( bool closeDatasets )
{
d->closeDatasets = closeDatasets;
}
bool PolarDiagram::closeDatasets() const
{
return d->closeDatasets;
}
void PolarDiagram::setShowDelimitersAtPosition( Position position,
bool showDelimiters )
{
d->showDelimitersAtPosition[position.value()] = showDelimiters;
}
void PolarDiagram::setShowLabelsAtPosition( Position position,
bool showLabels )
{
d->showLabelsAtPosition[position.value()] = showLabels;
}
bool PolarDiagram::showDelimitersAtPosition( Position position ) const
{
return d->showDelimitersAtPosition[position.value()];
}
bool PolarDiagram::showLabelsAtPosition( Position position ) const
{
return d->showLabelsAtPosition[position.value()];
}
diff --git a/src/KChart/Polar/KChartPolarDiagram.h b/src/KChart/Polar/KChartPolarDiagram.h
index cdc9e61..47cdeca 100644
--- a/src/KChart/Polar/KChartPolarDiagram.h
+++ b/src/KChart/Polar/KChartPolarDiagram.h
@@ -1,106 +1,110 @@
/*
* Copyright (C) 2001-2015 Klaralvdalens Datakonsult AB. All rights reserved.
*
* This file is part of the KD Chart library.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation; either version 2 of
* the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see .
*/
#ifndef KCHARTPOLARDIAGRAM_H
#define KCHARTPOLARDIAGRAM_H
#include "KChartPosition.h"
#include "KChartAbstractPolarDiagram.h"
QT_BEGIN_NAMESPACE
class QPolygonF;
QT_END_NAMESPACE
namespace KChart {
/**
* @brief PolarDiagram defines a common polar diagram
*/
class KCHART_EXPORT PolarDiagram : public AbstractPolarDiagram
{
Q_OBJECT
Q_DISABLE_COPY( PolarDiagram )
KCHART_DECLARE_DERIVED_DIAGRAM( PolarDiagram, PolarCoordinatePlane )
public:
explicit PolarDiagram(
QWidget* parent = nullptr, PolarCoordinatePlane* plane = nullptr );
virtual ~PolarDiagram();
protected:
// Implement AbstractDiagram
/** \reimpl */
void paint ( PaintContext* paintContext ) override;
public:
/** \reimpl */
void resize ( const QSizeF& area ) override;
// Implement AbstractPolarDiagram
/** \reimpl */
qreal valueTotals () const override;
/** \reimpl */
qreal numberOfValuesPerDataset() const override;
/** \reimpl */
qreal numberOfGridRings() const override;
- virtual PolarDiagram * clone() const;
+
+ /**
+ * Creates an exact copy of this diagram.
+ */
+ virtual PolarDiagram * clone() const;
/** \deprecated Use PolarCoordinatePlane::setStartPosition( qreal degrees ) instead. */
void setZeroDegreePosition( int degrees );
/** \deprecated Use qreal PolarCoordinatePlane::startPosition instead. */
int zeroDegreePosition() const;
void setRotateCircularLabels( bool rotateCircularLabels );
bool rotateCircularLabels() const;
/** Close each of the data series by connecting the last point to its
* respective start point
*/
void setCloseDatasets( bool closeDatasets );
bool closeDatasets() const;
void setShowDelimitersAtPosition( Position position,
bool showDelimiters );
void setShowLabelsAtPosition( Position position,
bool showLabels );
bool showDelimitersAtPosition( Position position ) const;
bool showLabelsAtPosition( Position position ) const;
virtual void paint ( PaintContext* paintContext,
bool calculateListAndReturnScale,
qreal& newZoomX, qreal& newZoomY ); // KChart 3: references -> pointers
protected:
/** \reimpl */
const QPair calculateDataBoundaries() const override;
void paintEvent ( QPaintEvent* ) override;
void resizeEvent ( QResizeEvent* ) override;
virtual void paintPolarMarkers( PaintContext* ctx, const QPolygonF& polygon );
}; // End of class PolarDiagram
}
#endif // KCHARTPOLARDIAGRAM_H
diff --git a/src/KChart/Polar/KChartRadarDiagram.cpp b/src/KChart/Polar/KChartRadarDiagram.cpp
index 5f17c48..d03dc24 100644
--- a/src/KChart/Polar/KChartRadarDiagram.cpp
+++ b/src/KChart/Polar/KChartRadarDiagram.cpp
@@ -1,335 +1,332 @@
/*
* Copyright (C) 2001-2015 Klaralvdalens Datakonsult AB. All rights reserved.
*
* This file is part of the KD Chart library.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation; either version 2 of
* the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see .
*/
#include "KChartRadarDiagram.h"
#include "KChartRadarDiagram_p.h"
#include "KChartPaintContext.h"
#include "KChartPainterSaver_p.h"
#include "KChartMath_p.h"
#include
using namespace KChart;
RadarDiagram::Private::Private() :
closeDatasets( false ),
reverseData( false ),
fillAlpha( 0.0 )
{
}
RadarDiagram::Private::~Private() {}
#define d d_func()
RadarDiagram::RadarDiagram( QWidget* parent, RadarCoordinatePlane* plane ) :
AbstractPolarDiagram( new Private( ), parent, plane )
{
//init();
}
RadarDiagram::~RadarDiagram()
{
}
void RadarDiagram::init()
{
}
-/**
- * Creates an exact copy of this diagram.
- */
RadarDiagram * RadarDiagram::clone() const
{
RadarDiagram* newDiagram = new RadarDiagram( new Private( *d ) );
// This needs to be copied after the fact
newDiagram->d->closeDatasets = d->closeDatasets;
return newDiagram;
}
const QPair RadarDiagram::calculateDataBoundaries () const
{
if ( !checkInvariants(true) ) return QPair( QPointF( 0, 0 ), QPointF( 0, 0 ) );
const int rowCount = model()->rowCount(rootIndex());
const int colCount = model()->columnCount(rootIndex());
qreal xMin = 0.0;
qreal xMax = colCount;
qreal yMin = 0, yMax = 0;
for ( int iCol=0; iColdata( model()->index( iRow, iCol, rootIndex() ) ).toReal(); // checked
yMax = qMax( yMax, value );
yMin = qMin( yMin, value );
}
}
QPointF bottomLeft ( QPointF( xMin, yMin ) );
QPointF topRight ( QPointF( xMax, yMax ) );
return QPair ( bottomLeft, topRight );
}
void RadarDiagram::paintEvent ( QPaintEvent*)
{
QPainter painter ( viewport() );
PaintContext ctx;
ctx.setPainter ( &painter );
ctx.setRectangle( QRectF ( 0, 0, width(), height() ) );
paint ( &ctx );
}
void RadarDiagram::paint( PaintContext* ctx )
{
qreal dummy1, dummy2;
paint( ctx, true, dummy1, dummy2 );
paint( ctx, false, dummy1, dummy2 );
}
static qreal fitFontSizeToGeometry( const QString& text, const QFont& font, const QRectF& geometry, const TextAttributes& ta )
{
QFont f = font;
const qreal origResult = f.pointSizeF();
qreal result = origResult;
const QSizeF mySize = geometry.size();
if ( mySize.isNull() )
return result;
const QString t = text;
QFontMetrics fm( f );
while ( true )
{
const QSizeF textSize = rotatedRect( fm.boundingRect( t ), ta.rotation() ).normalized().size();
if ( textSize.height() <= mySize.height() && textSize.width() <= mySize.width() )
return result;
result -= 0.5;
if ( result <= 0.0 )
return origResult;
f.setPointSizeF( result );
fm = QFontMetrics( f );
}
}
static QPointF scaleToRealPosition( const QPointF& origin, const QRectF& sourceRect, const QRectF& destRect, const AbstractCoordinatePlane& plane )
{
QPointF result = plane.translate( origin );
result -= sourceRect.topLeft();
result.setX( result.x() / sourceRect.width() * destRect.width() );
result.setY( result.y() / sourceRect.height() * destRect.height() );
result += destRect.topLeft();
return result;
}
void RadarDiagram::setReverseData( bool val )
{
d->reverseData = val;
}
bool RadarDiagram::reverseData()
{
return d->reverseData;
}
// local structure to remember the settings of a polygon inclusive the used color and pen.
struct Polygon {
QPolygonF polygon;
QBrush brush;
QPen pen;
Polygon(const QPolygonF &polygon, const QBrush &brush, const QPen &pen) : polygon(polygon), brush(brush), pen(pen) {}
};
void RadarDiagram::paint( PaintContext* ctx,
bool calculateListAndReturnScale,
qreal& newZoomX, qreal& newZoomY )
{
// note: Not having any data model assigned is no bug
// but we can not draw a diagram then either.
if ( !checkInvariants(true) )
return;
d->reverseMapper.clear();
const int rowCount = model()->rowCount( rootIndex() );
const int colCount = model()->columnCount( rootIndex() );
int iRow, iCol;
const qreal min = dataBoundaries().first.y();
const qreal r = qAbs( min ) + dataBoundaries().second.y();
const qreal step = ( r - qAbs( min ) ) / ( numberOfGridRings() );
RadarCoordinatePlane* plane = dynamic_cast(ctx->coordinatePlane());
TextAttributes ta = plane->textAttributes();
QRectF fontRect = ctx->rectangle();
fontRect.setSize( QSizeF( fontRect.width(), step / 2.0 ) );
const qreal labelFontSize = fitFontSizeToGeometry( QString::fromLatin1( "TestXYWQgqy" ), ta.font(), fontRect, ta );
QFont labelFont = ta.font();
ctx->painter()->setPen( ta.pen() );
labelFont.setPointSizeF( labelFontSize );
const QFontMetricsF metric( labelFont );
const qreal labelHeight = metric.height();
QPointF offset;
QRectF destRect = ctx->rectangle();
if ( ta.isVisible() )
{
destRect.setY( destRect.y() + 2 * labelHeight );
destRect.setHeight( destRect.height() - 4 * labelHeight );
}
if ( calculateListAndReturnScale ) {
ctx->painter()->save();
// Check if all of the data value texts / data comments will fit
// into the available space:
d->labelPaintCache.clear();
ctx->painter()->save();
for ( iCol=0; iCol < colCount; ++iCol ) {
for ( iRow=0; iRow < rowCount; ++iRow ) {
QModelIndex index = model()->index( iRow, iCol, rootIndex() ); // checked
const qreal value = model()->data( index ).toReal();
QPointF point = scaleToRealPosition( QPointF( value, iRow ), ctx->rectangle(), destRect, *ctx->coordinatePlane() );
d->addLabel( &d->labelPaintCache, index, nullptr, PositionPoints( point ),
Position::Center, Position::Center, value );
}
}
ctx->painter()->restore();
const qreal oldZoomX = coordinatePlane()->zoomFactorX();
const qreal oldZoomY = coordinatePlane()->zoomFactorY();
newZoomX = oldZoomX;
newZoomY = oldZoomY;
if ( d->labelPaintCache.paintReplay.count() ) {
QRectF txtRectF;
d->paintDataValueTextsAndMarkers( ctx, d->labelPaintCache, true, true, &txtRectF );
const QRect txtRect = txtRectF.toRect();
const QRect curRect = coordinatePlane()->geometry();
const qreal gapX = qMin( txtRect.left() - curRect.left(), curRect.right() - txtRect.right() );
const qreal gapY = qMin( txtRect.top() - curRect.top(), curRect.bottom() - txtRect.bottom() );
newZoomX = oldZoomX;
newZoomY = oldZoomY;
if ( gapX < 0.0 )
newZoomX *= 1.0 + (gapX-1.0) / curRect.width();
if ( gapY < 0.0 )
newZoomY *= 1.0 + (gapY-1.0) / curRect.height();
}
ctx->painter()->restore();
} else {
// Iterate through data sets and create a list of polygons out of them.
QList polygons;
for ( iCol=0; iCol < colCount; ++iCol ) {
//TODO(khz): As of yet RadarDiagram can not show per-segment line attributes
// but it draws every polyline in one go - using one color.
// This needs to be enhanced to allow for cell-specific settings
// in the same way as LineDiagram does it.
QPolygonF polygon;
QPointF point0;
for ( iRow=0; iRow < rowCount; ++iRow ) {
QModelIndex index = model()->index( iRow, iCol, rootIndex() ); // checked
const qreal value = model()->data( index ).toReal();
QPointF point = scaleToRealPosition( QPointF( value, d->reverseData ? ( rowCount - iRow ) : iRow ), ctx->rectangle(), destRect, *ctx->coordinatePlane() );
polygon.append( point );
if ( ! iRow )
point0= point;
}
if ( closeDatasets() && rowCount )
polygon.append( point0 );
QBrush brush = d->datasetAttrs( iCol, KChart::DatasetBrushRole ).value();
QPen p = d->datasetAttrs( iCol, KChart::DatasetPenRole ).value< QPen >();
if ( p.style() != Qt::NoPen )
{
polygons.append( Polygon( polygon, brush, PrintingParameters::scalePen( p ) ) );
}
}
// first fill the areas with the brush-color and the defined alpha-value.
if (d->fillAlpha > 0.0) {
Q_FOREACH(const Polygon& p, polygons) {
PainterSaver painterSaver( ctx->painter() );
ctx->painter()->setRenderHint ( QPainter::Antialiasing );
QBrush br = p.brush;
QColor c = br.color();
c.setAlphaF(d->fillAlpha);
br.setColor(c);
ctx->painter()->setBrush( br );
ctx->painter()->setPen( p.pen );
ctx->painter()->drawPolygon( p.polygon );
}
}
// then draw the poly-lines.
Q_FOREACH(const Polygon& p, polygons) {
PainterSaver painterSaver( ctx->painter() );
ctx->painter()->setRenderHint ( QPainter::Antialiasing );
ctx->painter()->setBrush( p.brush );
ctx->painter()->setPen( p.pen );
ctx->painter()->drawPolyline( p.polygon );
}
d->paintDataValueTextsAndMarkers( ctx, d->labelPaintCache, true );
}
}
void RadarDiagram::resize ( const QSizeF& size )
{
AbstractPolarDiagram::resize( size );
}
/*virtual*/
qreal RadarDiagram::valueTotals () const
{
return model()->rowCount(rootIndex());
}
/*virtual*/
qreal RadarDiagram::numberOfValuesPerDataset() const
{
return model() ? model()->rowCount(rootIndex()) : 0.0;
}
/*virtual*/
qreal RadarDiagram::numberOfGridRings() const
{
return 5; // FIXME
}
void RadarDiagram::setCloseDatasets( bool closeDatasets )
{
d->closeDatasets = closeDatasets;
}
bool RadarDiagram::closeDatasets() const
{
return d->closeDatasets;
}
qreal RadarDiagram::fillAlpha() const
{
return d->fillAlpha;
}
void RadarDiagram::setFillAlpha(qreal alphaF)
{
d->fillAlpha = alphaF;
}
void RadarDiagram::resizeEvent ( QResizeEvent*)
{
}
diff --git a/src/KChart/Polar/KChartRadarDiagram.h b/src/KChart/Polar/KChartRadarDiagram.h
index ba4b4ff..818727e 100644
--- a/src/KChart/Polar/KChartRadarDiagram.h
+++ b/src/KChart/Polar/KChartRadarDiagram.h
@@ -1,98 +1,101 @@
/*
* Copyright (C) 2001-2015 Klaralvdalens Datakonsult AB. All rights reserved.
*
* This file is part of the KD Chart library.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation; either version 2 of
* the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see .
*/
#ifndef KCHARTRADARDIAGRAM_H
#define KCHARTRADARDIAGRAM_H
#include "KChartPosition.h"
#include "KChartPolarDiagram.h"
#include "KChartRadarCoordinatePlane.h"
QT_BEGIN_NAMESPACE
class QPolygonF;
QT_END_NAMESPACE
namespace KChart {
/**
* @brief RadarDiagram defines a common radar diagram
*/
class KCHART_EXPORT RadarDiagram : public AbstractPolarDiagram
{
Q_OBJECT
Q_DISABLE_COPY( RadarDiagram )
KCHART_DECLARE_DERIVED_DIAGRAM( RadarDiagram, RadarCoordinatePlane )
public:
explicit RadarDiagram(
QWidget* parent = nullptr, RadarCoordinatePlane* plane = nullptr );
virtual ~RadarDiagram();
virtual void paint ( PaintContext* paintContext,
bool calculateListAndReturnScale,
qreal& newZoomX, qreal& newZoomY );
/** \reimpl */
void resize ( const QSizeF& area ) override;
/** \reimpl */
qreal valueTotals () const override;
/** \reimpl */
qreal numberOfValuesPerDataset() const override;
/** \reimpl */
qreal numberOfGridRings() const override;
/**
* if val is true the diagram will mirror the diagram datapoints
*/
void setReverseData( bool val );
bool reverseData();
- virtual RadarDiagram * clone() const;
+ /**
+ * Creates an exact copy of this diagram.
+ */
+ virtual RadarDiagram * clone() const;
/**
* Close each of the data series by connecting the last point to its
* respective start point
*/
void setCloseDatasets( bool closeDatasets );
bool closeDatasets() const;
/**
* Fill the areas of the radar chart with there respective color defined
* via KChart::DatasetBrushRole. The value defines the alpha of the
* color to use. If set to 0.0 (the default) then the radar areas will
* not be filled with any color. If set to 1.0 then the areas will be
* solid filled and are not transparent.
*/
qreal fillAlpha() const;
void setFillAlpha(qreal alphaF);
protected:
/** \reimpl */
const QPair calculateDataBoundaries() const override;
void paintEvent ( QPaintEvent* ) override;
void resizeEvent ( QResizeEvent* ) override;
void paint ( PaintContext* paintContext ) override;
}; // End of class RadarDiagram
}
#endif // KCHARTRADARDIAGRAM_H
diff --git a/src/KChart/Polar/KChartRingDiagram.cpp b/src/KChart/Polar/KChartRingDiagram.cpp
index 4814649..a3e177b 100644
--- a/src/KChart/Polar/KChartRingDiagram.cpp
+++ b/src/KChart/Polar/KChartRingDiagram.cpp
@@ -1,489 +1,470 @@
/*
* Copyright (C) 2001-2015 Klaralvdalens Datakonsult AB. All rights reserved.
*
* This file is part of the KD Chart library.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as
* published by the Free Software Foundation; either version 2 of
* the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see .
*/
#include "KChartRingDiagram.h"
#include "KChartRingDiagram_p.h"
#include "KChartAttributesModel.h"
#include "KChartPaintContext.h"
#include "KChartPainterSaver_p.h"
#include "KChartPieAttributes.h"
#include "KChartPolarCoordinatePlane_p.h"
#include "KChartThreeDPieAttributes.h"
#include "KChartDataValueAttributes.h"
#include "KChartMath_p.h"
#include
using namespace KChart;
RingDiagram::Private::Private()
: relativeThickness( false )
, expandWhenExploded( false )
{
}
RingDiagram::Private::~Private() {}
#define d d_func()
RingDiagram::RingDiagram( QWidget* parent, PolarCoordinatePlane* plane ) :
AbstractPieDiagram( new Private(), parent, plane )
{
init();
}
RingDiagram::~RingDiagram()
{
}
void RingDiagram::init()
{
}
-/**
- * Creates an exact copy of this diagram.
- */
RingDiagram * RingDiagram::clone() const
{
return new RingDiagram( new Private( *d ) );
}
bool RingDiagram::compare( const RingDiagram* other ) const
{
if ( other == this ) return true;
if ( ! other ) {
return false;
}
return // compare the base class
( static_cast(this)->compare( other ) ) &&
// compare own properties
(relativeThickness() == other->relativeThickness()) &&
(expandWhenExploded() == other->expandWhenExploded());
}
void RingDiagram::setRelativeThickness( bool relativeThickness )
{
d->relativeThickness = relativeThickness;
}
bool RingDiagram::relativeThickness() const
{
return d->relativeThickness;
}
void RingDiagram::setExpandWhenExploded( bool expand )
{
d->expandWhenExploded = expand;
}
bool RingDiagram::expandWhenExploded() const
{
return d->expandWhenExploded;
}
const QPair RingDiagram::calculateDataBoundaries () const
{
if ( !checkInvariants( true ) ) return QPair( QPointF( 0, 0 ), QPointF( 0, 0 ) );
const PieAttributes attrs( pieAttributes() );
QPointF bottomLeft( 0, 0 );
QPointF topRight;
// If we explode, we need extra space for the pie slice that has the largest explosion distance.
if ( attrs.explode() ) {
const int rCount = rowCount();
const int colCount = columnCount();
qreal maxExplode = 0.0;
for ( int i = 0; i < rCount; ++i ) {
qreal maxExplodeInThisRow = 0.0;
for ( int j = 0; j < colCount; ++j ) {
const PieAttributes columnAttrs( pieAttributes( model()->index( i, j, rootIndex() ) ) ); // checked
maxExplodeInThisRow = qMax( maxExplodeInThisRow, columnAttrs.explodeFactor() );
}
maxExplode += maxExplodeInThisRow;
// FIXME: What if explode factor of inner ring is > 1.0 ?
if ( !d->expandWhenExploded ) {
break;
}
}
// explode factor is relative to width (outer r - inner r) of one ring
maxExplode /= ( rCount + 1);
topRight = QPointF( 1.0 + maxExplode, 1.0 + maxExplode );
} else {
topRight = QPointF( 1.0, 1.0 );
}
return QPair( bottomLeft, topRight );
}
void RingDiagram::paintEvent( QPaintEvent* )
{
QPainter painter ( viewport() );
PaintContext ctx;
ctx.setPainter ( &painter );
ctx.setRectangle( QRectF ( 0, 0, width(), height() ) );
paint ( &ctx );
}
void RingDiagram::resizeEvent( QResizeEvent* )
{
}
void RingDiagram::paint( PaintContext* ctx )
{
// note: Not having any data model assigned is no bug
// but we can not draw a diagram then either.
if ( !checkInvariants(true) )
return;
d->reverseMapper.clear();
const PieAttributes attrs( pieAttributes() );
const int rCount = rowCount();
const int colCount = columnCount();
//QRectF contentsRect = PolarCoordinatePlane::Private::contentsRect( polarCoordinatePlane() );
QRectF contentsRect = ctx->rectangle();
if ( contentsRect.isEmpty() )
return;
d->startAngles = QVector< QVector >( rCount, QVector