File indexing completed on 2024-05-12 04:20:30

 /*
  * 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
  */
 
 #ifndef KCHARTABSTRACTDIAGRAM_P_H
 #define KCHARTABSTRACTDIAGRAM_P_H
 
 //
 //  W A R N I N G
 //  -------------
 //
 // This file is not part of the KD Chart API.  It exists purely as an
 // implementation detail.  This header file may change from version to
 // version without notice, or even be removed.
 //
 // We mean it.
 //
 
 #include "KChartAbstractDiagram.h"
 #include "KChartAbstractCoordinatePlane.h"
 #include "KChartDataValueAttributes.h"
 #include "KChartBackgroundAttributes.h"
 #include "KChartRelativePosition.h"
 #include "KChartPosition.h"
 #include "KChartPaintContext.h"
 #include "KChartPrintingParameters.h"
 #include "KChartChart.h"
 #include <KChartCartesianDiagramDataCompressor_p.h>
 #include "ReverseMapper.h"
 
 #include <QMap>
 #include <QPoint>
 #include <QPointer>
 #include <QFont>
 #include <QFontMetrics>
 #include <QPaintDevice>
 #include <QPainterPath>
 #include <QModelIndex>
 #include <QPainterPath>
 
 
 namespace KChart {
     class LabelPaintInfo {
     public:
         LabelPaintInfo();
         LabelPaintInfo( const QModelIndex& _index, const DataValueAttributes& _attrs,
                         const QPainterPath& _labelArea, const QPointF& _markerPos,
                         bool _isValuePositive, const QString& _value );
         LabelPaintInfo( const LabelPaintInfo& other );
         QModelIndex index;
         DataValueAttributes attrs;
         QPainterPath labelArea;
         QPointF markerPos;
         bool isValuePositive;
         // could (ab)use attrs.dataLabel() instead
         QString value;
     };
 
     class LabelPaintCache
     {
     public:
         LabelPaintCache() {}
         ~LabelPaintCache()
         {
             clear();
         }
 
         void clear()
         {
             paintReplay.clear();
         }
 
         QVector<LabelPaintInfo> paintReplay;
     private:
         LabelPaintCache( LabelPaintCache& other ); // no copies
     };
 
 
 /**
  * \internal
  */
     class AttributesModel;
 
     class Q_DECL_HIDDEN KChart::AbstractDiagram::Private
     {
         friend class AbstractDiagram;
     public:
         explicit Private();
         virtual ~Private();
 
         Private( const Private& rhs );
 
         void setAttributesModel( AttributesModel* );
 
         bool usesExternalAttributesModel() const;
 
         // FIXME: Optimize if necessary
         virtual qreal calcPercentValue( const QModelIndex & index ) const;
 
         // this should possibly be virtual so it can be overridden
         void addLabel( LabelPaintCache* cache,
                        const QModelIndex& index,
                        const CartesianDiagramDataCompressor::CachePosition* position,
                        const PositionPoints& points, const Position& autoPositionPositive,
                        const Position& autoPositionNegative, const qreal value,
                        qreal favoriteAngle = 0.0 );
 
         const QFontMetrics* cachedFontMetrics( const QFont& font, const QPaintDevice* paintDevice) const;
         const QFontMetrics cachedFontMetrics() const;
 
         QString formatNumber( qreal value, int decimalDigits ) const;
         QString formatDataValueText( const DataValueAttributes &dva,
                                      const QModelIndex& index, qreal value ) const;
 
         void forgetAlreadyPaintedDataValues();
 
         void paintDataValueTextsAndMarkers( PaintContext* ctx,
                                             const LabelPaintCache& cache,
                                             bool paintMarkers,
                                             bool justCalculateRect=false,
                                             QRectF* cumulatedBoundingRect = nullptr );
 
         void paintDataValueText( QPainter* painter,
                                  const QModelIndex& index,
                                  const QPointF& pos,
                                  qreal value,
                                  bool justCalculateRect=false,
                                  QRectF* cumulatedBoundingRect = nullptr );
 
         void paintDataValueText( QPainter* painter,
                                  const DataValueAttributes& attrs,
                                  const QPointF& pos,
                                  bool valueIsPositive,
                                  const QString& text,
                                  bool justCalculateRect=false,
                                  QRectF* cumulatedBoundingRect = nullptr );
 
         inline int datasetCount() const
         {
             return attributesModel->columnCount( attributesModelRootIndex ) / datasetDimension;
         }
 
         virtual QModelIndex indexAt( const QPoint& point ) const;
 
         QModelIndexList indexesAt( const QPoint& point ) const;
 
         QModelIndexList indexesIn( const QRect& rect ) const;
 
         virtual CartesianDiagramDataCompressor::AggregatedDataValueAttributes aggregatedAttrs(
                 const QModelIndex & index,
                 const CartesianDiagramDataCompressor::CachePosition * position ) const;
 
         /**
          * Sets arbitrary attributes of a data set.
          */
         void setDatasetAttrs( int dataset, const QVariant& data, int role );
 
         /**
          * Retrieves arbitrary attributes of a data set.
          */
         QVariant datasetAttrs( int dataset, int role ) const;
 
         /**
          * Resets an attribute of a dataset back to its default.
          */
         void resetDatasetAttrs( int dataset, int role );
 
         /**
          * Whether the diagram is transposed (X and Y swapped), which has the same effect as rotating
          * the diagram 90° clockwise and inverting the (then vertical) X coordinate.
          */
         bool isTransposed() const;
 
         static Private* get( AbstractDiagram *diagram ) { return diagram->_d; }
 
         AbstractDiagram* diagram;
         ReverseMapper reverseMapper;
         /// The size of the diagram set by AbstractDiagram::resize()
         QSizeF diagramSize;
         bool doDumpPaintTime; // for use in performance testing code
 
     protected:
         void init();
         void init( AbstractCoordinatePlane* plane );
 
         QPointer<AbstractCoordinatePlane> plane;
         mutable QModelIndex attributesModelRootIndex;
         QPointer<AttributesModel> attributesModel;
         bool allowOverlappingDataValueTexts;
         bool antiAliasing;
         bool percent;
         int datasetDimension;
         mutable QPair<QPointF,QPointF> databoundaries;
         mutable bool databoundariesDirty;
 
         QMap< Qt::Orientation, QString > unitSuffix;
         QMap< Qt::Orientation, QString > unitPrefix;
         QMap< int, QMap< Qt::Orientation, QString > > unitSuffixMap;
         QMap< int, QMap< Qt::Orientation, QString > > unitPrefixMap;
         QList< QPainterPath > alreadyDrawnDataValueTexts;
 
     private:
         QString prevPaintedDataValueText;
         mutable QFontMetrics mCachedFontMetrics;
         mutable QFont mCachedFont;
         mutable QPaintDevice* mCachedPaintDevice;
     };
 
     inline AbstractDiagram::AbstractDiagram( Private * p ) : _d( p )
     {
         init();
     }
     inline AbstractDiagram::AbstractDiagram(
         Private * p, QWidget* parent, AbstractCoordinatePlane* plane )
         : QAbstractItemView( parent ), _d( p )
     {
         _d->init( plane );
         init();
     }
 
 
     class LineAttributesInfo {
     public:
         LineAttributesInfo();
         LineAttributesInfo( const QModelIndex& _index, const QPointF& _value, const QPointF& _nextValue );
 
         QModelIndex index;
         QPointF value;
         QPointF nextValue;
     };
 
     typedef QVector<LineAttributesInfo> LineAttributesInfoList;
     typedef QVectorIterator<LineAttributesInfo> LineAttributesInfoListIterator;
 
 }
 #endif /* KCHARTDIAGRAM_P_H */