File indexing completed on 2024-06-09 04:18:32

 /*
  * SPDX-FileCopyrightText: 2001-2015 Klaralvdalens Datakonsult AB. All rights reserved.
  *
  * This file is part of the KD Chart library.
  *
  * SPDX-License-Identifier: GPL-2.0-or-later
  */
 
 #include "KChartPolarCoordinatePlane.h"
 #include "KChartPolarCoordinatePlane_p.h"
 
 #include "KChartPainterSaver_p.h"
 #include "KChartChart.h"
 #include "KChartPaintContext.h"
 #include "KChartAbstractDiagram.h"
 #include "KChartAbstractPolarDiagram.h"
 #include "KChartPolarDiagram.h"
 #include "KChartMath_p.h"
 
 #include <QFont>
 #include <QList>
 #include <QtDebug>
 #include <QPainter>
 #include <QTimer>
 
 
 using namespace KChart;
 
 #define d d_func()
 
 PolarCoordinatePlane::PolarCoordinatePlane ( Chart* parent )
     : AbstractCoordinatePlane ( new Private(), parent )
 {
     // this block left empty intentionally
 }
 
 PolarCoordinatePlane::~PolarCoordinatePlane()
 {
     // this block left empty intentionally
 }
 
 void PolarCoordinatePlane::init()
 {
     // this block left empty intentionally
 }
 
 void PolarCoordinatePlane::addDiagram ( AbstractDiagram* diagram )
 {
     Q_ASSERT_X ( dynamic_cast<AbstractPolarDiagram*> ( diagram ),
                  "PolarCoordinatePlane::addDiagram", "Only polar"
                  "diagrams can be added to a polar coordinate plane!" );
     AbstractCoordinatePlane::addDiagram ( diagram );
     connect ( diagram,  SIGNAL (layoutChanged(KChart::AbstractDiagram*)),
               SLOT (slotLayoutChanged(KChart::AbstractDiagram*)) );
 
 }
 
 void PolarCoordinatePlane::paint ( QPainter* painter )
 {
     AbstractDiagramList diags = diagrams();
     if ( d->coordinateTransformations.size() != diags.size() ) {
         // diagrams have not been set up yet
         return;
     }
      // need at least one so d->currentTransformation can be a valid pointer
     Q_ASSERT( !d->coordinateTransformations.isEmpty() );
 
     PaintContext ctx;
     ctx.setPainter ( painter );
     ctx.setCoordinatePlane ( this );
     ctx.setRectangle ( geometry() /*d->contentRect*/ );
 
     // 1. ask (only!) PolarDiagrams if they need additional space for data labels / data comments
 
     const qreal oldZoomX = zoomFactorX();
     const qreal oldZoomY = zoomFactorY();
     d->newZoomX = oldZoomX;
     d->newZoomY = oldZoomY;
     for ( int i = 0; i < diags.size(); i++ ) {
         d->currentTransformation = & ( d->coordinateTransformations[i] );
         qreal zoomX;
         qreal zoomY;
         PolarDiagram* polarDia = dynamic_cast<PolarDiagram*> ( diags[i] );
         if ( polarDia ) {
             polarDia->paint( &ctx, true, zoomX, zoomY );
             d->newZoomX = qMin( d->newZoomX, zoomX );
             d->newZoomY = qMin( d->newZoomY, zoomY );
         }
     }
 
     if ( d->newZoomX != oldZoomX || d->newZoomY != oldZoomY ) {
         //qDebug() << "new zoom:" << d->newZoomY << " old zoom:" << oldZoomY;
         d->currentTransformation = nullptr; // not painting anymore until we get called again
         QMetaObject::invokeMethod( this, "adjustZoomAndRepaint", Qt::QueuedConnection );
         return;
     }
 
     // 2. there was room enough for the labels, so start drawing
 
     // paint the coordinate system rulers:
     d->currentTransformation = &d->coordinateTransformations.first();
     d->grid->drawGrid( &ctx );
 
     // paint the diagrams which will re-use their DataValueTextInfoList(s) filled in step 1:
     for ( int i = 0; i < diags.size(); i++ ) {
         d->currentTransformation = & ( d->coordinateTransformations[i] );
         PainterSaver painterSaver( painter );
         PolarDiagram* polarDia = dynamic_cast<PolarDiagram*>( diags[i] );
         if ( polarDia ) {
             qreal dummy1, dummy2;
             polarDia->paint( &ctx, false, dummy1, dummy2 );
         } else {
             diags[i]->paint( &ctx );
         }
     }
     d->currentTransformation = nullptr;
 }
 
 
 void PolarCoordinatePlane::adjustZoomAndRepaint()
 {
     const qreal newZoom = qMin(d->newZoomX, d->newZoomY);
     setZoomFactors(newZoom, newZoom);
     update();
 }
 
 
 void PolarCoordinatePlane::resizeEvent ( QResizeEvent* )
 {
     d->initialResizeEventReceived = true;
     layoutDiagrams();
 }
 
 void PolarCoordinatePlane::layoutDiagrams()
 {
     // the rectangle the diagrams cover in the *plane*:
     // (Why -3? We save 1px on each side for the antialiased drawing, and
     // respect the way QPainter calculates the width of a painted rect (the
     // size is the rectangle size plus the pen width). This way, most clipping
     // for regular pens should be avoided. When pens with a penWidth or larger
     // than 1 are used, this may not b sufficient.
     const QRect rect( areaGeometry() );
     d->contentRect = QRectF ( 1, 1, rect.width() - 3, rect.height() - 3 );
 
     const ZoomParameters zoom = d->coordinateTransformations.isEmpty() ? ZoomParameters()
                                                                        : d->coordinateTransformations.front().zoom;
     // FIXME distribute space according to options:
     const qreal oldStartPosition = startPosition();
     d->coordinateTransformations.clear();
     const auto ds = diagrams();
     for ( AbstractDiagram* diagram : ds ) {
             AbstractPolarDiagram *polarDiagram = dynamic_cast<AbstractPolarDiagram*>( diagram );
             Q_ASSERT( polarDiagram );
             QPair<QPointF, QPointF> dataBoundariesPair = polarDiagram->dataBoundaries();
 
             const qreal angleUnit = 360 / polarDiagram->valueTotals();
 //qDebug() << "--------------------------------------------------------";
             const qreal radius = qAbs( dataBoundariesPair.first.y() ) + dataBoundariesPair.second.y();
 //qDebug() << radius <<"="<<dataBoundariesPair.second.y();
             const qreal diagramWidth = radius * 2; // == height
             const qreal planeWidth = d->contentRect.width();
             const qreal planeHeight = d->contentRect.height();
             const qreal radiusUnit = qMin( planeWidth, planeHeight ) / diagramWidth;
 //qDebug() << radiusUnit <<"=" << "qMin( "<<planeWidth<<","<< planeHeight <<") / "<<diagramWidth;
             QPointF coordinateOrigin = QPointF ( planeWidth / 2, planeHeight / 2 );
             coordinateOrigin += d->contentRect.topLeft();
 
             CoordinateTransformation diagramTransposition;
             diagramTransposition.originTranslation = coordinateOrigin;
             diagramTransposition.radiusUnit = radiusUnit;
             diagramTransposition.angleUnit = angleUnit;
             diagramTransposition.startPosition = oldStartPosition;
             diagramTransposition.zoom = zoom;
             diagramTransposition.minValue = dataBoundariesPair.first.y() < 0 ? dataBoundariesPair.first.y() : 0.0;
             d->coordinateTransformations.append( diagramTransposition );
         }
     update();
 }
 
 const QPointF PolarCoordinatePlane::translate( const QPointF& diagramPoint ) const
 {
     Q_ASSERT_X ( d->currentTransformation != nullptr, "PolarCoordinatePlane::translate",
                  "Only call translate() from within paint()." );
     return  d->currentTransformation->translate ( diagramPoint );
 }
 
 const QPointF PolarCoordinatePlane::translatePolar( const QPointF& diagramPoint ) const
 {
     Q_ASSERT_X ( d->currentTransformation != nullptr, "PolarCoordinatePlane::translate",
                  "Only call translate() from within paint()." );
     return  d->currentTransformation->translatePolar ( diagramPoint );
 }
 
 qreal PolarCoordinatePlane::angleUnit() const
 {
     Q_ASSERT_X ( d->currentTransformation != nullptr, "PolarCoordinatePlane::angleUnit",
                  "Only call angleUnit() from within paint()." );
     return  d->currentTransformation->angleUnit;
 }
 
 qreal PolarCoordinatePlane::radiusUnit() const
 {
     Q_ASSERT_X ( d->currentTransformation != nullptr, "PolarCoordinatePlane::radiusUnit",
                  "Only call radiusUnit() from within paint()." );
     return  d->currentTransformation->radiusUnit;
 }
 
 void PolarCoordinatePlane::slotLayoutChanged ( AbstractDiagram* )
 {
     if ( d->initialResizeEventReceived ) layoutDiagrams();
 }
 
 void PolarCoordinatePlane::setStartPosition( qreal degrees )
 {
     Q_ASSERT_X ( diagram(), "PolarCoordinatePlane::setStartPosition",
                  "setStartPosition() needs a diagram to be associated to the plane." );
     for ( CoordinateTransformationList::iterator it = d->coordinateTransformations.begin();
                                                 it != d->coordinateTransformations.end();
                                                 ++it )
     {
         CoordinateTransformation& trans = *it;
         trans.startPosition = degrees;
     }
 }
 
 qreal PolarCoordinatePlane::startPosition() const
 {
     return d->coordinateTransformations.isEmpty()
         ? 0.0
         :  d->coordinateTransformations.first().startPosition;
 }
 
 qreal PolarCoordinatePlane::zoomFactorX() const
 {
     return d->coordinateTransformations.isEmpty()
         ? 1.0
         : d->coordinateTransformations.first().zoom.xFactor;
 }
 
 qreal PolarCoordinatePlane::zoomFactorY() const
 {
     return d->coordinateTransformations.isEmpty()
         ? 1.0
         : d->coordinateTransformations.first().zoom.yFactor;
 }
 
 void PolarCoordinatePlane::setZoomFactors( qreal factorX, qreal factorY )
 {
     setZoomFactorX( factorX );
     setZoomFactorY( factorY );
 }
 
 void PolarCoordinatePlane::setZoomFactorX( qreal factor )
 {
     for ( CoordinateTransformationList::iterator it = d->coordinateTransformations.begin();
                                                 it != d->coordinateTransformations.end();
                                                 ++it )
     {
         CoordinateTransformation& trans = *it;
         trans.zoom.xFactor = factor;
     }
 }
 
 void PolarCoordinatePlane::setZoomFactorY( qreal factor )
 {
     for ( CoordinateTransformationList::iterator it = d->coordinateTransformations.begin();
                                                 it != d->coordinateTransformations.end();
                                                 ++it )
     {
         CoordinateTransformation& trans = *it;
         trans.zoom.yFactor = factor;
     }
 }
 
 QPointF PolarCoordinatePlane::zoomCenter() const
 {
     return d->coordinateTransformations.isEmpty()
         ? QPointF( 0.5, 0.5 )
         : QPointF( d->coordinateTransformations.first().zoom.xCenter, d->coordinateTransformations.first().zoom.yCenter );
 }
 
 void PolarCoordinatePlane::setZoomCenter( const QPointF& center )
 {
     for ( CoordinateTransformationList::iterator it = d->coordinateTransformations.begin();
                                                 it != d->coordinateTransformations.end();
                                                 ++it )
     {
         CoordinateTransformation& trans = *it;
         trans.zoom.xCenter = center.x();
         trans.zoom.yCenter = center.y();
     }
 }
 
 DataDimensionsList PolarCoordinatePlane::getDataDimensionsList() const
 {
     DataDimensionsList l;
 
     //FIXME(khz): do the real calculation
 
     return l;
 }
 
 void KChart::PolarCoordinatePlane::setGridAttributes(
     bool circular,
     const GridAttributes& a )
 {
     if ( circular )
         d->gridAttributesCircular = a;
     else
         d->gridAttributesSagittal = a;
     setHasOwnGridAttributes( circular, true );
     update();
     Q_EMIT propertiesChanged();
 }
 
 void KChart::PolarCoordinatePlane::resetGridAttributes(
     bool circular )
 {
     setHasOwnGridAttributes( circular, false );
     update();
 }
 
 const GridAttributes KChart::PolarCoordinatePlane::gridAttributes(
     bool circular ) const
 {
     if ( hasOwnGridAttributes( circular ) ) {
         if ( circular )
             return d->gridAttributesCircular;
         else
             return d->gridAttributesSagittal;
     } else {
         return globalGridAttributes();
     }
 }
 
 QRectF KChart::PolarCoordinatePlane::Private::contentsRect( const KChart::PolarCoordinatePlane* plane )
 {
     QRectF contentsRect;
     QPointF referencePointAtTop = plane->translate( QPointF( 1, 0 ) );
     QPointF temp = plane->translate( QPointF( 0, 0 ) ) - referencePointAtTop;
     const qreal offset = temp.y();
     referencePointAtTop.setX( referencePointAtTop.x() - offset );
     contentsRect.setTopLeft( referencePointAtTop );
     contentsRect.setBottomRight( referencePointAtTop + QPointF( 2.0 * offset, 2.0 * offset) );
     return contentsRect;
 }
 
 void KChart::PolarCoordinatePlane::setHasOwnGridAttributes(
     bool circular, bool on )
 {
     if ( circular )
         d->hasOwnGridAttributesCircular = on;
     else
         d->hasOwnGridAttributesSagittal = on;
     Q_EMIT propertiesChanged();
 }
 
 bool KChart::PolarCoordinatePlane::hasOwnGridAttributes(
     bool circular ) const
 {
     return
         ( circular )
         ? d->hasOwnGridAttributesCircular
         : d->hasOwnGridAttributesSagittal;
 }