diff options
Diffstat (limited to 'libkdchart/KDChartParams.h')
| -rw-r--r-- | libkdchart/KDChartParams.h | 2787 |
1 files changed, 2787 insertions, 0 deletions
diff --git a/libkdchart/KDChartParams.h b/libkdchart/KDChartParams.h new file mode 100644 index 0000000..0667348 --- /dev/null +++ b/libkdchart/KDChartParams.h @@ -0,0 +1,2787 @@ +/* -*- Mode: C++ -*- + KDChart - a multi-platform charting engine +*/ + +/**************************************************************************** + ** Copyright (C) 2001-2003 Klarälvdalens Datakonsult AB. All rights reserved. + ** + ** This file is part of the KDChart library. + ** + ** This file may be distributed and/or modified under the terms of the + ** GNU General Public License version 2 as published by the Free Software + ** Foundation and appearing in the file LICENSE.GPL included in the + ** packaging of this file. + ** + ** Licensees holding valid commercial KDChart licenses may use this file in + ** accordance with the KDChart Commercial License Agreement provided with + ** the Software. + ** + ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE + ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. + ** + ** See http://www.klaralvdalens-datakonsult.se/?page=products for + ** information about KDChart Commercial License Agreements. + ** + ** Contact info@klaralvdalens-datakonsult.se if any conditions of this + ** licensing are not clear to you. + ** + **********************************************************************/ +#ifndef __KDCHARTPARAMS_H__ +#define __KDCHARTPARAMS_H__ + +#include <qapplication.h> +#include <qfont.h> +#include <qcolor.h> +#include <qpen.h> +#include <qmap.h> +#include <qdict.h> +#include <qintdict.h> +#include <qobject.h> +#include <qtextstream.h> +#include <qsimplerichtext.h> +#include <qdom.h> +#include <limits.h> + +#include <math.h> +#ifdef Q_WS_WIN +#define M_PI 3.14159265358979323846 +#endif + +#include "KDChartGlobal.h" +#include "KDChartEnums.h" +#include "KDChartCustomBox.h" +#include "KDFrame.h" +#include "KDChartAxisParams.h" +#include "KDChartPropertySet.h" + +#if COMPAT_QT_VERSION >= 0x030000 +#include <qvaluevector.h> +#else +#include <qarray.h> +#endif + +/** \file KDChartParams.h + \brief Header for all common chart parameters. + + This file is used to access all chart parameters except of the + axis settings which you will find in \c KDChartAxisParams.h + + \see KDChartAxisParams.h +*/ + + +typedef QIntDict<KDChartPropertySet> KDChartPropertySetList; + +#define KDCHART_ALL_AXES UINT_MAX-1 + +// PENDING(blackie) KHZ, please clean up here. I guess this defined can be removed now. +// Note: The following specification matches the UINT_MAX value used +// in KDChartAxisParams::KDChartAxisParams() to initialize the +// axis' _axisIsoRefAxis member. +// OK, this is a dirty hack but is avoids circular dependency +// between KDChartParams and KDChartAxisParams +#define KDCHART_NO_AXIS UINT_MAX +#define KDCHART_ALL_DATASETS UINT_MAX - 1 + +#define KDCHART_NO_DATASET UINT_MAX +#define KDCHART_UNKNOWN_CHART UINT_MAX - 2 +#define KDCHART_ALL_CHARTS UINT_MAX - 1 +#define KDCHART_NO_CHART UINT_MAX +#define KDCHART_GLOBAL_LINE_STYLE UINT_MAX +#define KDCHART_AUTO_SIZE INT_MAX +#define KDCHART_DATA_VALUE_AUTO_DIGITS INT_MAX +#define KDCHART_SAGITTAL_ROTATION INT_MAX +#define KDCHART_TANGENTIAL_ROTATION INT_MAX - 1 +#define KDCHART_PROPSET_NORMAL_DATA 0 +#define KDCHART_PROPSET_TRANSPARENT_DATA 1 +#define KDCHART_PROPSET_HORI_LINE 2 +#define KDCHART_PROPSET_VERT_LINE 3 + +// #define KDCHART_DATA_VALUE_AUTO_COLOR KDChartAutoColor::instance()->color() + +// PENDING(blackie) Can we delete this now? +/* we must keep this wrongly spelled value for backward compatibility reasons */ +#define KDCHART_SAGGITAL_ROTATION INT_MAX + +/** + Our charts may have up to 4 ordinate axes: + 2 left ones and 2 right ones + */ +#define KDCHART_CNT_ORDINATES 4 + +#define KDCHART_MAX_POLAR_DELIMS_AND_LABELS_POS 8 +#define KDCHART_MAX_AXES 12 + + +#define KDCHART_DATA_VALUE_AUTO_COLOR (KDChartAutoColor::instance()->color()) + +class KDCHART_EXPORT KDChartAutoColor { +public: + static const KDChartAutoColor* instance(); + static void freeInstance(); + const QColor* color() const + { + return &mColor; + } +private: + KDChartAutoColor(); + KDChartAutoColor( KDChartAutoColor const& ); + ~KDChartAutoColor(); + QColor mColor; + static KDChartAutoColor *mInstance; +}; + +/* +// #define KDCHART_DATA_VALUE_AUTO_COLOR KDChartParams_KDChartAutoColor +*/ + + +class KDCHART_EXPORT KDChartParams : public QObject +{ + + Q_OBJECT + Q_ENUMS(ChartType) + Q_ENUMS(SourceMode) + Q_ENUMS(BarChartSubType) + Q_ENUMS(LineChartSubType) + Q_ENUMS(LineMarkerStyle) + Q_ENUMS(AreaChartSubType) + Q_ENUMS(AreaLocation) + Q_ENUMS(PolarChartSubType) + Q_ENUMS(PolarMarkerStyle) + Q_ENUMS(HiLoChartSubType) + Q_ENUMS(BWChartSubType) + Q_ENUMS(BWStatVal) + Q_ENUMS(LegendPosition) + Q_ENUMS(LegendSource) + Q_ENUMS(HdFtPos) + + // Needed for QSA + Q_ENUMS( BrushStyle ) + Q_ENUMS( PenStyle ) + Q_ENUMS( Orientation ) + + +public slots: // PENDING(blackie) merge public slots into one section. + void setOptimizeOutputForScreen( bool screenOutput ) + { + _optimizeOutputForScreen = screenOutput; + } + + + bool optimizeOutputForScreen() const + { + return _optimizeOutputForScreen; + } + + void setGlobalLeading( int left, int top, int right, int bottom ); + + void setGlobalLeadingLeft( int leading ) + { + _globalLeadingLeft = leading; + emit changed(); + } + void setGlobalLeadingTop( int leading ) + { + _globalLeadingTop = leading; + emit changed(); + } + void setGlobalLeadingRight( int leading ) + { + _globalLeadingRight = leading; + emit changed(); + } + void setGlobalLeadingBottom( int leading ) + { + _globalLeadingBottom = leading; + emit changed(); + } + int globalLeadingLeft() const + { + return _globalLeadingLeft; + } + int globalLeadingTop() const + { + return _globalLeadingTop; + } + int globalLeadingRight() const + { + return _globalLeadingRight; + } + int globalLeadingBottom() const + { + return _globalLeadingBottom; + } + + int registerProperties( KDChartPropertySet& rSet ); + void setProperties( int id, KDChartPropertySet& rSet ); + bool removeProperties( int id ); + bool properties( int id, KDChartPropertySet& rSet ) const; + KDChartPropertySet* properties( int id ); + bool calculateProperties( int startId, KDChartPropertySet& rSet ) const; + +public: + +// MOC_SKIP_BEGIN + class KDCHART_EXPORT KDChartFrameSettings + { + // Q_OBJECT + public: + KDChartFrameSettings(); + KDChartFrameSettings( uint dataRow, + uint dataCol, + uint data3rd, + const KDFrame& frame, + int outerGapX, + int outerGapY, + int innerGapX, + int innerGapY, + bool addFrameWidthToLayout = true, + bool addFrameHeightToLayout = true ); + + // public slots: + uint dataRow() const + { + return _dataRow; + } + uint dataCol() const + { + return _dataCol; + } + uint data3rd() const + { + return _data3rd; + } + + void setDataRow( uint dataRow ) + { + _dataRow = dataRow; + } + void setDataCol( uint dataCol ) + { + _dataCol = dataCol; + } + void setData3rd( uint data3rd ) + { + _data3rd = data3rd; + } + + + void resetFrame() + { + if( _frame ) + delete _frame; + _frame = new KDFrame(); + } + + + const KDFrame* framePtr() const + { + return _frame; + } + + + const KDFrame& frame() const + { + return *_frame; + } + + + int innerGapX() const + { + return _innerGapX; + } + + + int innerGapY() const + { + return _innerGapY; + } + + + int outerGapX() const + { + return _outerGapX; + } + + + int outerGapY() const + { + return _outerGapY; + } + + + bool addFrameWidthToLayout() const + { + return _addFrameWidthToLayout; + } + + + bool addFrameHeightToLayout() const + { + return _addFrameHeightToLayout; + } + + // public: + virtual ~KDChartFrameSettings(); + + + static void createFrameSettingsNode( QDomDocument& document, + QDomNode& parent, + const QString& elementName, + const KDChartFrameSettings* settings, + uint areaId ); + + static bool readFrameSettingsNode( const QDomElement& element, + KDChartFrameSettings& settings, + uint& areaId ); + + + static void deepCopy( KDChartFrameSettings& D, const KDChartFrameSettings& R ) { + D._dataRow = R._dataRow; + D._dataCol = R._dataCol; + D._data3rd = R._data3rd; + + delete D._frame; + if( R._frame ){ + D._frame = new KDFrame(); + KDFrame::deepCopy(*D._frame, *R._frame); + }else{ + D._frame = 0; + } + + D._outerGapX = R._outerGapX; + D._outerGapY = R._outerGapY; + D._innerGapX = R._innerGapX; + D._innerGapY = R._innerGapY; + D._addFrameWidthToLayout = R._addFrameWidthToLayout; + D._addFrameHeightToLayout = R._addFrameHeightToLayout; + } + + private: + // KDChartFrameSettings( const KDChartFrameSettings& other ) :QObject( 0 ) { + KDChartFrameSettings( const KDChartFrameSettings& ) {} + KDChartFrameSettings& operator=( const KDChartFrameSettings& ){return *this;} + + + private: + uint _dataRow; + uint _dataCol; + uint _data3rd; + KDFrame* _frame; + int _outerGapX; + int _outerGapY; + int _innerGapX; + int _innerGapY; + bool _addFrameWidthToLayout; + bool _addFrameHeightToLayout; + }; + +// MOC_SKIP_END + +public slots: + + void setFrame( uint area, + const KDFrame& frame, + int outerGapX, + int outerGapY, + int innerGapX, + int innerGapY, + bool addFrameWidthToLayout = true, + bool addFrameHeightToLayout = true ) + { + _areaDict.setAutoDelete( TRUE ); + _areaDict.replace( QString( "%1/-----/-----/-----" ).arg( area, 5 ), + new KDChartFrameSettings(0,0,0, + frame, + outerGapX, + outerGapY, + innerGapX, + innerGapY, + addFrameWidthToLayout, + addFrameHeightToLayout ) ); + emit changed(); + } + + + // Note if you change the parameters here, then you must also change them in wrappers/KDChartParametersWrapper.h + void setSimpleFrame( uint area, + int outerGapX = 0, + int outerGapY = 0, + int innerGapX = 0, + int innerGapY = 0, + bool addFrameWidthToLayout = true, + bool addFrameHeightToLayout = true, + KDFrame::SimpleFrame simpleFrame = KDFrame::FrameFlat, + int lineWidth = 1, + int midLineWidth = 0, + QPen pen = QPen(), + QBrush background = QBrush( Qt::NoBrush ), + const QPixmap* backPixmap = 0, // no pixmap + KDFrame::BackPixmapMode backPixmapMode = KDFrame::PixStretched, + int shadowWidth = 0, + KDFrame::CornerName sunPos = KDFrame::CornerTopLeft ) + { + _areaDict.setAutoDelete( TRUE ); + KDFrame frame( QRect(0,0,0,0), + simpleFrame, + lineWidth, + midLineWidth, + pen, + background, + backPixmap, + backPixmapMode, + shadowWidth, + sunPos ); + + _areaDict.replace( QString( "%1/-----/-----/-----" ).arg( area, 5 ), + new KDChartFrameSettings( 0,0,0, frame, + outerGapX, + outerGapY, + innerGapX, + innerGapY, + addFrameWidthToLayout, + addFrameHeightToLayout ) ); + emit changed(); + } + + bool removeFrame( uint area ); + + + // Note if you change the parameters here, then you must also change them in wrappers/KDChartParametersWrapper.h + void setDataRegionFrame( uint dataRow, + uint dataCol, + uint, // important: we ignore the data3rd parameter for now! + int innerGapX = 0, + int innerGapY = 0, + bool addFrameWidthToLayout = true, + bool addFrameHeightToLayout = true, + KDFrame::SimpleFrame simpleFrame = KDFrame::FrameFlat, + int lineWidth = 1, + int midLineWidth = 0, + QPen pen = QPen(), + int shadowWidth = 0, + KDFrame::CornerName sunPos = KDFrame::CornerTopLeft ) + { + _areaDict.setAutoDelete( TRUE ); + KDFrame frame( QRect(0,0,0,0), + simpleFrame, + lineWidth, + midLineWidth, + pen, + QBrush( Qt::NoBrush ), + 0, + KDFrame::PixStretched, + shadowWidth, + sunPos ); + + _areaDict.replace( + dataRegionFrameAreaName( dataRow, dataCol, 0 ), //data3rd 5 ), + new KDChartFrameSettings( dataRow, + dataCol, + 0, // important: we ignore the data3rd parameter for now! + frame, + 0, + 0, + innerGapX, + innerGapY, + addFrameWidthToLayout, + addFrameHeightToLayout ) ); + emit changed(); + } + + + // Note if you change the parameters here, then you must also change them in wrappers/KDChartParametersWrapper.h + bool moveDataRegionFrame( uint oldDataRow, + uint oldDataCol, + uint, // important: we ignore the data3rd parameter for now! + uint newDataRow, + uint newDataCol, + uint // important: we ignore the data3rd parameter for now! + ); + + + const KDChartFrameSettings* frameSettings( uint area, + bool& bFound, + int* pIterIdx=0 ) const; + + const KDChartFrameSettings* nextFrameSettings( bool& bFound, + int* pIterIdx ) const; + + +public: + typedef QIntDict <KDChartCustomBox > CustomBoxDict; + +public slots: + uint insertCustomBox( const KDChartCustomBox & box ); + bool removeCustomBox( const uint & idx ); + + void removeAllCustomBoxes() + { + emit changed(); + _customBoxDict.setAutoDelete( true ); + _customBoxDict.clear(); + } + + KDChartCustomBox* customBoxRef( uint box ); + const KDChartCustomBox* customBox( uint box ) const; + uint maxCustomBoxIdx() const; + + +public: + enum ChartType { NoType, Bar, Line, Area, Pie, HiLo, Ring, Polar, BoxWhisker }; + +public slots: + void setChartType( ChartType chartType ); + ChartType chartType() const + { + return _chartType; + } + + + static QString chartTypeToString( ChartType type ); + static ChartType stringToChartType( const QString& string ); + + void setAdditionalChartType( ChartType chartType ); + ChartType additionalChartType() const + { + return _additionalChartType; + } +public: + + enum SourceMode { + UnknownMode = 0, + DontUse = 1, + DataEntry = 2, + AxisLabel = 3, + LegendText = 4, + ExtraLinesAnchor = 5, + Last_SourceMode = ExtraLinesAnchor }; + +public slots: + void setChartSourceMode( SourceMode mode, + uint dataset, + uint dataset2 = KDCHART_NO_DATASET, + uint chart = 0 ); + + static QString chartSourceModeToString( const SourceMode& mode ); + static SourceMode stringToChartSourceMode( const QString& string ); + + + bool neverUsedSetChartSourceMode() const + { + return !_setChartSourceModeWasUsed; + } + + SourceMode chartSourceMode( uint dataset, + uint dataset2 = KDCHART_NO_DATASET, + uint* chart = 0 ) const; + + bool findDataset( SourceMode mode, + uint& dataset, + uint& dataset2, + uint chart = 0 ) const; + + bool findDatasets( SourceMode mode1, + SourceMode mode2, + uint& dataset, + uint& dataset2, + uint chart = 0 ) const; + + uint maxDatasetSourceMode() const + { + return _maxDatasetSourceMode; + } + + + void setDefaultAxesTypes(); + void activateDefaultAxes(); + + + void setNumValues( uint numValues ) + { + _numValues = numValues; + emit changed(); + } + + + int numValues() const + { + return _numValues; + } + + + void calculateShadowColors( QColor color, + QColor& shadow1, + QColor& shadow2 ) const; + + void setDataColor( uint dataset, QColor color ); + QColor dataColor( uint dataset ) const; + + void setDataDefaultColors(); + void setDataRainbowColors(); + void setDataSubduedColors( bool ordered = false ); + + + void setShadowBrightnessFactor( double factor ) + { + _shadowBrightnessFactor = factor; + recomputeShadowColors(); + emit changed(); + } + + double shadowBrightnessFactor() const + { + return _shadowBrightnessFactor; + } + + + void setShadowPattern( BrushStyle style ) { + _shadowPattern = style; + emit changed(); + } + + Qt::BrushStyle shadowPattern() const { + return _shadowPattern; + } + + + void setOutlineDataColor( QColor color ) + { + _outlineDataColor = color; + emit changed(); + } + + + QColor outlineDataColor() const + { + return _outlineDataColor; + } + + + void setOutlineDataLineWidth( uint width ) + { + _outlineDataLineWidth = width; + emit changed(); + } + + uint outlineDataLineWidth() const + { + return _outlineDataLineWidth; + } + + + void setOutlineDataLineStyle( PenStyle style ) + { + _outlineDataLineStyle = style; + emit changed(); + } + + PenStyle outlineDataLineStyle() const + { + return _outlineDataLineStyle; + } + + + uint maxDataColor() const + { + return _maxDatasetColor; + } + + + void setThreeDShadowColors( bool shadow ) + { + _threeDShadowColors = shadow; + emit changed(); + } + + + bool threeDShadowColors() const + { + return _threeDShadowColors; + } + + + static int roundVal( double d ) + { + double fr; + double i=0.0; // initialization necessary for Borland C++ + fr = modf( d, &i ); + int ret = static_cast < int > ( i ); + if( 0.49999 <= fabs( fr ) ) + ret += ( 0.0 < d ) ? 1 : -1; + return ret; + } + + // Note if you change the parameters here, then you must also change them in wrappers/KDChartParametersWrapper.h + void setPrintDataValues( bool active, + uint chart = KDCHART_ALL_CHARTS, + int divPow10 = 0, + int digitsBehindComma = KDCHART_DATA_VALUE_AUTO_DIGITS, + QFont* font = 0, + uint size = UINT_MAX, // <-- makes us use the *default* font params + // by IGNORING settings of + // the following parameters! + const QColor* color = KDCHART_DATA_VALUE_AUTO_COLOR, + KDChartEnums::PositionFlag negativePosition = KDChartEnums::PosCenter, + uint negativeAlign = Qt::AlignCenter, + int negativeDeltaX = 0, + int negativeDeltaY = 0, + int negativeRotation = 0, + KDChartEnums::PositionFlag positivePosition = KDChartEnums::PosCenter, + uint positiveAlign = Qt::AlignCenter, + int positiveDeltaX = 0, + int positiveDeltaY = 0, + int positiveRotation = 0, + KDChartEnums::TextLayoutPolicy policy = KDChartEnums::LayoutPolicyRotate ); + + void setDataValuesCalc( int divPow10 = 0, + int digitsBehindComma = KDCHART_DATA_VALUE_AUTO_DIGITS, + uint chart = KDCHART_ALL_CHARTS ); + void setDataValuesFont( QFont* font, + uint size = UINT_MAX, + uint chart = KDCHART_ALL_CHARTS ); + + // Note if you change the parameters here, then you must also change them in wrappers/KDChartParametersWrapper.h + void setDataValuesPlacing( KDChartEnums::PositionFlag position, + uint align, + int deltaX, + int deltaY, + int rotation, + bool specifyingPositiveValues = true, + uint chart = KDCHART_ALL_CHARTS ); + + void setDataValuesColors( const QColor* color = KDCHART_DATA_VALUE_AUTO_COLOR, + const QBrush& background = Qt::NoBrush, + uint chart = KDCHART_ALL_CHARTS ); + + // Note if you change the parameters here, then you must also change them in wrappers/KDChartParametersWrapper.h + void setDataValuesPolicy( KDChartEnums::TextLayoutPolicy policy = KDChartEnums::LayoutPolicyRotate, + uint chart = KDCHART_ALL_CHARTS ); + + void setDataValuesShowInfinite( bool dataValuesShowInfinite = true, + uint chart = KDCHART_ALL_CHARTS ); + + void setPrintDataValuesWithDefaultFontParams( uint chart = KDCHART_ALL_CHARTS, + bool callSetPrintDataValues = true ); + + void setAllowOverlappingDataValueTexts( bool allow ) + { + _allowOverlappingDataValueTexts = allow; + } + + + bool allowOverlappingDataValueTexts() const + { + return _allowOverlappingDataValueTexts; + } + + bool printDataValuesWithDefaultFontParams( uint chart ) const + { + return chart ? _printDataValuesSettings2._useDefaultFontParams + : _printDataValuesSettings._useDefaultFontParams; + } + + bool printDataValues( uint chart ) const + { + return chart ? _printDataValuesSettings2._printDataValues + : _printDataValuesSettings._printDataValues; + } + + + int dataValuesDivPow10( uint chart ) const + { + return chart ? _printDataValuesSettings2._divPow10 + : _printDataValuesSettings._divPow10; + } + + + int dataValuesDigitsBehindComma( uint chart ) const + { + return chart ? _printDataValuesSettings2._digitsBehindComma + : _printDataValuesSettings._digitsBehindComma; + } + + + QFont dataValuesFont( uint chart ) const + { + return chart ? _printDataValuesSettings2._dataValuesFont + : _printDataValuesSettings._dataValuesFont; + } + + + bool dataValuesUseFontRelSize( uint chart ) const + { + return chart ? _printDataValuesSettings2._dataValuesUseFontRelSize + : _printDataValuesSettings._dataValuesUseFontRelSize; + } + + + int dataValuesFontRelSize( uint chart ) const + { + return chart ? _printDataValuesSettings2._dataValuesFontRelSize + : _printDataValuesSettings._dataValuesFontRelSize; + } + + + QColor dataValuesColor( uint chart ) const + { + return chart ? _printDataValuesSettings2._dataValuesColor + : _printDataValuesSettings._dataValuesColor; + } + + + QBrush dataValuesBackground( uint chart ) const + { + return chart ? _printDataValuesSettings2._dataValuesBrush + : _printDataValuesSettings._dataValuesBrush; + } + + + bool dataValuesAutoColor( uint chart ) const + { + return chart ? _printDataValuesSettings2._dataValuesAutoColor + : _printDataValuesSettings._dataValuesAutoColor; + } + + + KDChartEnums::PositionFlag dataValuesAnchorPosition( uint chart, + bool negative ) const; + uint dataValuesAnchorAlign( uint chart, bool negative ) const; + int dataValuesAnchorDeltaX( uint chart, bool negative ) const; + int dataValuesAnchorDeltaY( uint chart, bool negative ) const; + int dataValuesRotation( uint chart, bool negative ) const; + + KDChartEnums::TextLayoutPolicy dataValuesLayoutPolicy( uint chart ) const + { + return chart ? _printDataValuesSettings2._dataValuesLayoutPolicy + : _printDataValuesSettings._dataValuesLayoutPolicy; + } + + + bool dataValuesShowInfinite( uint chart ) const + { + return chart ? _printDataValuesSettings2._dataValuesShowInfinite + : _printDataValuesSettings._dataValuesShowInfinite; + } + + + // for backward compatibility we may NOT remove these functions: + void setPrintDataValuesColor( uint chart = KDCHART_ALL_CHARTS, + const QColor* color = KDCHART_DATA_VALUE_AUTO_COLOR ); + void setPrintDataValuesFontRelSize( uint chart, uint size ); + + + static QString markerStyleToString( int style ); + static QString markerStyleToStringTr( int style ); + static int stringToMarkerStyle( const QString& string ); + static int stringToMarkerStyleTr( const QString& string ); + + // END GENERAL + + +public: + + // BAR CHART-SPECIFIC + enum BarChartSubType { BarNormal, BarStacked, BarPercent, BarMultiRows }; + +public slots: + void setBarChartSubType( BarChartSubType barChartSubType ) + { + _barChartSubType = barChartSubType; + emit changed(); + } + + BarChartSubType barChartSubType() const + { + return _barChartSubType; + } + + + + + + static QString barChartSubTypeToString( BarChartSubType type ); + static BarChartSubType stringToBarChartSubType( const QString& string ); + + + void setThreeDBars( bool threeDBars ) + { + _threeDBars = threeDBars; + emit changed(); + } + + bool threeDBars() const + { + return _threeDBars; + } + + + void setThreeDBarsShadowColors( bool shadow ) + { + _threeDShadowColors = shadow; + emit changed(); + } + + + bool threeDBarsShadowColors() const + { + return _threeDShadowColors; + } + + + QColor dataShadow1Color( uint dataset ) const; + QColor dataShadow2Color( uint dataset ) const; + + + void setThreeDBarAngle( uint angle ); + uint threeDBarAngle() const + { + return _threeDBarAngle; + } + + + double cosThreeDBarAngle() const + { + return _cosThreeDBarAngle; + } + + + void setThreeDBarDepth( double depth ) + { + _threeDBarDepth = depth; + emit changed(); + } + + + double threeDBarDepth() const + { + return _threeDBarDepth; + } + + + void setDatasetGap( int gap ) + { + _datasetGap = gap; + emit changed(); + } + + int datasetGap() const + { + return _datasetGap; + } + + + void setDatasetGapIsRelative( bool gapIsRelative ) + { + _datasetGapIsRelative = gapIsRelative; + emit changed(); + } + + bool datasetGapIsRelative() const + { + return _datasetGapIsRelative; + } + + + void setValueBlockGap( int gap ) + { + _valueBlockGap = gap; + emit changed(); + } + + int valueBlockGap() const + { + return _valueBlockGap; + } + + + void setValueBlockGapIsRelative( bool gapIsRelative ) + { + _valueBlockGapIsRelative = gapIsRelative; + emit changed(); + } + + bool valueBlockGapIsRelative() const + { + return _valueBlockGapIsRelative; + } + + + void setBarWidth( int width = KDCHART_AUTO_SIZE ) + { + if ( width == KDCHART_AUTO_SIZE ) { + _barWidth = width; + _userWidth = 0; + } + else + _userWidth = width; + + emit changed(); + } + + + int barWidth() const + { + return _barWidth; + } + + int userWidth() const + { + return _userWidth; + } + + int numBarsDisplayed() const + { + return _barsDisplayed; + } + + int numBarsLeft() const + { + return _barsLeft; + } + + void setDrawSolidExcessArrows( bool solidArrows ) { + _solidExcessArrows = solidArrows; + emit changed(); + } + + bool drawSolidExcessArrows() const + { + return _solidExcessArrows; + } + + // END BAR CHART-SPECIFIC + +public: + // LINE/AREA CHART-SPECIFIC + enum LineChartSubType { LineNormal, LineStacked, LinePercent }; + +public slots: + void setLineChartSubType( LineChartSubType lineChartSubType ) + { + _lineChartSubType = lineChartSubType; + emit changed(); + } + + LineChartSubType lineChartSubType() const + { + return _lineChartSubType; + } + + + static LineChartSubType stringToLineChartSubType( const QString& string ); + static QString lineChartSubTypeToString( LineChartSubType type ); + + + void setLineMarker( bool marker ) + { + _lineMarker = marker; + emit changed(); + } + + bool lineMarker() const + { + return _lineMarker; + } + +public: + enum LineMarkerStyle { LineMarkerCircle = 0, + LineMarkerSquare = 1, + LineMarkerDiamond = 2, + LineMarker1Pixel = 3, + LineMarker4Pixels = 4, + LineMarkerRing = 5, + LineMarkerCross = 6, + LineMarkerFastCross = 7 }; + + // PENDING(blackie) Add a wrapper for this + typedef QMap<uint,LineMarkerStyle> LineMarkerStyleMap; +public slots: + + void setLineMarkerStyle( uint dataset, LineMarkerStyle style ); + void setLineMarkerStyles( LineMarkerStyleMap map ); + LineMarkerStyle lineMarkerStyle( uint dataset ) const; + + static QString lineMarkerStyleToString( LineMarkerStyle style ); + static QString lineMarkerStyleToStringTr( LineMarkerStyle style ); + static LineMarkerStyle stringToLineMarkerStyle( const QString& string ); + static LineMarkerStyle stringToLineMarkerStyleTr( const QString& string ); + + LineMarkerStyleMap lineMarkerStyles() const { + return _lineMarkerStyles; + } + + + uint maxDatasetLineMarkerStyle() const + { + return _maxDatasetLineMarkerStyle; + } + + + void setLineMarkerSize( QSize size ) + { + _lineMarkerSize = size; + emit changed(); + } + + QSize lineMarkerSize() const + { + return _lineMarkerSize; + } + + void setLineWidth( int width ) + { + _lineWidth = width; + emit changed(); + } + + int lineWidth() const + { + return _lineWidth; + } + + + void setLineColor( QColor color = QColor() ) + { + _lineColor = color; + emit changed(); + } + + QColor lineColor() const + { + return _lineColor; + } + + void setLineStyle( PenStyle style, uint dataset=KDCHART_GLOBAL_LINE_STYLE ); + + PenStyle lineStyle( uint dataset=KDCHART_GLOBAL_LINE_STYLE ) const; + + + void setThreeDLines( bool threeD ) { + _threeDLines = threeD; + emit changed(); + } + + + bool threeDLines() const { + return _threeDLines; + } + + + void setThreeDLineDepth( int depth ) { + _threeDLineDepth = depth; + emit changed(); + } + + + int threeDLineDepth() const { + return _threeDLineDepth; + } + + + // NOTE: documentation of this function is temporary disabled. + // Feature is currently not supported, will be implemented + // by future versions of KDChart + void setThreeDLineXRotation( int degrees ) { + _threeDLineXRotation = degrees; + emit changed(); + } + + + // NOTE: documentation of this function is temporary disabled. + // Feature is currently not supported, will be implemented + // by future versions of KDChart + int threeDLineXRotation() const { + return _threeDLineXRotation; + } + + + // NOTE: documentation of this function is temporary disabled. + // Feature is currently not supported, will be implemented + // by future versions of KDChart + void setThreeDLineYRotation( int degrees ) { + _threeDLineYRotation = degrees; + emit changed(); + } + + + // NOTE: documentation of this function is temporary disabled. + // Feature is currently not supported, will be implemented + // by future versions of KDChart + int threeDLineYRotation() const { + return _threeDLineYRotation; + } + +public: + enum AreaChartSubType { AreaNormal, AreaStacked, AreaPercent }; + +public slots: + void setAreaChartSubType( AreaChartSubType areaChartSubType ) + { + _areaChartSubType = areaChartSubType; + // activate default data value text settings for this chart type + if( printDataValues( 0 ) + && printDataValuesWithDefaultFontParams( 0 ) ) + setPrintDataValues( true, 0 ); + emit changed(); + } + + + AreaChartSubType areaChartSubType() const + { + return _areaChartSubType; + } + + + static QString areaChartSubTypeToString( AreaChartSubType type ); + static AreaChartSubType stringToAreaChartSubType( const QString& string ); + +public: + enum AreaLocation { AreaAbove, AreaBelow }; +public slots: + + void setAreaLocation( AreaLocation location ) + { + _areaLocation = location; + emit changed(); + } + + AreaLocation areaLocation() const + { + return _areaLocation; + } + + + static QString areaLocationToString( AreaLocation type ); + static AreaLocation stringToAreaLocation( const QString& string ); + + // END LINE/AREA CHART-SPECIFIC + +public: + // POLAR CHART-SPECIFIC + enum PolarChartSubType { PolarNormal, PolarStacked, PolarPercent }; + +public slots: + void setPolarChartSubType( PolarChartSubType polarChartSubType ) + { + _polarChartSubType = polarChartSubType; + emit changed(); + } + + PolarChartSubType polarChartSubType() const + { + return _polarChartSubType; + } + + + static PolarChartSubType stringToPolarChartSubType( const QString& string ); + static QString polarChartSubTypeToString( PolarChartSubType type ); + + void setPolarMarker( bool marker ) + { + _polarMarker = marker; + emit changed(); + } + + bool polarMarker() const + { + return _polarMarker; + } + +public: + enum PolarMarkerStyle { PolarMarkerCircle = 0, + PolarMarkerSquare = 1, + PolarMarkerDiamond = 2, + PolarMarker1Pixel = 3, + PolarMarker4Pixels = 4, + PolarMarkerRing = 5, + PolarMarkerCross = 6 }; + +public slots: + void setPolarMarkerStyle( uint dataset, PolarMarkerStyle style ); + PolarMarkerStyle polarMarkerStyle( uint dataset ) const; + static QString polarMarkerStyleToString( PolarMarkerStyle style ); + static QString polarMarkerStyleToStringTr( PolarMarkerStyle style ); + static PolarMarkerStyle stringToPolarMarkerStyle( const QString& string ); + static PolarMarkerStyle stringToPolarMarkerStyleTr( const QString& string ); + +public: + typedef QMap<uint,PolarMarkerStyle> PolarMarkerStyleMap; + +public slots: + void setPolarMarkerStyles( PolarMarkerStyleMap map ); + + PolarMarkerStyleMap polarMarkerStyles() const { + return _polarMarkerStyles; + } + + uint maxDatasetPolarMarkerStyle() const + { + return _maxDatasetPolarMarkerStyle; + } + + void setPolarMarkerSize( QSize size = QSize( -40, -40 ) ) + { + _polarMarkerSize = size; + emit changed(); + } + + QSize polarMarkerSize() const + { + return _polarMarkerSize; + } + + void setPolarLineWidth( int width = -3 ) + { + _polarLineWidth = width; + emit changed(); + } + + int polarLineWidth() const + { + return _polarLineWidth; + } + + + void setPolarZeroDegreePos( int degrees ) + { + _polarZeroDegreePos = degrees; + } + + int polarZeroDegreePos() const + { + return _polarZeroDegreePos; + } + + + void setPolarRotateCircularLabels( bool rotateCircularLabels ) + { + _polarRotateCircularLabels = rotateCircularLabels; + } + + bool polarRotateCircularLabels() const + { + return _polarRotateCircularLabels; + } + + + // Note if you change the parameters here, then you must also change them in wrappers/KDChartParametersWrapper.h + void setPolarDelimsAndLabelsAtPos( KDChartEnums::PositionFlag pos, + bool showDelimiters, + bool showLabels ); + + // Note if you change the parameters here, then you must also change them in wrappers/KDChartParametersWrapper.h + bool polarDelimAtPos( KDChartEnums::PositionFlag pos ) const; + + // Note if you change the parameters here, then you must also change them in wrappers/KDChartParametersWrapper.h + bool polarLabelsAtPos( KDChartEnums::PositionFlag pos ) const; + + // END POLAR CHART-SPECIFIC + + + // PIE/RING CHART-SPECIFIC + + void setExplode( bool explode ) + { + _explode = explode; + emit changed(); + } + + bool explode() const + { + return _explode; + } + + + void setExplodeValues( QValueList<int> explodeList ) { + _explodeList = explodeList; + emit changed(); + } + + + // Unfortunately this is not avaialble from QSA- + QValueList<int> explodeValues() const { + return _explodeList; + } + +public: + typedef QMap<int,double> ExplodeFactorsMap; + +public slots: + void setExplodeFactors( ExplodeFactorsMap factors ) { + _explodeFactors = factors; + emit changed(); + } + + + ExplodeFactorsMap explodeFactors() const { + return _explodeFactors; + } + + + void setExplodeFactor( double factor ) + { + _explodeFactor = factor; + emit changed(); + } + + double explodeFactor() const + { + return _explodeFactor; + } + + + void setThreeDPies( bool threeDPies ) + { + _threeDPies = threeDPies; + emit changed(); + } + + bool threeDPies() const + { + return _threeDPies; + } + + + void setThreeDPieHeight( int pixels ) + { + _threeDPieHeight = pixels; + emit changed(); + } + + int threeDPieHeight() const + { + return _threeDPieHeight; + } + + void setPieStart( int degrees ) + { + while ( degrees < 0 ) + degrees += 360; + while ( degrees >= 360 ) + degrees -= 360; + _pieStart = degrees; + + emit changed(); + } + + + int pieStart() const + { + return _pieStart; + } + + void setRingStart( int degrees ) + { + while ( degrees < 0 ) + degrees += 360; + while ( degrees >= 360 ) + degrees -= 360; + _ringStart = degrees; + + emit changed(); + } + + + int ringStart() const + { + return _ringStart; + } + + void setRelativeRingThickness( bool relativeThickness ) { + _relativeRingThickness = relativeThickness; + + emit changed(); + } + + + bool relativeRingThickness() const { + return _relativeRingThickness; + } + + // END PIE/RING CHART-SPECIFIC + +public: + // HI/LO CHART-SPECIFIC + enum HiLoChartSubType { HiLoNormal, HiLoSimple = HiLoNormal, + HiLoClose, HiLoOpenClose }; + +public slots: + void setHiLoChartSubType( HiLoChartSubType hiLoChartSubType ) + { + _hiLoChartSubType = hiLoChartSubType; + emit changed(); + } + + HiLoChartSubType hiLoChartSubType() const + { + return _hiLoChartSubType; + } + + static QString hiLoChartSubTypeToString( HiLoChartSubType type ); + static HiLoChartSubType stringToHiLoChartSubType( const QString& string ); + void setHiLoChartPrintLowValues( bool active, + QFont* font = 0, + int size = 14, + QColor* color = 0 ); + + bool hiLoChartPrintLowValues() const + { + return _hiLoChartPrintLowValues; + } + + + QFont hiLoChartLowValuesFont() const + { + return _hiLoChartLowValuesFont; + } + + + bool hiLoChartLowValuesUseFontRelSize() const + { + return _hiLoChartLowValuesUseFontRelSize; + } + + + int hiLoChartLowValuesFontRelSize() const + { + return _hiLoChartLowValuesFontRelSize; + } + + + QColor hiLoChartLowValuesColor() const + { + return _hiLoChartLowValuesColor; + } + + void setHiLoChartPrintHighValues( bool active, + QFont* font = 0, + int size = 14, + QColor* color = 0 ); + + + bool hiLoChartPrintHighValues() const + { + return _hiLoChartPrintHighValues; + } + + + QFont hiLoChartHighValuesFont() const + { + return _hiLoChartHighValuesFont; + } + + + bool hiLoChartHighValuesUseFontRelSize() const + { + return _hiLoChartHighValuesUseFontRelSize; + } + + + int hiLoChartHighValuesFontRelSize() const + { + return _hiLoChartHighValuesFontRelSize; + } + + + QColor hiLoChartHighValuesColor() const + { + return _hiLoChartHighValuesColor; + } + + void setHiLoChartPrintOpenValues( bool active, + QFont* font = 0, + uint size = 14, + QColor* color = 0 ); + + bool hiLoChartPrintOpenValues() const + { + return _hiLoChartPrintOpenValues; + } + + + QFont hiLoChartOpenValuesFont() const + { + return _hiLoChartOpenValuesFont; + } + + + bool hiLoChartOpenValuesUseFontRelSize() const + { + return _hiLoChartOpenValuesUseFontRelSize; + } + + + int hiLoChartOpenValuesFontRelSize() const + { + return _hiLoChartOpenValuesFontRelSize; + } + + + QColor hiLoChartOpenValuesColor() const + { + return _hiLoChartOpenValuesColor; + } + + void setHiLoChartPrintCloseValues( bool active, + QFont* font = 0, + int size = 14, + QColor* color = 0 ); + + bool hiLoChartPrintCloseValues() const + { + return _hiLoChartPrintCloseValues; + } + + + QFont hiLoChartCloseValuesFont() const + { + return _hiLoChartCloseValuesFont; + } + + + bool hiLoChartCloseValuesUseFontRelSize() const + { + return _hiLoChartCloseValuesUseFontRelSize; + } + + + int hiLoChartCloseValuesFontRelSize() const + { + return _hiLoChartCloseValuesFontRelSize; + } + + + QColor hiLoChartCloseValuesColor() const + { + return _hiLoChartCloseValuesColor; + } + + + void setHiLoChartPrintFirstValues( bool active, + QFont* font = 0, + uint size = 14, + QColor* color = 0 ) + { + setHiLoChartPrintOpenValues( active, font, size, color ); + } + + bool hiLoChartPrintFirstValues() const + { + return hiLoChartPrintOpenValues(); + } + + + QFont hiLoChartFirstValuesFont() const + { + return hiLoChartOpenValuesFont(); + } + + + bool hiLoChartFirstValuesUseFontRelSize() const + { + return hiLoChartOpenValuesUseFontRelSize(); + } + + int hiLoChartFirstValuesFontRelSize() const + { + return hiLoChartOpenValuesFontRelSize(); + } + + QColor hiLoChartFirstValuesColor() const + { + return hiLoChartOpenValuesColor(); + } + + void setHiLoChartPrintLastValues( bool active, + QFont* font = 0, + int size = 14, + QColor* color = 0 ) + { + setHiLoChartPrintCloseValues( active, font, size, color ); + } + + bool hiLoChartPrintLastValues() const + { + return hiLoChartPrintCloseValues(); + } + + QFont hiLoChartLastValuesFont() const + { + return hiLoChartCloseValuesFont(); + } + + bool hiLoChartLastValuesUseFontRelSize() const + { + return hiLoChartCloseValuesUseFontRelSize(); + } + + int hiLoChartLastValuesFontRelSize() const + { + return hiLoChartCloseValuesFontRelSize(); + } + + QColor hiLoChartLastValuesColor() const + { + return hiLoChartCloseValuesColor(); + } + + + // END HI/LO CHART-SPECIFIC + + +public: + // BOX WHISKER CHART-SPECIFIC + enum BWChartSubType { BWNormal, BWSimple = BWNormal }; + + enum BWStatVal { BWStatValSTART, + UpperOuterFence = BWStatValSTART, // first value stored in array + UpperInnerFence, + Quartile3, + Median, + Quartile1, + LowerInnerFence, + LowerOuterFence, + MaxValue, + MeanValue, + MinValue, + BWStatValEND = MinValue, // last value stored in array + // extra values - not stored in the array: + BWStatValOffEndValue, // the number of array values + BWStatValALL, // special flag reprsenting *all* array values + BWStatValUNKNOWN }; // to be returned when value is undefined +public slots: + + void setBWChartSubType( BWChartSubType bWChartSubType ) + { + _BWChartSubType = bWChartSubType; + emit changed(); + } + + BWChartSubType bWChartSubType() const + { + return _BWChartSubType; + } + + static QString bWChartSubTypeToString( BWChartSubType type ); + static BWChartSubType stringToBWChartSubType( const QString& string ); + static QString bWChartStatValToString( BWStatVal type ); + static BWStatVal stringToBWChartStatVal( const QString& string ); + + void setBWChartFences( double upperInner, double lowerInner, + double upperOuter, double lowerOuter ); + void bWChartFences( double& upperInner, double& lowerInner, + double& upperOuter, double& lowerOuter ) const; + + void setBWChartBrush( const QBrush& bWChartBrush ) + { + _BWChartBrush = bWChartBrush; + emit changed(); + } + + QBrush bWChartBrush() const + { + return _BWChartBrush; + } + + void setBWChartOutValMarkerSize( int size ) + { + _BWChartOutValMarkerSize = size; + } + + + int bWChartOutValMarkerSize() const + { + return _BWChartOutValMarkerSize; + } + + void setBWChartPrintStatistics( BWStatVal statValue, + bool active, + QFont* font = 0, + int size = 24, + QColor* color = 0, + QBrush* brush = 0 ); + + bool bWChartPrintStatistics( BWStatVal statValue ) const + { + return _BWChartStatistics[ statValue ].active; + } + + + QFont bWChartStatisticsFont( BWStatVal statValue ) const + { + return _BWChartStatistics[ statValue ].font; + } + + + bool bWChartStatisticsUseRelSize( BWStatVal statValue ) const + { + return _BWChartStatistics[ statValue ].useRelSize; + } + + + int bWChartStatisticsFontRelSize( BWStatVal statValue ) const + { + return _BWChartStatistics[ statValue ].relSize; + } + + + QColor bWChartStatisticsColor( BWStatVal statValue ) const + { + return _BWChartStatistics[ statValue ].color; + } + + QBrush bWChartStatisticsBrush( BWStatVal statValue ) const + { + return _BWChartStatistics[ statValue ].brush; + } + + +public: + // LEGENDS + + enum LegendPosition { NoLegend, LegendTop, LegendBottom, + LegendLeft, LegendRight, + LegendTopLeft, + LegendTopLeftTop, + LegendTopLeftLeft, + LegendTopRight, + LegendTopRightTop, + LegendTopRightRight, + LegendBottomLeft, + LegendBottomLeftBottom, + LegendBottomLeftLeft, + LegendBottomRight, + LegendBottomRightBottom, + LegendBottomRightRight + }; + +public slots: + void setLegendPosition( LegendPosition position ) + { + _legendPosition = position; + emit changed(); + } + + LegendPosition legendPosition() const + { + return _legendPosition; + } + + void setLegendOrientation( Orientation orientation ) + { + _legendOrientation = orientation; + emit changed(); + } + + Orientation legendOrientation() const + { + return _legendOrientation; + } + + + void setLegendShowLines( bool legendShowLines ) + { + _legendShowLines = legendShowLines; + emit changed(); + } + + bool legendShowLines() const + { + return _legendShowLines; + } + + + static QString legendPositionToString( LegendPosition pos ); + static LegendPosition stringToLegendPosition( const QString& string ); + +public: + enum LegendSource { LegendManual, LegendFirstColumn, LegendAutomatic }; + +public slots: + void setLegendSource( LegendSource source ) + { + _legendSource = source; + emit changed(); + } + + LegendSource legendSource() const + { + return _legendSource; + } + + static QString legendSourceToString( LegendSource source ); + static LegendSource stringToLegendSource( const QString& string ); + + void setLegendText( uint dataset, const QString& text ) + { + _legendText[ dataset ] = text; + emit changed(); + } + + QString legendText( uint dataset ) const + { + if( _legendText.find( dataset ) != _legendText.end() ) + return _legendText[ dataset ]; + else + return QString::null; + } + + + void setLegendTextColor( const QColor& color ) + { + _legendTextColor = color; + emit changed(); + } + + + QColor legendTextColor() const + { + return _legendTextColor; + } + + + void setLegendFont( const QFont& font, bool useFontSize ) + { + _legendFont = font; + _legendFontUseRelSize = ! useFontSize; + emit changed(); + } + + QFont legendFont() const + { + return _legendFont; + } + + + void setLegendFontUseRelSize( bool legendFontUseRelSize ) + { + _legendFontUseRelSize = legendFontUseRelSize; + emit changed(); + } + + bool legendFontUseRelSize() const + { + return _legendFontUseRelSize; + } + + void setLegendFontRelSize( int legendFontRelSize ) + { + _legendFontRelSize = legendFontRelSize; + emit changed(); + } + + int legendFontRelSize() const + { + return _legendFontRelSize; + } + + + void setLegendTitleText( const QString& text ) + { + _legendTitleText = text; + emit changed(); + } + + + QString legendTitleText() const + { + return _legendTitleText; + } + + + void setLegendTitleTextColor( const QColor& color ) + { + _legendTitleTextColor = color; + emit changed(); + } + + + QColor legendTitleTextColor() const + { + return _legendTitleTextColor; + } + + + + void setLegendTitleFont( const QFont& font, bool useFontSize ) + { + _legendTitleFont = font; + _legendTitleFontUseRelSize = ! useFontSize; + emit changed(); + } + + QFont legendTitleFont() const + { + return _legendTitleFont; + } + + + void setLegendTitleFontUseRelSize( bool legendTitleFontUseRelSize ) + { + _legendTitleFontUseRelSize = legendTitleFontUseRelSize; + emit changed(); + } + + bool legendTitleFontUseRelSize() const + { + return _legendTitleFontUseRelSize; + } + + void setLegendTitleFontRelSize( int legendTitleFontRelSize ) + { + _legendTitleFontRelSize = legendTitleFontRelSize; + emit changed(); + } + + int legendTitleFontRelSize() const + { + return _legendTitleFontRelSize; + } + + + void setLegendSpacing( uint space ) + { + _legendSpacing = space; + } + + + uint legendSpacing() const + { + return _legendSpacing; + } + + // END LEGENDS + + + + // AXES + + // Note if you change the parameters here, then you must also change them in wrappers/KDChartParametersWrapper.h + void setAxisType( uint n, const KDChartAxisParams::AxisType axisType ) + { + if ( n < KDCHART_MAX_AXES ) { + _axisSettings[ n ].params.setAxisType( axisType ); + emit changed(); + } + } + + void setAxisVisible( uint n, + const bool axisVisible ) + { + if ( n < KDCHART_MAX_AXES ) { + _axisSettings[ n ].params.setAxisVisible( axisVisible ); + emit changed(); + } + } + + bool axisVisible( uint n ) const + { + return n < KDCHART_MAX_AXES ? _axisSettings[ n ].params.axisVisible() + : false; + } + + void setAxisShowGrid( uint n, + bool axisShowGrid ); + bool showGrid() const; + void setAxisDatasets( uint n, + uint dataset, + uint dataset2 = KDCHART_NO_DATASET, + uint chart = 0 ); + bool axisDatasets( uint n, + uint& dataset, + uint& dataset2, + uint& chart ) const; + +public: +#if COMPAT_QT_VERSION >= 0x030000 + typedef QValueVector<uint> AxesArray; +#else + typedef QArray<uint> AxesArray; +#endif + +public slots: + bool chartAxes( uint chart, uint& cnt, AxesArray& axes ) const; + + void setAxisArea( const uint n, const QRect& areaRect ) + { + if ( n < KDCHART_MAX_AXES ) { + _axisSettings[ n ].params.setAxisTrueAreaRect( areaRect ); + // Do not do emit changed() here! + } + } + + void setAxisLabelsTouchEdges( uint n, bool axisLabelsTouchEdges ) + { + _axisSettings[ n ].params.setAxisLabelsTouchEdges( + axisLabelsTouchEdges ); + emit changed(); + } + + void setAxisLabelsVisible( uint n, + bool axisLabelsVisible ) + { + if ( n < KDCHART_MAX_AXES ) + _axisSettings[ n ].params.setAxisLabelsVisible( axisLabelsVisible ); + } + + void setAxisLabelsFont( uint n, + QFont axisLabelsFont, + int axisLabelsFontSize = 0, + QColor axisLabelsColor = Qt::black ); + + // Note if you change the parameters here, then you must also change them in wrappers/KDChartParametersWrapper.h + void setAxisLabelTextParams( uint n, + bool axisSteadyValueCalc = true, + QVariant axisValueStart = KDCHART_AXIS_LABELS_AUTO_LIMIT, + QVariant axisValueEnd = KDCHART_AXIS_LABELS_AUTO_LIMIT, + double axisValueDelta = KDCHART_AXIS_LABELS_AUTO_DELTA, + int axisDigitsBehindComma = KDCHART_AXIS_LABELS_AUTO_DIGITS, + int axisMaxEmptyInnerSpan = 67, + KDChartAxisParams::LabelsFromDataRow takeLabelsFromDataRow + = KDChartAxisParams::LabelsFromDataRowNo, + int labelTextsDataRow = 0, + QStringList* axisLabelStringList = 0, + QStringList* axisShortLabelsStringList = 0, + int axisValueLeaveOut = KDCHART_AXIS_LABELS_AUTO_LEAVEOUT, + KDChartAxisParams::ValueScale axisValueDeltaScale = KDChartAxisParams::ValueScaleNumerical ) + { + _axisSettings[ n ].params.setAxisValues( + axisSteadyValueCalc, + axisValueStart, + axisValueEnd, + axisValueDelta, + axisDigitsBehindComma, + axisMaxEmptyInnerSpan, + takeLabelsFromDataRow, + labelTextsDataRow, + axisLabelStringList, + axisShortLabelsStringList, + axisValueLeaveOut, + axisValueDeltaScale ); + emit changed(); + } + + + void setAxisLabelStringParams( uint n, + QStringList* axisLabelStringList, + QStringList* axisShortLabelStringList, + const QString& valueStart = QString::null, + const QString& valueEnd = QString::null ); + + + void setAxisParams( uint n, + const KDChartAxisParams& axisParams ); + + const KDChartAxisParams& axisParams( uint n ) const + { + return n < KDCHART_MAX_AXES ? _axisSettings[ n ].params + : _axisSettings[ KDCHART_MAX_AXES ].params; + } + + // some convenience functions refering to the first KDChartCustomBox + // that is anchored to the axis n. + bool findFirstAxisCustomBoxID( uint n, uint& boxID ) const; + void setAxisTitle( uint n, const QString& axisTitle ); + + QString axisTitle( uint n ) const; + void setAxisTitleColor( uint n, QColor axisTitleColor ); + QColor axisTitleColor( uint n ) const; + void setAxisTitleFont( uint n, QFont axisTitleFont ); + void setAxisTitleFont( uint n, QFont axisTitleFont, bool useFixedFontSize ); + QFont axisTitleFont( uint n ) const; + void setAxisTitleFontUseRelSize( uint n, bool useRelSize ); + bool axisTitleFontUseRelSize( uint n ) const; + void setAxisTitleFontRelSize( uint n, int axisTitleFontRelSize ); + int axisTitleFontRelSize( uint n ) const; + + QRect axisArea( const uint n ) const + { + if ( n < KDCHART_MAX_AXES ) { + return _axisSettings[ n ].params.axisTrueAreaRect(); + // Do not do emit changed() here! + }else{ + return QRect(QPoint(0,0),QSize(0,0)); + } + } + // END AXES + + + + QRect dataArea() const { return _dataAreaRect; } + QRect legendArea() const { return _legendAreaRect; } + + + + // HEADERS/FOOTERS + +public: + + /* + READ before changing/enhancing the following enum + ================================================= + + Please note: The following enum is made in a way that + sections with smaller Y values come first. + Thus one can construct a loop itterating over theHdFtPos values + and so going from the top of the screen toiwards the bottom... + + Also please note that extending this enum shound NOT break the + tripple groups (numbers 0/1/2, 3/4/5, and 6/7/8) since the + algorithms in + KDChartPainter::setupGeometry() and + KDChartPainter::paintHeaderFooter() rely on this schema. + Also don't forget to always update the auxiliary values + HdFtPosSTART, HdFtPosHeadersSTART, + HdFtPosHeadersEND, HdFtPosFootersSTART, + HdFtPosFootersEND, and HdFtPosEND muessen - these are used + fpr other itarators... + */ + enum HdFtPos{ // start of all sections + HdFtPosSTART = 0, + + // headers: + HdFtPosHeadersSTART = 0, + // top-most headers + HdFtPosHeaders0START = 0, + HdFtPosHeader0 = 0, + HdFtPosHeader0L = 1, + HdFtPosHeader0R = 2, + HdFtPosHeaders0END = 2, + // normal ( == middle ) headers + HdFtPosHeaders1START = 3, + HdFtPosHeader = 3, // center + HdFtPosHeaderL = 4, // left + HdFtPosHeaderR = 5, // right + HdFtPosHeaders1END = 5, + // bottom headers + HdFtPosHeaders2START = 6, + HdFtPosHeader2 = 6, + HdFtPosHeader2L = 7, + HdFtPosHeader2R = 8, + HdFtPosHeaders2END = 8, + + HdFtPosHeadersEND = 8, + + // footers: + HdFtPosFootersSTART = 9, + // normal ( == middle ) footers + HdFtPosFooters1START = 9, + HdFtPosFooter = 9, + HdFtPosFooterL = 10, + HdFtPosFooterR = 11, + HdFtPosFooters1END = 11, + // bottom footers + HdFtPosFooters2START = 12, + HdFtPosFooter2 = 12, + HdFtPosFooter2L = 13, + HdFtPosFooter2R = 14, + HdFtPosFooters2END = 14, + // top-most footers + HdFtPosFooters0START = 15, + HdFtPosFooter0 = 15, + HdFtPosFooter0L = 16, + HdFtPosFooter0R = 17, + HdFtPosFooters0END = 17, + + HdFtPosFootersEND = 17, + + HdFtPosEND = 17 }; + +public slots: + + void setHeaderFooterText( uint pos, const QString& text ); + QString headerFooterText( uint pos ) const; + const QRect& headerFooterRect( uint pos ) const; + void setHeaderFooterColor( uint pos, const QColor color ); + QColor headerFooterColor( uint pos ) const; + void setHeaderFooterFont( uint pos, const QFont& font, + bool fontUseRelSize, + int fontRelSize ); + QFont headerFooterFont( uint pos ) const; + bool headerFooterFontUseRelSize( uint pos ) const; + int headerFooterFontRelSize( uint pos ) const; + + + // quick&dirty functions: access Header, Header2 and Footer + // without having to specify the HdFtPos + // + // This may be convenient for specifying simple charts with + // up to two centered header(s) and up to one centered footer. + + + void setHeader1Text( const QString& text ) + { + _hdFtParams[ HdFtPosHeader ]._text = text; + emit changed(); + } + + + QString header1Text() const + { + return _hdFtParams[ HdFtPosHeader ]._text; + } + + void setHeader1Font( const QFont& font ) + { + _hdFtParams[ HdFtPosHeader ]._font = font; + emit changed(); + } + + + QFont header1Font() const + { + return _hdFtParams[ HdFtPosHeader ]._font; + } + + void setHeader2Text( const QString& text ) + { + _hdFtParams[ HdFtPosHeader2 ]._text = text; + emit changed(); + } + + + QString header2Text() const + { + return _hdFtParams[ HdFtPosHeader2 ]._text; + } + + void setHeader2Font( const QFont& font ) + { + _hdFtParams[ HdFtPosHeader2 ]._font = font; + emit changed(); + } + + + QFont header2Font() const + { + return _hdFtParams[ HdFtPosHeader2 ]._font; + } + + + + void setFooterText( const QString& text ) + { + _hdFtParams[ HdFtPosFooter ]._text = text; + emit changed(); + } + + + QString footerText() const + { + return _hdFtParams[ HdFtPosFooter ]._text; + } + + void setFooterFont( const QFont& font ) + { + _hdFtParams[ HdFtPosFooter ]._font = font; + emit changed(); + } + + + QFont footerFont() const + { + return _hdFtParams[ HdFtPosFooter ]._font; + } + + + /** + \internal + */ + void __internalStoreHdFtRect( int pos, QRect rect ) + { + if ( 0 <= pos && HdFtPosEND >= pos ) + _hdFtParams[ pos ].setRect( rect ); + } + + + // END HEADERS/FOOTERS + + + +public: + KDChartParams(); + virtual ~KDChartParams(); + +public slots: + void loadAxesFormXML(int& curAxisSettings, QDomElement& element); + bool loadXML( const QDomDocument& doc ); + + void saveAxesToXML(QDomDocument& doc, QDomElement& docRoot) const; + QDomDocument saveXML( bool withPI = true ) const; + +public: + friend QTextStream& operator<<( QTextStream& s, const KDChartParams& p ); + friend QTextStream& operator>>( QTextStream& s, KDChartParams& p ); + +public slots: + static void createChartValueNode( QDomDocument& doc, QDomNode& parent, + const QString& elementName, + const QVariant& valY, + const QVariant& valX, + const int& propID ); + static void createColorMapNode( QDomDocument& doc, QDomNode& parent, + const QString& elementName, + const QMap< uint, QColor >& map ); + static void createDoubleMapNode( QDomDocument& doc, QDomNode& parent, + const QString& elementName, + const QMap< int, double >& map ); + static void createChartFontNode( QDomDocument& doc, QDomNode& parent, + const QString& elementName, + const QFont& font, bool useRelFont, + int relFont, + int minFont=-1 ); + static bool readColorMapNode( const QDomElement& element, + QMap<uint,QColor>* map ); + static bool readDoubleMapNode( const QDomElement& element, + QMap<int,double>* map ); + static bool readChartFontNode( const QDomElement& element, QFont& font, + bool& useRelFont, int& relFontSize, + int* minFontSize=0 ); + static bool readChartValueNode( const QDomElement& element, + QVariant& valY, + QVariant& valX, + int& propID ); + + + // do *not* call this function manually: it is used by KDChartPainter::setupGeometry() + void setDataArea( const QRect& areaRect ) + { + _dataAreaRect = areaRect; + // Do not do emit changed() here! + } + // do *not* call this function manually: it is used by KDChartPainter::setupGeometry() + void setLegendArea( const QRect& areaRect ) + { + _legendAreaRect = areaRect; + // Do not do emit changed() here! + } + + +signals: + void changed(); + + +protected: + void setBarsDisplayed( int barsDisplayed ) + { + _barsDisplayed = barsDisplayed; + } + void setBarsLeft( int barsLeft ) + { + _barsLeft = barsLeft; + } + + +private: + QString dataRegionFrameAreaName( uint dataRow, + uint dataCol, + uint data3rd ); + void recomputeShadowColors(); + void insertDefaultAxisTitleBox( uint n, + bool setTitle, const QString& axisTitle, + bool setColor, const QColor& axisTitleColor, + bool setFont, const QFont& axisTitleFont, + bool setFontUseRel, bool useFontSize, + bool setFontRelSize, int axisTitleFontRelSize ); + + static QColor _internalPointer_DataValueAutoColor; + + KDChartPropertySet* tempPropSetA; + KDChartPropertySet* tempPropSetB; + + bool _optimizeOutputForScreen; + int _globalLeadingLeft; + int _globalLeadingTop; + int _globalLeadingRight; + int _globalLeadingBottom; + ChartType _chartType; + ChartType _additionalChartType; + int _numValues; + QFont _defaultFont; + + typedef QDict < KDChartFrameSettings > AreaDict; + AreaDict _areaDict; + + CustomBoxDict _customBoxDict; + bool _customBoxDictMayContainHoles; + QRect _noRect; + KDFrame _noFrame; + + KDChartFrameSettings _noFrameSettings; + + class ModeAndChart + { + public: + ModeAndChart() + : _mode( UnknownMode ), _chart( KDCHART_NO_CHART ) + {} + ModeAndChart( SourceMode mode, uint chart ) + : _mode( mode ), _chart( chart ) + {} + + SourceMode mode() const + { + return _mode; + }; + uint chart() const + { + return _chart; + }; + + void setMode( SourceMode mode ) + { + _mode = mode; + }; + void setChart( uint chart ) + { + _chart = chart; + }; + private: + SourceMode _mode; + uint _chart; + }; + + typedef QMap < uint, ModeAndChart > ModeAndChartMap; + ModeAndChartMap _dataSourceModeAndChart; + bool _setChartSourceModeWasUsed; + QMap < uint, QColor > _dataColors; + uint _maxDatasetSourceMode; + KDChartPropertySetList _propertySetList; + double _shadowBrightnessFactor; + Qt::BrushStyle _shadowPattern; + bool _threeDShadowColors; + uint _maxDatasetColor; + QMap < uint, QColor > _dataColorsShadow1; + QMap < uint, QColor > _dataColorsShadow2; + QColor _outlineDataColor; + uint _outlineDataLineWidth; + PenStyle _outlineDataLineStyle; + + + struct PrintDataValuesSettings { + bool _printDataValues; + int _divPow10; + int _digitsBehindComma; + QFont _dataValuesFont; + bool _dataValuesUseFontRelSize; + int _dataValuesFontRelSize; + QColor _dataValuesColor; + QBrush _dataValuesBrush; + bool _dataValuesAutoColor; + KDChartEnums::PositionFlag _dataValuesAnchorNegativePosition; + uint _dataValuesAnchorNegativeAlign; + int _dataValuesAnchorNegativeDeltaX; + int _dataValuesAnchorNegativeDeltaY; + int _dataValuesNegativeRotation; + KDChartEnums::PositionFlag _dataValuesAnchorPositivePosition; + uint _dataValuesAnchorPositiveAlign; + int _dataValuesAnchorPositiveDeltaX; + int _dataValuesAnchorPositiveDeltaY; + int _dataValuesPositiveRotation; + KDChartEnums::TextLayoutPolicy _dataValuesLayoutPolicy; + bool _dataValuesShowInfinite; + + bool _useDefaultFontParams; // internal flag, do NOT store it! + }; + PrintDataValuesSettings _printDataValuesSettings; + PrintDataValuesSettings _printDataValuesSettings2; + + bool _allowOverlappingDataValueTexts; + BarChartSubType _barChartSubType; + bool _threeDBars; + int _threeDBarAngle; + double _threeDBarDepth; + double _cosThreeDBarAngle; + int _datasetGap; + bool _datasetGapIsRelative; + int _valueBlockGap; + bool _valueBlockGapIsRelative; + int _barWidth; + int _userWidth; + bool _solidExcessArrows; + // volatile bar chart information, not saved in the stream + QRect _dataAreaRect; + QRect _legendAreaRect; + int _barsDisplayed; + int _barsLeft; + + // LINES/AREAS-specific + LineChartSubType _lineChartSubType; + bool _threeDLines; + int _threeDLineDepth; + int _threeDLineXRotation; + int _threeDLineYRotation; + bool _lineMarker; + LineMarkerStyleMap _lineMarkerStyles; + uint _maxDatasetLineMarkerStyle; + QSize _lineMarkerSize; + QColor _lineColor; + int _lineWidth; + PenStyle _lineStyle; + typedef QMap<uint, PenStyle> LineStyleMap; + LineStyleMap _datasetLineStyles; + AreaChartSubType _areaChartSubType; + AreaLocation _areaLocation; + + + // POLAR-specific + PolarChartSubType _polarChartSubType; + bool _polarMarker; + PolarMarkerStyleMap _polarMarkerStyles; + uint _maxDatasetPolarMarkerStyle; + QSize _polarMarkerSize; + int _polarLineWidth; + int _polarZeroDegreePos; + bool _polarRotateCircularLabels; + struct _polarDelimsAndLabelStruct { + bool showDelimiters; + bool showLabels; + }; + _polarDelimsAndLabelStruct _polarDelimsAndLabels[ 1 + KDCHART_MAX_POLAR_DELIMS_AND_LABELS_POS ]; + + + + // PIES/RINGS + bool _explode; + double _explodeFactor; + ExplodeFactorsMap _explodeFactors; + QValueList<int> _explodeList; + bool _threeDPies; + int _threeDPieHeight; + int _pieStart; + int _ringStart; + bool _relativeRingThickness; + + + // HI-LO CHARTS + + HiLoChartSubType _hiLoChartSubType; + bool _hiLoChartPrintLowValues; + QFont _hiLoChartLowValuesFont; + bool _hiLoChartLowValuesUseFontRelSize; + int _hiLoChartLowValuesFontRelSize; + QColor _hiLoChartLowValuesColor; + bool _hiLoChartPrintHighValues; + QFont _hiLoChartHighValuesFont; + bool _hiLoChartHighValuesUseFontRelSize; + int _hiLoChartHighValuesFontRelSize; + QColor _hiLoChartHighValuesColor; + bool _hiLoChartPrintOpenValues; + QFont _hiLoChartOpenValuesFont; + bool _hiLoChartOpenValuesUseFontRelSize; + int _hiLoChartOpenValuesFontRelSize; + QColor _hiLoChartOpenValuesColor; + bool _hiLoChartPrintCloseValues; + QFont _hiLoChartCloseValuesFont; + bool _hiLoChartCloseValuesUseFontRelSize; + int _hiLoChartCloseValuesFontRelSize; + QColor _hiLoChartCloseValuesColor; + + + + // BOX AND WHISKER CHARTS + + BWChartSubType _BWChartSubType; + + struct BWChartStatistics { + double value; + int y; + bool active; + QFont font; + bool useRelSize; + int relSize; + QColor color; + QBrush brush; + }; + BWChartStatistics _BWChartStatistics[ BWStatValOffEndValue ]; + double _BWChartFenceUpperInner; + double _BWChartFenceLowerInner; + double _BWChartFenceUpperOuter; + double _BWChartFenceLowerOuter; + int _BWChartOutValMarkerSize; + QBrush _BWChartBrush; + + + // LEGENDS + + LegendPosition _legendPosition; + Qt::Orientation _legendOrientation; + bool _legendShowLines; + LegendSource _legendSource; + QMap < int, QString > _legendText; + QColor _legendTextColor; + QFont _legendFont; + bool _legendFontUseRelSize; + int _legendFontRelSize; + QString _legendTitleText; + QColor _legendTitleTextColor; + QFont _legendTitleFont; + bool _legendTitleFontUseRelSize; + int _legendTitleFontRelSize; + uint _legendSpacing; + + + // AXES (private) + // Must be exported because of the inline methods + struct KDCHART_EXPORT AxisSettings + { + uint dataset; + uint dataset2; + uint chart; + KDChartAxisParams params; + AxisSettings() + { + dataset = KDCHART_NO_DATASET; + dataset2 = KDCHART_NO_DATASET; + chart = KDCHART_NO_CHART; + } + }; + + // 13 == KDCHART_MAX_AXES + 1 + AxisSettings _axisSettings[ 13 ]; + // END AXES (private) + + + // HEADER/FOOTER (private) + // Must be exported because of the inline methods + struct KDCHART_EXPORT HdFtParams + { + QString _text; + QColor _color; + QFont _font; + bool _fontUseRelSize; + int _fontRelSize; + HdFtParams() + { + _color = QColor( Qt::black ); + _font = QFont( "helvetica", 10, QFont::Normal, false ); + _fontUseRelSize = true; + _fontRelSize = 8; // per default quite small + } + void setRect( QRect rect ) + { + _rect = rect; + } + const QRect& rect() const + { + return _rect; + } + private: + // temporary data that are NOT to be stored within sessions: + QRect _rect; + }; + + HdFtParams _hdFtParams[ HdFtPosEND + 1 ]; + // END HEADER/FOOTER (private) +}; + + +QTextStream& operator<<( QTextStream& s, const KDChartParams& p ); + + +QTextStream& operator>>( QTextStream& s, KDChartParams& p ); + + +#endif |