From 8362bf63dea22bbf6736609b0f49c152f975eb63 Mon Sep 17 00:00:00 2001 From: tpearson Date: Wed, 20 Jan 2010 01:29:50 +0000 Subject: Added old abandoned KDE3 version of koffice git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/applications/koffice@1077364 283d02a7-25f6-0310-bc7c-ecb5cbfe19da --- kchart/kdchart/KDChartParams.cpp | 9564 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 9564 insertions(+) create mode 100644 kchart/kdchart/KDChartParams.cpp (limited to 'kchart/kdchart/KDChartParams.cpp') diff --git a/kchart/kdchart/KDChartParams.cpp b/kchart/kdchart/KDChartParams.cpp new file mode 100644 index 00000000..94fd117e --- /dev/null +++ b/kchart/kdchart/KDChartParams.cpp @@ -0,0 +1,9564 @@ +/* -*- 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. + ** + **********************************************************************/ +#include +#include +#include +#include +#include +#include +#include +#ifndef KDCHART_MASTER_CVS +#include "KDChartParams.moc" +#endif + +class KDChartData; + +//#include + +/** + \class KDChartParams KDChartParams.h + \brief Bundles the display parameters of a chart. + + Bundles all parameters of a chart including the type except the + actual data displayed. Serializing an object of this type plus the + data displayed is enough to be able to recreate the chart later. + */ + + + +//QColor KDChartParams::_internalPointer_DataValueAutoColor = QColor( 0,1,0 ); + +KDChartAutoColor* KDChartAutoColor::mInstance = NULL; + +KDChartAutoColor::KDChartAutoColor() +{ +} + +KDChartAutoColor::KDChartAutoColor( KDChartAutoColor const& ) +{ +} + +KDChartAutoColor::~KDChartAutoColor() +{ +} + +const KDChartAutoColor* KDChartAutoColor::instance() +{ + if( mInstance == 0 ) + mInstance = new KDChartAutoColor(); + return mInstance; +} + +void KDChartAutoColor::freeInstance() +{ + if( mInstance ) + delete mInstance; + mInstance = 0; +} + + +/* +static QColor defaultColor; +QT_STATIC_CONST_IMPL QColor & KDChartParams_AutoColor = defaultColor; +*/ + +/** + Constructor. Defines default values. + */ +KDChartParams::KDChartParams() +{ + tempPropSetA = new KDChartPropertySet(); + tempPropSetB = new KDChartPropertySet(); + + // GENERAL + + // Avoid Purify UMR + _maxDatasetColor = 1; + _maxDatasetSourceMode = 0; + _setChartSourceModeWasUsed = false; + + _customBoxDictMayContainHoles = false; + + // Set the default font params flag for data value texts + // but do *not* call setPrintDataValues() there since + // this will be called internally by setChartType() below. + setPrintDataValuesWithDefaultFontParams( KDCHART_ALL_CHARTS, false ); + _printDataValuesSettings._dataValuesShowInfinite = true; + _printDataValuesSettings2._dataValuesShowInfinite = true; + + setAllowOverlappingDataValueTexts( false ); + +#if COMPAT_QT_VERSION >= 0x030100 + setOptimizeOutputForScreen( false ); +#else + setOptimizeOutputForScreen( true ); +#endif + + setGlobalLeading( 0,0,0,0 ); + + + // Default type is bar charts + setChartType( Bar ); + + // By default, there is no additional chart type + setAdditionalChartType( NoType ); + + // Default is to show all values. + setNumValues( static_cast( -1 ) ); + + _defaultFont = QFont( "helvetica", 8, QFont::Normal, false ); + + // The default frame settings: no border, no corners, no background + _noFrame.clearAll(); + + // The default frame settings: no inner gap, no outer gap and use the _noFrame + // *** no need to initialize _noFrameSettings: it is initialized by a default c'tor! + + // The default brightness of shadow colors (needs to be set + // before the data colors to avoid an UMR). + setShadowBrightnessFactor( 1.0 ); + + // The default shadow fill style. + setShadowPattern( Qt::SolidPattern ); + + // Some default colors for the data. + setDataDefaultColors(); + + // Default color for data display outlines. + setOutlineDataColor( black ); + + // Default line width for data display outlines. + setOutlineDataLineWidth( 1 ); + + // Default line style for data display outlines. + setOutlineDataLineStyle( Qt::SolidLine ); + + // END GENERAL + + + setDataArea( QRect( QPoint(0,0), QSize(0,0)) ); + setLegendArea(QRect( QPoint(0,0), QSize(0,0)) ); + + + // BAR CHART-SPECIFIC + + // Default bar subtype is normal + setBarChartSubType( BarNormal ); + + // Default is not to draw 3D bars + setThreeDBars( false ); + + // Default is to used shadowed colors for 3D bar effects + setThreeDBarsShadowColors( true ); + + // Default angle for 3D bars is 45 degrees. + setThreeDBarAngle( 45 ); + + // Default depth of 3D bars is 1.0 + setThreeDBarDepth( 1.0 ); + + // Default gap between datasets is 6 per mille of chart data area. + setDatasetGap( 6 ); + setDatasetGapIsRelative( true ); + + // Default gap between value blocks is 24 per mille of chart data area. + setValueBlockGap( 24 ); + setValueBlockGapIsRelative( true ); + + // Default is to have the bar width's calculated indiidually + setBarWidth( KDCHART_AUTO_SIZE ); + // reset the special indicator members storing the number + // of bars that were drawn last time / could not be drawn + // due to too less horizontal space + setBarsDisplayed( 0 ); + setBarsLeft( 0 ); + + // By default, excess arrows are drawn in a split fashion + setDrawSolidExcessArrows( false ); + + // END BAR CHART-SPECIFIC + + + // LINE/AREA CHART-SPECIFIC + // Normal lines by default + setLineChartSubType( LineNormal ); + + // No markers by default + setLineMarker( false ); + + // Lines have a width of 1 pixel by default + setLineWidth( 1 ); + + // Lines are solid by default + setLineStyle( Qt::SolidLine ); + + // Lines have the same color as their + // respective data points by default + setLineColor(); + + + // Default line marker styles and size + _maxDatasetLineMarkerStyle = 0; // avoid UMR + setLineMarkerStyle( 0, LineMarkerCircle ); + setLineMarkerStyle( 1, LineMarkerSquare ); + setLineMarkerStyle( 2, LineMarkerDiamond ); + setLineMarkerSize( QSize( 6, 6 ) ); + + // 3D line settings + setThreeDLines( false ); + setThreeDLineDepth( 10 ); + /* temporary disabled: + setThreeDLineXRotation( 30 ); + setThreeDLineYRotation( 30 ); + */ + setThreeDLineXRotation( 15 ); + setThreeDLineYRotation( 15 ); + + // Normal areas by default + setAreaChartSubType( AreaNormal ); + + // Areas are filled below the value points by default. + setAreaLocation( AreaBelow ); + + // END LINE/AREA CHART-SPECIFIC + + // POLAR CHART-SPECIFIC + // Normal polar charts by default + setPolarChartSubType( PolarNormal ); + + // Have markers by default + setPolarMarker( true ); + + // Polar charts show the zero point at the right side of the circle + setPolarZeroDegreePos( 0 ); + + // Lines have a width of 3/1000 of the chart's min size + // (either width or height) by default + setPolarLineWidth( -3 ); + + // Default polar marker styles and size + _maxDatasetPolarMarkerStyle = 0; // avoid UMR + setPolarMarkerStyle( 0, PolarMarkerCircle ); + setPolarMarkerStyle( 1, PolarMarkerSquare ); + setPolarMarkerStyle( 2, PolarMarkerDiamond ); + setPolarMarkerSize( QSize( -40,-40 ) ); + + // default circular axes delimiters + setPolarRotateCircularLabels( false ); + setPolarDelimsAndLabelsAtPos( KDChartEnums::PosTopLeft, false, false ); + setPolarDelimsAndLabelsAtPos( KDChartEnums::PosTopCenter, true, true ); + setPolarDelimsAndLabelsAtPos( KDChartEnums::PosTopRight, false, false ); + + setPolarDelimsAndLabelsAtPos( KDChartEnums::PosCenterLeft, false, false ); + setPolarDelimsAndLabelsAtPos( KDChartEnums::PosCenterRight, false, false ); + + setPolarDelimsAndLabelsAtPos( KDChartEnums::PosBottomLeft, false, false ); + setPolarDelimsAndLabelsAtPos( KDChartEnums::PosBottomCenter, true, true ); + setPolarDelimsAndLabelsAtPos( KDChartEnums::PosBottomRight, false, false ); + + + /* for test: + setPolarDelimsAndLabelsAtPos( KDChartEnums::PosTopLeft, true, true ); + setPolarDelimsAndLabelsAtPos( KDChartEnums::PosTopCenter, true, true ); + setPolarDelimsAndLabelsAtPos( KDChartEnums::PosTopRight, true, true ); + setPolarDelimsAndLabelsAtPos( KDChartEnums::PosCenterRight, true, true ); + setPolarDelimsAndLabelsAtPos( KDChartEnums::PosBottomRight, true, true ); + setPolarDelimsAndLabelsAtPos( KDChartEnums::PosBottomCenter, true, true ); + setPolarDelimsAndLabelsAtPos( KDChartEnums::PosBottomLeft, true, true ); + setPolarDelimsAndLabelsAtPos( KDChartEnums::PosCenterLeft, true, true ); + */ + + + // END POLAR CHART-SPECIFIC + + // PIE/RING CHART-SPECIFIC + // Pie/ring charts do not explode by default. + setExplode( false ); + // But if they do, the explode factor is 10% + setExplodeFactor( 0.1 ); + // setExplodeValues() is not called for initialization, the default + // empty list is the default. + // Flat pies by default + setThreeDPies( false ); + // Height of 3D effect + setThreeDPieHeight( 20 ); + // Start of pie circle + setPieStart( 0 ); + // Start of ring circle + setRingStart( 0 ); + // Ring thickness is constant by default + setRelativeRingThickness( false ); + // END PIE/RING CHART-SPECIFIC + + + // HILO CHART-SPECIFIC + // Simple HiLo charts by default + setHiLoChartSubType( KDChartParams::HiLoSimple ); + setHiLoChartPrintLowValues( false ); + setHiLoChartPrintHighValues( false ); + setHiLoChartPrintOpenValues( false ); + setHiLoChartPrintCloseValues( false ); + + + // BOX+WHISKER CHART-SPECIFIC + // Simple Box-and-Whisker charts by default + setBWChartSubType( KDChartParams::BWSimple ); + setBWChartFences(1.5, 1.5, 3.0, 3.0); + setBWChartOutValMarkerSize( -25 ); + setBWChartPrintStatistics( BWStatValALL, false ); + setBWChartBrush( Qt::white ); + + // LEGEND + // Distance between legend and data. + setLegendSpacing( 20 ); + // Position of the legend + setLegendPosition( LegendRight ); + // Orientation of the legend + setLegendOrientation( Qt::Vertical ); + // Whether the legend shall show lines or just + // show the markers (or squares, resp.) + setLegendShowLines( false ); + // Where the legend labels come from + setLegendSource( LegendAutomatic ); + // legend texts are drawn in black by default + setLegendTextColor( Qt::black ); + // legend font size is calculated dynamically, but ignore the font size + setLegendFont( QFont( "helvetica", 10, QFont::Normal, false ), false ); + // legend font size is calculated dynamically: + // 40 / 1000 of the minimal value of + // the printable area height and width + setLegendFontRelSize( 40 ); + // the default legend title is "Legend" + setLegendTitleText( tr( "Legend" ) ); + // legend title is drawn in black by default + setLegendTitleTextColor( Qt::black ); + // legend title font size is calculated dynamically, but ignore + // the font size + setLegendTitleFont( QFont( "helvetica", 12, QFont::Normal, false ), false ); + // legend title font size is calculated dynamically: + // 50 / 1000 of the minimal value of + // the printable area height and width + setLegendTitleFontRelSize( 50 ); + // END LEGEND + + + // AXES + + setDefaultAxesTypes(); + // activate bottom (ordinate) and left (abcissa) axis + activateDefaultAxes(); + + // END AXES + + + // HEADERS/FOOTERS + + // Set a default font for all sections not taking the build-in + // defaults from c'tor KDChartParams::HdFtParams::HdFtParams() + QFont defaultHdFtFont( "helvetica", 14, QFont::Normal, false ); + int relHd0Size = 15; + int relHdSize = 22; + int relHd2Size = 19; + + int relFt0Size = 15; + int relFtSize = 19; + int relFt2Size = 12; + setHeaderFooterFont( KDChartParams::HdFtPosHeader0, + defaultHdFtFont, true, relHd0Size ); + setHeaderFooterFont( KDChartParams::HdFtPosHeader0L, + defaultHdFtFont, true, relHd0Size ); + setHeaderFooterFont( KDChartParams::HdFtPosHeader0R, + defaultHdFtFont, true, relHd0Size ); + setHeaderFooterFont( KDChartParams::HdFtPosHeader, + defaultHdFtFont, true, relHdSize ); + setHeaderFooterFont( KDChartParams::HdFtPosHeaderL, + defaultHdFtFont, true, relHdSize ); + setHeaderFooterFont( KDChartParams::HdFtPosHeaderR, + defaultHdFtFont, true, relHdSize ); + setHeaderFooterFont( KDChartParams::HdFtPosHeader2, + defaultHdFtFont, true, relHd2Size ); + setHeaderFooterFont( KDChartParams::HdFtPosHeader2L, + defaultHdFtFont, true, relHd2Size ); + setHeaderFooterFont( KDChartParams::HdFtPosHeader2R, + defaultHdFtFont, true, relHd2Size ); + + setHeaderFooterFont( KDChartParams::HdFtPosFooter0, + defaultHdFtFont, true, relFt0Size ); + setHeaderFooterFont( KDChartParams::HdFtPosFooter0L, + defaultHdFtFont, true, relFt0Size ); + setHeaderFooterFont( KDChartParams::HdFtPosFooter0R, + defaultHdFtFont, true, relFt0Size ); + setHeaderFooterFont( KDChartParams::HdFtPosFooter, + defaultHdFtFont, true, relFtSize ); + setHeaderFooterFont( KDChartParams::HdFtPosFooterL, + defaultHdFtFont, true, relFtSize ); + setHeaderFooterFont( KDChartParams::HdFtPosFooterR, + defaultHdFtFont, true, relFtSize ); + setHeaderFooterFont( KDChartParams::HdFtPosFooter2, + defaultHdFtFont, true, relFt2Size ); + setHeaderFooterFont( KDChartParams::HdFtPosFooter2L, + defaultHdFtFont, true, relFt2Size ); + setHeaderFooterFont( KDChartParams::HdFtPosFooter2R, + defaultHdFtFont, true, relFt2Size ); + // END HEADERS/FOOTERS + + // PROPERTY SETS + tempPropSetA->fullReset("normal data"); + setProperties(KDCHART_PROPSET_NORMAL_DATA, *tempPropSetA); + // don't show the line, don't show the marker + tempPropSetA->setName("transparent data"); + tempPropSetA->setLineStyle( KDChartPropertySet::OwnID, Qt::NoPen ); + tempPropSetA->setShowMarker( KDChartPropertySet::OwnID, false ); + setProperties(KDCHART_PROPSET_TRANSPARENT_DATA, *tempPropSetA); + // don't show line nor marker, but do show the horizontal line + tempPropSetA->setName("horizontal line"); + tempPropSetA->setExtraLinesAlign( KDChartPropertySet::OwnID, Qt::AlignLeft | Qt::AlignRight ); + setProperties(KDCHART_PROPSET_HORI_LINE, *tempPropSetA); + // don't show line nor marker, but do show the vertical line + tempPropSetA->setName("vertical line"); + tempPropSetA->setExtraLinesAlign( KDChartPropertySet::OwnID, Qt::AlignTop | Qt::AlignBottom ); + setProperties(KDCHART_PROPSET_VERT_LINE, *tempPropSetA); + // END PROPERTY SETS +} + + +/** + Destructor. Only defined to have it virtual. + */ +KDChartParams::~KDChartParams() +{ + KDChartAutoColor::freeInstance(); + delete tempPropSetA; + delete tempPropSetB; +} + + +// GENERAL +/** @name General parameters. + + These methods set general parameters that apply to several or all chart types. + */ +//@{ + + +/** + Stores a new property set: data are stored by value so you may + use your \c rSet instance for other purpose later... + + \returns The property set's ID to be used for later retrieving + the property information by calling the properties() function + or for assigning these properties to a data cell - either in the + KDChartData constructor or by calling KDChartData::setPropertySet(). + + \note The property set's ID may also be retrieved by calling + set.id() after calling registerProperties( set ) + + \note The predefined (build-in) property ids (like KDCHART_PROPSET_NORMAL_DATA + and KDCHART_PROPSET_TRANSPARENT_DATA) must not be registered + but should be used without further initialization. + + \sa KDCHART_PROPSET_NORMAL_DATA, KDCHART_PROPSET_TRANSPARENT_DATA + \sa KDCHART_PROPSET_HORI_LINE, KDCHART_PROPSET_VERT_LINE + \sa KDChartData::setPropertySet + \sa removeProperties + */ +int KDChartParams::registerProperties( KDChartPropertySet& rSet ) +{ + _propertySetList.setAutoDelete( true ); + rSet.mOwnID = _propertySetList.count(); + _propertySetList.insert( rSet.mOwnID, rSet.clone() ); + return rSet.mOwnID; +} + +/** + Overwrites a property set with a new property set. + + \note This function might also be used to initialy store + a property set using a specific ID number, but note + that another property set having the same number + would be replaced by this property set automatically. Therefor + in general it is better to use the registerProperties function + to initially obtain a unique ID number for your new property set. + + \returns TRUE if the property set had been stored before, + or FALSE if the set was now stored initially. + + \sa KDCHART_PROPSET_TRANSPARENT_DATA + \sa KDCHART_PROPSET_HORI_LINE, KDCHART_PROPSET_VERT_LINE + \sa KDChartData::setPropertySet + \sa removeProperties + */ +void KDChartParams::setProperties( int id, KDChartPropertySet& rSet ) +{ + _propertySetList.setAutoDelete( true ); + rSet.mOwnID = id; + _propertySetList.replace( rSet.mOwnID, rSet.clone() ); +} + +/** + Removes a property set from the registry + that was registered via registerProperties(). + + \note It is not possible to remove the build-in default property set: + function calls using KDCHART_PROPSET_NORMAL_DATA as ID + will be ignored. + + \returns TRUE if the property set was found and removed, or FALSE + if the set was not found or KDCHART_PROPSET_NORMAL_DATA + was specified as ID value. + + \sa registerProperties, setProperties + */ +bool KDChartParams::removeProperties( int id ) +{ + _propertySetList.setAutoDelete( true ); + // Removing the default property set is not allowed! + if( KDCHART_PROPSET_NORMAL_DATA == id ) + return false; + return _propertySetList.remove( id ); +} + + +/** + Retrieves the values specified for a property set that + was stored by registerProperties(). + + Use this function to retrieve the exact specification + of a property set. + + Don't use this function to retrieve the properties that are + valid for a given data cell but use KDChartParams::calculateProperties() + instead. + + \note This function does not return a pointer + to the property set itself but a copy of the data + stored therein. To change a stored property set + you may use the setProperties() function. + + \returns TRUE if the property set was found, FALSE + if it no property set was registred with this ID. + + \sa registerProperties, KDChartData::setPropertySet + */ +bool KDChartParams::properties( int id, KDChartPropertySet& rSet ) const +{ + const KDChartPropertySet* R = _propertySetList.find( id ); + const bool bFound = (0 != R); + if( bFound ) + rSet.deepCopy( R ); + return bFound; +} + + +/** + Retrieves the internal property set object that + created when you called registerProperties(). + + Use this function to access a property set for modifying it directly. + + Don't use this function to retrieve the properties that are + valid for a given data cell but use KDChartParams::calculateProperties() + instead. + + \note This function does return a pointer + to the property set itself, so you can directly modify its contents. + However you have to make sure NOT to delete this pointer, + since KDChartParams is owning it, so it would try to free + the pointer again later, most likely resulting in a program crash. + To delete a stored property set you may use the removeProperties() function. + + \returns A pointer to the internally stored property set if the property set was found, + Zero if no property set was registred with this ID. + + \sa registerProperties, removeProperties, KDChartData::setPropertySet + */ +KDChartPropertySet* KDChartParams::properties( int id ) +{ + return _propertySetList.find( id ); +} + + +/** + Retrieves the values that correspond to a property set by + reading this set's properties and obtaining other property + set's values if necessary (according to ID numbers that might + be stored in the property set). + + Use this function to retrieve the properties that are + valid for a given data cell. + + Don't use this function to retrieve the exact specification + of a property set but use KDChartParams::properties() instead. + + \returns TRUE if the property set was found, FALSE + if it no property set was registred with this ID. + + \sa registerProperties, KDChartData::setPropertySet + */ +bool KDChartParams::calculateProperties( int startId, KDChartPropertySet& rSet ) const +{ + KDChartPropertySet& startSet = *tempPropSetA; + startSet.quickReset(""); + + rSet.deepCopy( &startSet ); // reset all properties of rSet to the default !! + +//qDebug("in KDChartParams::calculateProperties():"); +//qDebug(" startId: %i",startId); +//qDebug(" startSet: %s",startSet.name().latin1()); + + bool bOk = properties(startId, startSet); + if( bOk ){ + int lineWidth; + QColor lineColor; + Qt::PenStyle lineStyle; + bool showMarker; + uint markerAlign; + QSize markerSize; + QColor markerColor; + int markerStyle; + uint extraLinesAlign; + bool extraLinesInFront; + int extraLinesLength; + int extraLinesWidth; + QColor extraLinesColor; + Qt::PenStyle extraLinesStyle; + uint extraMarkersAlign; + QSize extraMarkersSize; + QColor extraMarkersColor; + int extraMarkersStyle; + bool showBar; + QColor barColor; + QBrush areaBrush; + // c'tor sets all IDs to unknown by default + KDChartPropertySet& propSet = *tempPropSetB; + propSet.quickReset(""); + // PENDING(khz) replace the rustic depth counter i by a smart way + // to quickly and safely recognize forbidden circular ID dependencies + // *without* using this artificial maximal tree depth limitation. + const int maxDepth = 1000; + int i; + int id; + // retrieve lineWidth + propSet.deepCopy( &startSet ); i=0; + do{ + if( propSet.hasOwnLineWidth( id, lineWidth ) ){ + rSet.setLineWidth( KDChartPropertySet::OwnID, lineWidth ); + break; + }else if( KDChartPropertySet::UndefinedID == id || maxDepth < i ) + break; + ++i; + }while( properties(id, propSet) ); + // retrieve lineColor + propSet.deepCopy( &startSet ); i=0; + do{ + if( propSet.hasOwnLineColor( id, lineColor ) ){ + rSet.setLineColor( KDChartPropertySet::OwnID, lineColor ); + break; + }else if( KDChartPropertySet::UndefinedID == id || maxDepth < i ) + break; + ++i; + }while( properties(id, propSet) ); + // retrieve lineStyle + propSet.deepCopy( &startSet ); i=0; + do{ + if( propSet.hasOwnLineStyle( id, lineStyle ) ){ + rSet.setLineStyle( KDChartPropertySet::OwnID, lineStyle ); + break; + }else if( KDChartPropertySet::UndefinedID == id || maxDepth < i ) + break; + ++i; + }while( properties(id, propSet) ); + + // markers at cell value position: + + // retrieve showMarker + propSet.deepCopy( &startSet ); i=0; + do{ + if( propSet.hasOwnShowMarker( id, showMarker ) ){ + rSet.setShowMarker( KDChartPropertySet::OwnID, showMarker ); + break; + }else if( KDChartPropertySet::UndefinedID == id || maxDepth < i ) + break; + ++i; + }while( properties(id, propSet) ); + // retrieve marker alignment + propSet.deepCopy( &startSet ); i=0; + do{ + if( propSet.hasOwnMarkerAlign( id, markerAlign ) ){ + rSet.setMarkerAlign( KDChartPropertySet::OwnID, markerAlign ); + break; + }else if( KDChartPropertySet::UndefinedID == id || maxDepth < i ) + break; + ++i; + }while( properties(id, propSet) ); + // retrieve marker size + propSet.deepCopy( &startSet ); i=0; + do{ + if( propSet.hasOwnMarkerSize( id, markerSize ) ){ + rSet.setMarkerSize( KDChartPropertySet::OwnID, markerSize ); + break; + }else if( KDChartPropertySet::UndefinedID == id || maxDepth < i ) + break; + ++i; + }while( properties(id, propSet) ); + // retrieve marker color + propSet.deepCopy( &startSet ); i=0; + do{ + if( propSet.hasOwnMarkerColor( id, markerColor ) ){ + rSet.setMarkerColor( KDChartPropertySet::OwnID, markerColor ); + break; + }else if( KDChartPropertySet::UndefinedID == id || maxDepth < i ) + break; + ++i; + }while( properties(id, propSet) ); + // retrieve marker style + propSet.deepCopy( &startSet ); i=0; + do{ + if( propSet.hasOwnMarkerStyle( id, markerStyle ) ){ + rSet.setMarkerStyle( KDChartPropertySet::OwnID, markerStyle ); + break; + }else if( KDChartPropertySet::UndefinedID == id || maxDepth < i ) + break; + ++i; + }while( properties(id, propSet) ); + + // extra lines: + + // retrieve alignment of extra lines + propSet.deepCopy( &startSet ); i=0; + do{ + if( propSet.hasOwnExtraLinesAlign( id, extraLinesAlign ) ){ + rSet.setExtraLinesAlign( KDChartPropertySet::OwnID, extraLinesAlign ); + break; + }else if( KDChartPropertySet::UndefinedID == id || maxDepth < i ) + break; + ++i; + }while( properties(id, propSet) ); + // retrieve whether the extra lines shall be printed in front of the normal lines + propSet.deepCopy( &startSet ); i=0; + do{ + if( propSet.hasOwnExtraLinesInFront( id, extraLinesInFront ) ){ + rSet.setExtraLinesInFront( KDChartPropertySet::OwnID, extraLinesInFront ); + break; + }else if( KDChartPropertySet::UndefinedID == id || maxDepth < i ) + break; + ++i; + }while( properties(id, propSet) ); + // retrieve lineLength + propSet.deepCopy( &startSet ); i=0; + do{ + if( propSet.hasOwnExtraLinesLength( id, extraLinesLength ) ){ + rSet.setExtraLinesLength( KDChartPropertySet::OwnID, extraLinesLength ); + break; + }else if( KDChartPropertySet::UndefinedID == id || maxDepth < i ) + break; + ++i; + }while( properties(id, propSet) ); + // retrieve lineWidth + propSet.deepCopy( &startSet ); i=0; + do{ + if( propSet.hasOwnExtraLinesWidth( id, extraLinesWidth ) ){ + rSet.setExtraLinesWidth( KDChartPropertySet::OwnID, extraLinesWidth ); + break; + }else if( KDChartPropertySet::UndefinedID == id || maxDepth < i ) + break; + ++i; + }while( properties(id, propSet) ); + // retrieve lineColor + propSet.deepCopy( &startSet ); i=0; + do{ + if( propSet.hasOwnExtraLinesColor( id, extraLinesColor ) ){ + rSet.setExtraLinesColor( KDChartPropertySet::OwnID, extraLinesColor ); + break; + }else if( KDChartPropertySet::UndefinedID == id || maxDepth < i ) + break; + ++i; + }while( properties(id, propSet) ); + // retrieve lineStyle + propSet.deepCopy( &startSet ); i=0; + do{ + if( propSet.hasOwnExtraLinesStyle( id, extraLinesStyle ) ){ + rSet.setExtraLinesStyle( KDChartPropertySet::OwnID, extraLinesStyle ); + break; + }else if( KDChartPropertySet::UndefinedID == id || maxDepth < i ) + break; + ++i; + }while( properties(id, propSet) ); + + // markers at the ends of the extra lines: + + // retrieve marker alignment + propSet.deepCopy( &startSet ); i=0; + do{ + if( propSet.hasOwnExtraMarkersAlign( id, extraMarkersAlign ) ){ + rSet.setExtraMarkersAlign( KDChartPropertySet::OwnID, extraMarkersAlign ); + break; + }else if( KDChartPropertySet::UndefinedID == id || maxDepth < i ) + break; + ++i; + }while( properties(id, propSet) ); + // retrieve marker size + propSet.deepCopy( &startSet ); i=0; + do{ + if( propSet.hasOwnExtraMarkersSize( id, extraMarkersSize ) ){ + rSet.setExtraMarkersSize( KDChartPropertySet::OwnID, extraMarkersSize ); + break; + }else if( KDChartPropertySet::UndefinedID == id || maxDepth < i ) + break; + ++i; + }while( properties(id, propSet) ); + // retrieve marker color + propSet.deepCopy( &startSet ); i=0; + do{ + if( propSet.hasOwnExtraMarkersColor( id, extraMarkersColor ) ){ + rSet.setExtraMarkersColor( KDChartPropertySet::OwnID, extraMarkersColor ); + break; + }else if( KDChartPropertySet::UndefinedID == id || maxDepth < i ) + break; + ++i; + }while( properties(id, propSet) ); + // retrieve marker style + propSet.deepCopy( &startSet ); i=0; + do{ + if( propSet.hasOwnExtraMarkersStyle( id, extraMarkersStyle ) ){ + rSet.setExtraMarkersStyle( KDChartPropertySet::OwnID, extraMarkersStyle ); + break; + }else if( KDChartPropertySet::UndefinedID == id || maxDepth < i ) + break; + ++i; + }while( properties(id, propSet) ); + + // retrieve showBar + propSet.deepCopy( &startSet ); i=0; + do{ + if( propSet.hasOwnShowBar( id, showBar ) ){ + rSet.setShowBar( KDChartPropertySet::OwnID, showBar ); + break; + }else if( KDChartPropertySet::UndefinedID == id || maxDepth < i ) + break; + ++i; + }while( properties(id, propSet) ); + // retrieve barColor + propSet.deepCopy( &startSet ); i=0; + do{ + if( propSet.hasOwnBarColor( id, barColor ) ){ + rSet.setBarColor( KDChartPropertySet::OwnID, barColor ); + break; + }else if( KDChartPropertySet::UndefinedID == id || maxDepth < i ) + break; + ++i; + }while( properties(id, propSet) ); + + // retrieve areaBrush + propSet.deepCopy( &startSet ); i=0; + do{ + if( propSet.hasOwnAreaBrush( id, areaBrush ) ){ + rSet.setAreaBrush( KDChartPropertySet::OwnID, areaBrush ); + break; + }else if( KDChartPropertySet::UndefinedID == id || maxDepth < i ) + break; + ++i; + }while( properties(id, propSet) ); + + } + return bOk; +} + + +/** + \fn int KDChartParams::roundVal(double) + + Returns the parameter \c d rounded to the nearest integer. + */ + + + +/** + Specifies if and how a chart will print the data value texts near + their respective entries. + + Data value texts will be printed immediately after drawing all of + the chart data points (or bars, lines,...) but before drawing the + legend and before drawing any custom boxes. If more than one chart + ist to be drawn (sharing the same data area) printing of the data + text values will take place after drawing all of the last charts + data points, this enables us to see the texts even if their + respective data representations are covered by the second charts + drawings. The same covering/colliding problem might occur with Area + charts if one area is (partially) covering another area. In such + cases you might either want to specify an appropriate + TextLayoutPolicy for getting a better looking result or specify an + other text color for data value texts of the second chart since by + default the first chart has black texts while the second chart + shows its data value texts in dark blue color. + + \note Only used if chartType() is neither HiLo nor + BoxWhisker. To specify printing of data values in a HiLo chart + please use setHiLoChartPrintLowValues, setHiLoChartPrintHighValues, + setHiLoChartPrintOpenValues, setHiLoChartPrintCloseValues. To + specify printing of data values in a BoxWhisker chart please use + setBWChartPrintStatistics. + + Calling setPrintDataValues( false ) will deactivate + printing of the values. + + Calling setPrintDataValuesWithDefaultFontParams( chart ) will + reset the respective font size and colour and position + parameters (but not the QFont itself) and activate printing + of the values for the \c chart speficied (or for all charts by + using \c KDCHART_ALL_CHARTS, resp.). + + \param active specifies whether the value texts are to be printed or not. + \param chart The number of the chart: 0 for the first chart, 1 for + the second chart in case there are two charts to be drawn sharing the + same data area. Use the special value KDCHART_ALL_CHARTS + to specify that your settings are to be taken for both charts. + \param divPow10 The power of 10 which the data value is to be divided by. + A value of 2 means divide by 100, a value of -3 means multiply by 1000, + and 0 (by definition) would result in multiplying by 1. + \param digitsBehindComma The number of digits to show behind the comma, + to have this calculated automatically just use the default value + KDCHART_DATA_VALUE_AUTO_DIGITS. + \param font a Pointer to the font to be used, if zero the default data value + texts font will be taken (this is a Times font since small Times digits are + clearer than small Helvetica digits). + + Changing of one or more of the following parameters + automatically de-activates all future font parameter adjustments + that would otherwise take place after each call of setChartType (or + setAdditionalChartType, resp.). To re-enable this usefull feature + you may call setPrintDataValuesWithDefaultFontParams at any time + afterwards. + + \param size (in per mille of the chart width) the dynamic size of + the font to be used. If this parameter is zero the size of the + \c font is used instead - regardless of the size of the chart! + You may use setPrintDataValuesFontRelSize to change this parameter setting + without affecting the other ones. + \param color the color to be used when printing the values. + To have the color calculated automatically - useful when printing + inside the bars (or pie slices, areas, ... resp.) - please use + \c KDCHART_DATA_VALUE_AUTO_COLOR instead of a QColor*. + You may use setPrintDataValuesColor to change this parameter setting + without affecting the other ones. + + The following parameters apply to values less than zero only: + + \param negativePosition The anchor position which the text is to be +aligned to. +\param negativeAlign The way how the text is to be aligned to the anchor. +This must be a reasonable combination of Qt::AlignmentFlags. +\param negativeDeltaX The X distance between the anchor +point -- specified by \c negativePosition (or \c + positivePosition, resp.) -- and the internal alignment point +of the text -- specified by \c negativeAlign (or \c positiveAlign, + resp.). Note: For better compatibility to the dynamic font +size this parameter is interpreted as being a per-cent value of the +used font height. If greater 0, the X position is increased, if +less than 0, it is reduced. Actual font size and thus also this +delta value are calculated dynamically before painting based on the +size of the chart and the specification made via parameter \c size. + +\param negativeDeltaY The Y distance between the anchor +point -- specified by \c negativePosition (or \c + positivePosition, resp.) -- and the internal alignment point +of the text -- specified by \c negativeAlign (or \c positiveAlign, + resp.). Note: For better compatibility to the dynamic font +size this parameter is interpreted as being a per-cent value of the +used font height. If greater 0, the Y position is increased, if +less than 0, it is reduced. Actual font size and thus also this +delta value are calculated dynamically before painting based on the +size of the chart and the specification made via parameter \c size. +\param negativeRotation The amount of degrees (using a circle of + 360 degrees) taken to rotate the text. Positive values rotate +clockwise, negative values rotate counter-clockwise. There are two +special values that you might find usefull for Pie charts or for +Ring charts: \c KDCHART_SAGGITAL_ROTATION and \c +KDCHART_TANGENTIAL_ROTATION both leading to individual +calculation of appropriate rotation for each data value. Rotation +will be performed around the internal alignment point of the +text -- specified by \c negativeAlign (or \c positiveAlign, resp.). + +The following parameters apply to values greater than zero or equal zero: + +\param positivePosition The anchor position which the text is to be +aligned to. +\param positiveAlign The way how the text is to be aligned to the anchor. +This must be a reasonable combination of Qt::AlignmentFlags. +\param negativeDeltaX The X distance between the anchor +point -- specified by \c negativePosition (or \c + positivePosition, resp.) -- and the internal alignment point +of the text -- specified by \c negativeAlign (or \c positiveAlign, + resp.). Note: For better compatibility to the dynamic font +size this parameter is interpreted as being a per-cent value of the +used font height. If greater 0, the X position is increased, if +less than 0, it is reduced. Actual font size and thus also this +delta value are calculated dynamically before painting based on the +size of the chart and the specification made via parameter \c size. +\param positiveDeltaY The Y distance between the anchor +point -- specified by \c negativePosition (or \c + positivePosition, resp.) -- and the internal alignment point +of the text -- specified by \c negativeAlign (or \c positiveAlign, + resp.). Note: For better compatibility to the dynamic font +size this parameter is interpreted as being a per-cent value of the +used font height. If greater 0, the Y position is increased, if +less than 0, it is reduced. Actual font size and thus also this +delta value are calculated dynamically before painting based on the +size of the chart and the specification made via parameter \c size. +\param positiveRotation The amount of degrees (using a circle of + 360 degrees) taken to rotate the text. Positive values rotate +clockwise, negative values rotate counter-clockwise. There are two +special values that you might find usefull for Pie charts or for +Ring charts: \c KDCHART_SAGGITAL_ROTATION and \c +KDCHART_TANGENTIAL_ROTATION both leading to individual +calculation of appropriate rotation for each data value. Rotation +will be performed around the internal alignment point of the +text -- specified by \c negativeAlign (or \c positiveAlign, resp.). + +\param layoutPolicy The way to handle too narrow space conflicts: +what to do if a data text covers a neighboring data text (or a + neighboring data area, resp.). + +\sa printDataValues +\sa setPrintDataValuesWithDefaultFontParams, printDataValuesWithDefaultFontParams +\sa setPrintDataValuesFontRelSize, setPrintDataValuesColor +\sa dataValuesDivPow10 +\sa dataValuesDigitsBehindComma +\sa dataValuesFontUseRelSize +\sa dataValuesFontRelSize +\sa dataValuesFontColor +\sa dataValuesAnchorPosition +\sa dataValuesAnchorAlign +\sa dataValuesAnchorDeltaX +\sa dataValuesAnchorDeltaY +\sa dataValuesRotation +\sa dataValuesLayoutPolicy +*/ +void KDChartParams::setPrintDataValues( bool active, + uint chart, + int divPow10, + int digitsBehindComma, + QFont* font, + uint size, + const QColor* color, + KDChartEnums::PositionFlag negativePosition, + uint negativeAlign, + int negativeDeltaX, + int negativeDeltaY, + int negativeRotation, + KDChartEnums::PositionFlag positivePosition, + uint positiveAlign, + int positiveDeltaX, + int positiveDeltaY, + int positiveRotation, + KDChartEnums::TextLayoutPolicy policy ) +{ + uint count = (KDCHART_ALL_CHARTS == chart) ? 2 : 1; + PrintDataValuesSettings * settings = (( 1 < count ) || ( 0 == chart )) + ? &_printDataValuesSettings + : &_printDataValuesSettings2; + for ( uint i = 0; i < count; ++i ) { + settings->_printDataValues = active; + settings->_divPow10 = divPow10; + settings->_digitsBehindComma = digitsBehindComma; + + const ChartType cType + = ( ( 1 < count && i ) + || ( 1 == count && 0 < chart && chart < 1000 ) ) + ? additionalChartType() + : chartType(); + + bool finished( false ); + if ( UINT_MAX == size ) { + finished = true; + switch ( cType ) { + case NoType: + case Bar: { + if ( font ) + settings->_dataValuesFont = *font; + else + settings->_dataValuesFont = QFont( "times", 1, QFont::Bold ); + settings->_dataValuesUseFontRelSize = true; + settings->_dataValuesFontRelSize = 16; + settings->_dataValuesAutoColor = false; // !!! + settings->_dataValuesColor = QColor( Qt::darkBlue ); + settings->_dataValuesBrush = QBrush( Qt::NoBrush ); + // for values below zero: + settings->_dataValuesAnchorNegativePosition = KDChartEnums::PosBottomRight; + settings->_dataValuesAnchorNegativeAlign = Qt::AlignBottom + Qt::AlignRight; + settings->_dataValuesAnchorNegativeDeltaX = 20; + settings->_dataValuesAnchorNegativeDeltaY = 55; + settings->_dataValuesNegativeRotation = 300; + // for values greater/equal zero: + settings->_dataValuesAnchorPositivePosition = KDChartEnums::PosTopLeft; + settings->_dataValuesAnchorPositiveAlign = Qt::AlignTop + Qt::AlignLeft; + settings->_dataValuesAnchorPositiveDeltaX = - 20; + settings->_dataValuesAnchorPositiveDeltaY = - 65; + settings->_dataValuesPositiveRotation = 300; + + settings->_dataValuesLayoutPolicy = KDChartEnums::LayoutPolicyRotate; + } + break; + case Line: { + if ( font ) + settings->_dataValuesFont = *font; + else + settings->_dataValuesFont = QFont( "times", 1, QFont::Normal ); + settings->_dataValuesUseFontRelSize = true; + settings->_dataValuesFontRelSize = 16; + settings->_dataValuesAutoColor = false; // !!! + settings->_dataValuesColor = QColor( Qt::darkBlue ); + settings->_dataValuesBrush = QBrush( Qt::NoBrush ); + // for values below zero: + settings->_dataValuesAnchorNegativePosition = KDChartEnums::PosBottomCenter; + settings->_dataValuesAnchorNegativeAlign = Qt::AlignTop + Qt::AlignHCenter; + settings->_dataValuesAnchorNegativeDeltaX = 0; + settings->_dataValuesAnchorNegativeDeltaY = 0; + settings->_dataValuesNegativeRotation = 0; + // for values greater/equal zero: + settings->_dataValuesAnchorPositivePosition = KDChartEnums::PosTopCenter; + settings->_dataValuesAnchorPositiveAlign = Qt::AlignBottom + Qt::AlignHCenter; + settings->_dataValuesAnchorPositiveDeltaX = 0; + settings->_dataValuesAnchorPositiveDeltaY = 0; + settings->_dataValuesPositiveRotation = 0; + + settings->_dataValuesLayoutPolicy = KDChartEnums::LayoutPolicyRotate; + } + break; + case Area: { + if ( font ) + settings->_dataValuesFont = *font; + else + settings->_dataValuesFont = QFont( "times", 1, QFont::Bold ); + settings->_dataValuesUseFontRelSize = true; + settings->_dataValuesFontRelSize = 21; + settings->_dataValuesAutoColor = true; // !!! + settings->_dataValuesColor = QColor( Qt::black ); + settings->_dataValuesBrush = QBrush( Qt::white ); + + bool bShowOutside = areaChartSubType() == AreaNormal; + // for values below zero: + settings->_dataValuesAnchorNegativePosition = KDChartEnums::PosBottomCenter; + settings->_dataValuesAnchorNegativeAlign = Qt::AlignHCenter + + (bShowOutside ? Qt::AlignTop : Qt::AlignBottom); + settings->_dataValuesAnchorNegativeDeltaX = 0; + settings->_dataValuesAnchorNegativeDeltaY = bShowOutside ? 20 : -35; + settings->_dataValuesNegativeRotation = 0; + // for values greater/equal zero: + settings->_dataValuesAnchorPositivePosition = KDChartEnums::PosTopCenter; + settings->_dataValuesAnchorPositiveAlign = Qt::AlignHCenter + + (bShowOutside ? Qt::AlignBottom : Qt::AlignTop); + settings->_dataValuesAnchorPositiveDeltaX = 0; + settings->_dataValuesAnchorPositiveDeltaY = bShowOutside ? -20 : 35; + settings->_dataValuesPositiveRotation = 0; + + settings->_dataValuesLayoutPolicy = KDChartEnums::LayoutPolicyRotate; + } + break; + case HiLo: + case BoxWhisker: + // settings are not defined here because HiLo and BW charts + // are *not* set up using setPrintDataValues() + // but by using their own methods + break; + case Pie: { + if ( font ) + settings->_dataValuesFont = *font; + else + settings->_dataValuesFont = QFont( "times", 1, QFont::Bold ); + settings->_dataValuesUseFontRelSize = true; + settings->_dataValuesFontRelSize = 25; + settings->_dataValuesAutoColor = true; // !!! + settings->_dataValuesColor = QColor( Qt::black ); + settings->_dataValuesBrush = QBrush( Qt::NoBrush ); + // for values below zero: + settings->_dataValuesAnchorNegativePosition = KDChartEnums::PosTopCenter; + settings->_dataValuesAnchorNegativeAlign = Qt::AlignTop + Qt::AlignHCenter; + settings->_dataValuesAnchorNegativeDeltaX = 0; + settings->_dataValuesAnchorNegativeDeltaY = 50; + settings->_dataValuesNegativeRotation = KDCHART_TANGENTIAL_ROTATION; + // for values greater/equal zero: + settings->_dataValuesAnchorPositivePosition = KDChartEnums::PosTopCenter; + settings->_dataValuesAnchorPositiveAlign = Qt::AlignTop + Qt::AlignHCenter; + settings->_dataValuesAnchorPositiveDeltaX = 0; + settings->_dataValuesAnchorPositiveDeltaY = 50; + settings->_dataValuesPositiveRotation = KDCHART_TANGENTIAL_ROTATION; + + settings->_dataValuesLayoutPolicy = KDChartEnums::LayoutPolicyRotate; + } + break; + case Ring: { + if ( font ) + settings->_dataValuesFont = *font; + else + settings->_dataValuesFont = QFont( "times", 1, QFont::Bold ); + settings->_dataValuesUseFontRelSize = true; + settings->_dataValuesFontRelSize = 25; + settings->_dataValuesAutoColor = true; // !!! + settings->_dataValuesColor = QColor( Qt::black ); + settings->_dataValuesBrush = QBrush( Qt::NoBrush ); + // for values below zero: + settings->_dataValuesAnchorNegativePosition = KDChartEnums::PosCenter; + settings->_dataValuesAnchorNegativeAlign = Qt::AlignCenter; + settings->_dataValuesAnchorNegativeDeltaX = 0; + settings->_dataValuesAnchorNegativeDeltaY = 10; + settings->_dataValuesNegativeRotation = KDCHART_TANGENTIAL_ROTATION; + // for values greater/equal zero: + settings->_dataValuesAnchorPositivePosition = KDChartEnums::PosCenter; + settings->_dataValuesAnchorPositiveAlign = Qt::AlignCenter; + settings->_dataValuesAnchorPositiveDeltaX = 0; + settings->_dataValuesAnchorPositiveDeltaY = 10; + settings->_dataValuesPositiveRotation = KDCHART_TANGENTIAL_ROTATION; + + settings->_dataValuesLayoutPolicy = KDChartEnums::LayoutPolicyRotate; + } + break; + + case Polar: { + settings->_dataValuesFontRelSize = 18; + if ( font ) + settings->_dataValuesFont = *font; + else + settings->_dataValuesFont = QFont( "times", 1, QFont::Bold ); + settings->_dataValuesUseFontRelSize = true; + settings->_dataValuesFontRelSize = 26; + settings->_dataValuesAutoColor = polarMarker(); // !!! + settings->_dataValuesColor = QColor( Qt::black ); + settings->_dataValuesBrush = QBrush( Qt::NoBrush ); + + // for values below zero: + settings->_dataValuesAnchorNegativePosition = KDChartEnums::PosCenter; + settings->_dataValuesAnchorNegativeAlign = Qt::AlignCenter; + settings->_dataValuesAnchorNegativeDeltaX = 0; + settings->_dataValuesAnchorNegativeDeltaY = 0; + settings->_dataValuesNegativeRotation = 0; + // for values greater/equal zero: + settings->_dataValuesAnchorNegativePosition = KDChartEnums::PosCenter; + settings->_dataValuesAnchorNegativeAlign = Qt::AlignCenter; + settings->_dataValuesAnchorNegativeDeltaX = 0; + settings->_dataValuesAnchorNegativeDeltaY = 0; + settings->_dataValuesNegativeRotation = 0; + + //settings->_dataValuesLayoutPolicy = KDChartEnums::LayoutPolicyShrinkFontSize; + //settings->_dataValuesFontRelSize = 26; + //setDefaultAxesTypes(); + //finished = false; // use build-in default params, see KDChartParams.h::setPrintDataValues() + } + break; + + default: { + qDebug( "IMPLEMENTATION ERROR: Unknown chartType in setPrintDataValues()" ); + finished = false; // use build-in default params, see KDChartParams.h::setPrintDataValues() + } + } + } + if ( !finished ) { + settings->_useDefaultFontParams = false; + + if ( font ) + settings->_dataValuesFont = *font; + else + settings->_dataValuesFont = QFont( "times", 1, QFont::Bold ); + + uint theSize( UINT_MAX == size ? 14 : size ); + settings->_dataValuesUseFontRelSize = ( 0 < theSize ); + settings->_dataValuesFontRelSize = theSize; + if ( KDCHART_DATA_VALUE_AUTO_COLOR == color + && ( Polar != cType || polarMarker() ) ) { + settings->_dataValuesAutoColor = true; // !!! + settings->_dataValuesColor = QColor( Qt::black ); + } + else { + settings->_dataValuesAutoColor = false; + if ( 0 == color ) + settings->_dataValuesColor + = QColor( i ? Qt::darkBlue : Qt::black ); + else + settings->_dataValuesColor = *color; + } + settings->_dataValuesBrush = Qt::NoBrush; + // for values below zero: + settings->_dataValuesAnchorNegativePosition = negativePosition; + settings->_dataValuesAnchorNegativeAlign = negativeAlign; + settings->_dataValuesAnchorNegativeDeltaX = negativeDeltaX; + settings->_dataValuesAnchorNegativeDeltaY = negativeDeltaY; + settings->_dataValuesNegativeRotation = negativeRotation; + // for values greater/equal zero: + settings->_dataValuesAnchorPositivePosition = positivePosition; + settings->_dataValuesAnchorPositiveAlign = positiveAlign; + settings->_dataValuesAnchorPositiveDeltaX = positiveDeltaX; + settings->_dataValuesAnchorPositiveDeltaY = positiveDeltaY; + settings->_dataValuesPositiveRotation = positiveRotation; + + settings->_dataValuesLayoutPolicy = policy; + } + if ( 0 < chart ) + settings = &_printDataValuesSettings2; + } + emit changed(); +} + + +/** + \enum KDChartParams::SourceMode + + The chart source mode. + Use \c setChartSourceMode to specify if and how any data + should be taken into account for a given chart. + + \sa setChartSourceMode, chartSourceMode, setAdditionalChartType + */ + + +/** + Specifies the chart source mode of one or more datasets. + Use this to specify if and how any data should be taken + into account for a given chart. You may call this function + multiple times to specify how the different datasets are to + be used. Number of datasets is only limited by the data that + you actually provide to the chart widget. Usage of this method + is mandatory when specifying combinations of more than one + chart (e.g. via \c setAdditionalChartType() ). + + \note If specifying more than one dataset for the very + same chart and the same source mode make sure they form + a contiguous series.
+ It is not possible to use dataset 0..3 as DataEntry, dataset + 4 as AxisLabel and again dataset 5..6 as DataEntry for the + very same chart!
+ Of course you could specify 0..3 as DataEntry for chart 0 + while 5..6 would contain the data entries for chart 1 + when specifying a widget showing two charts. + + Also note:
+ Whenever you use \c setChartSourceMode() make sure not to + forget any of the datasets which you want to define: not + specifying a dataset would result in it being ignored.
+ So the rule is: either don't call setChartSourceMode() at all + or call it for each dataset! + + To quickly clear all such settings just might want to call + setChartSourceMode( UnknownMode, KDCHART_ALL_DATASETS ); + without specifying a dataset number and without specifying + a chart number.
+ However this KDCHART_ALL_DATASETS may only be used to + clear SourceMode settings - but not for defining the + SourceMode for all datasets - the above mentioned combination + with UnknownMode is the only way how to use + KDCHART_ALL_DATASETS here! + + Examples: + + \verbatim + setChartSourceMode( DataEntry, 2 ); + \endverbatim + This would specify a simple chart obtaining its values from dataset 2. + + \verbatim + setChartSourceMode( DataEntry, 0, 0, 0 ); + setChartSourceMode( DataEntry, 3, 3, 1 ); + \endverbatim + This would specify a two chart widget - the 1st obtaining its values + from dataset 0 and the 2nd taking the values from dataset 3. + + \verbatim + setChartSourceMode( LegendText, 1, 1, 0 ); + setChartSourceMode( AxisLabel, 2, 2, 0 ); + setChartSourceMode( DataEntry, 3, 6, 0 ); + setChartSourceMode( ExtraLinesAnchor, 7, 7, 0 ); + setChartSourceMode( LegendText, 8, 8, 1 ); + setChartSourceMode( AxisLabel, 9, 9, 1 ); + setChartSourceMode( DataEntry, 10, 13, 1 ); + \endverbatim + This would specify a two chart widget - the 1st obtaining its values + from datasets 3..6 and the 2nd taking the values from datasets 10..13. + Their respective legends and axes would take their values from + datasets 1 and 2 (or 8 and 9, resp.). + Additionally the 1st chart would use dataset 7 to determine the + horizontal (or vertical, resp.) position of any extra lines + that might be specified by KDChartPropertySet IDs assigned to + the cells in dataset 7. + + \note If source mode is ExtraLinesAnchor all cells + of the respective datset will be ignored when the normal + cell representations (e.g. Bars or Lines) are drawn - these + cells will only be used as anchor points for any + extra lines that are specified with these cell's property sets. + + When specifying \c ExtraLinesAnchor for more than one dataset + of the same chart make sure they form a contiguous row + together with the \c DataEntry dataset(s): e.g + you may use datasets 3..8 for DataEntry cells and datasets + 9..10 for ExtraLinesAnchor cells. + All datasets with mode DataEntry or ExtraLinesAnchor are taken + into account for calculation of the axes ranges and delimiters. + +

+ + \param mode the way how to use information stored in this dataset. + \param dataset the dataset number to be used (or ignored, resp.). + Use \c KDCHART_ALL_DATASETS to indicate that information given + applies to all of the datasets. + \param dataset2 a second dataset number to be taken into account + (or ignored, resp.). Use this one together with the \dataset +param to specify a range of datasets. +\param chart the chart taking into account this dataset. +Use this parameter only if more than one chart is to be displayed. +By using KDCHART_ALL_CHARTS here you may specify that the dataset +(or the range of datasets, resp.) is to be taken into account for +all of the charts displayed. + +\sa SourceMode, chartSourceMode, findDataset +\sa maxDatasetSourceMode, setAdditionalChartType +*/ +void KDChartParams::setChartSourceMode( SourceMode mode, + uint dataset, + uint dataset2, + uint chart ) +{ + if ( KDCHART_NO_DATASET != dataset + && KDCHART_ALL_DATASETS != dataset + && KDCHART_ALL_DATASETS != dataset2 ) { + uint i; + uint last = ( KDCHART_NO_DATASET == dataset2 ) ? dataset : dataset2; + for ( i = dataset; i <= last; ++i ) + _dataSourceModeAndChart[ i ] = ModeAndChart( mode, chart ); + _maxDatasetSourceMode = QMAX( _maxDatasetSourceMode, --i ); + _setChartSourceModeWasUsed = true; + } else if ( UnknownMode == mode && dataset == KDCHART_ALL_DATASETS ) { + _dataSourceModeAndChart.clear(); + _setChartSourceModeWasUsed = false; + } + + emit changed(); +} + + +/** + Retrieves usage information of a given dataset or a range of + datasets. + + \note If you specify a range of datasets and not all of them + share the same SourceMode the return value will be \c UnknownMode + whereas in case of the dataset(s) not being used it will be \c DontUse. + Accordingly if you provide a chart pointer and not all the + datasets share the same chart the chart pointer will receive + the value KDCHART_UNKNOWN_CHART.
+ + Also note: + If \c setChartSourceMode() was not used at all + chartSourceMode() will return DataEntry no matter what + dataset number is specified. + +

+ + \param dataset the dataset number to be looked at. + Use \c KDCHART_ALL_DATASETS to find out if all of the datasets share + the very same SourceMode. + \param dataset2 a second dataset number. + Use this one together with the \dataset param to look at a range of + datasets and find out if all of them share the very same SourceMode. + \param chart If this parameter points to an int the method will + provide you with the chart number that this dataset (or this range + of datasets, resp.) is taken into account for. + + \sa SourceMode, setChartSourceMode, setAdditionalChartType + \sa maxDatasetSourceMode, findDataset + */ +KDChartParams::SourceMode KDChartParams::chartSourceMode( uint dataset, + uint dataset2, + uint* pChart ) const +{ + uint chart = KDCHART_UNKNOWN_CHART; + SourceMode mode = UnknownMode; + + if ( _setChartSourceModeWasUsed ) { + if ( dataset <= _maxDatasetSourceMode + && ( KDCHART_NO_DATASET == dataset2 + || dataset2 <= _maxDatasetSourceMode ) ) { + + uint a, b; + if ( KDCHART_ALL_DATASETS == dataset ) { + a = 0; + b = UINT_MAX; + } else { + a = dataset; + b = KDCHART_NO_DATASET == dataset2 ? a : dataset2; + } + + bool bStart = true; + ModeAndChartMap::ConstIterator it; + for( it = _dataSourceModeAndChart.find( a ); + ( it != _dataSourceModeAndChart.end() ) && ( it.key() <= b ); + ++it ){ + if ( bStart ) { + mode = it.data().mode(); + chart = it.data().chart(); + bStart = false; + } else { + if ( mode != it.data().mode() ) + mode = UnknownMode; + if ( chart != it.data().chart() ) + chart = KDCHART_UNKNOWN_CHART; + } + } + } + } else { + mode = DataEntry; + chart = 0; + } + if ( pChart ) + * pChart = chart; + return mode; +} + + +/** + Retrieves the dataset number or a range of datasets + being used with a given SourceMode for a given chart + or KDCHART_NO_DATASET if no dataset was specified for + that mode and that chart. + + \note If \c setChartSourceMode() was not used at all + findDataset() will return true and set the dataset + to KDCHART_ALL_DATASETS when called for SourceMode + DataEntry. All other SourceModes will return false then. + + \return True if at least one dataset was found. + + \param mode the SourceMode to search for. + \param dataset the dataset number found (or the first + dataset number in case a series of datasets was found, resp.) + \param dataset2 the dataset number found (or the last + dataset number in case a series of datasets was found, resp.) + Hint: You may give the same variable both for + dataset and for dataset2, e.g. this makes sense in case you + are sure that findDataset will find only one dataset anyway. + \param chart the chart number that the dataset (or this range + of datasets, resp.) must have been defined for. If this is missing + findDataset assumes you are looking for datasets of the first chart. + + \sa findDatasets, SourceMode, setChartSourceMode, chartSourceMode + \sa maxDatasetSourceMode, setAdditionalChartType + */ +bool KDChartParams::findDataset( SourceMode mode, + uint& dataset, + uint& dataset2, + uint chart ) const +{ + bool res = false; + dataset = KDCHART_NO_DATASET; + dataset2 = KDCHART_NO_DATASET; + if ( _setChartSourceModeWasUsed ) { + bool bStart = true; + ModeAndChartMap::ConstIterator it; + for ( it = _dataSourceModeAndChart.begin(); + it != _dataSourceModeAndChart.end(); ++it ) { + if ( ( it.data().mode() == mode ) + && ( ( KDCHART_ALL_CHARTS == chart ) + || ( it.data().chart() == chart ) ) ) { + if ( bStart ) { + dataset = it.key(); + bStart = false; + } + dataset2 = it.key(); + res = true; + } else if ( !bStart ) + return res; + } + } else if ( DataEntry == mode ) { + dataset = KDCHART_ALL_DATASETS; + dataset2 = KDCHART_ALL_DATASETS; + res = true; + } + return res; +} + + +/** + Retrieves the dataset number or a range of datasets + being used with one of two given SourceModes + for a given chart or KDCHART_NO_DATASET + if no dataset was specified for that mode and that chart. + + If \c setChartSourceMode() was not used at all + findDataset() will return true and set the dataset + to KDCHART_ALL_DATASETS when either \c modeA or \c modeB + is DataEntry. All other SourceModes will return + false then. + + \note If the found datasets do not form a + contiguous series the return value will be false + and the value of \c dataset will be KDCHART_NO_DATASET + and a comment will be written to stderr + (if KDChart was compiled in debug mode). + + \return True if at least one dataset was found. + + \param modeA one of the SourceModes to search for. + \param modeB the other one of the two SourceModes to search for. + \param dataset the dataset number found (or the first + dataset number in case a series of datasets was found, resp.) + \param dataset2 the dataset number found (or the last + dataset number in case a series of datasets was found, resp.) + Hint: You may give the same variable both for + dataset and for dataset2, e.g. this makes sense in case you + are sure that findDataset will find only one dataset anyway. + \param chart the chart number that the dataset (or this range + of datasets, resp.) must have been defined for. If this is missing + findDataset assumes you are looking for datasets of the first chart. + + \sa findDataset, SourceMode, setChartSourceMode, chartSourceMode + \sa maxDatasetSourceMode, setAdditionalChartType + */ +bool KDChartParams::findDatasets( SourceMode modeA, + SourceMode modeB, + uint& dataset, + uint& dataset2, + uint chart ) const +{ + bool res = false; + dataset = KDCHART_NO_DATASET; + dataset2 = KDCHART_NO_DATASET; + uint dsA1, dsA2, dsB1, dsB2; + bool foundA = findDataset( modeA, dsA1, dsA2, chart ); + bool foundB = findDataset( modeB, dsB1, dsB2, chart ); + if( foundA || foundB ){ + if( dsA1 == KDCHART_ALL_DATASETS || dsB1 == KDCHART_ALL_DATASETS ){ + dataset = KDCHART_ALL_DATASETS; + dataset2 = KDCHART_ALL_DATASETS; + res = true; + }else{ + if( foundA && foundB ){ + if( QMIN(dsA2, dsB2) + 1 == QMAX(dsA1, dsB1) ){ + dataset = QMIN(dsA1, dsB1); + dataset2 = QMAX(dsA2, dsB2); + res = true; + }else{ + qDebug("ERROR in KDChartParams::findDatasets(): Datasets found are *not* a contiguous series."); + } + }else{ + dataset = foundA ? dsA1 : dsB1; + dataset2 = foundA ? dsA2 : dsB2; + res = true; + } + } + } + return res; +} + + +/** + Specifies a color for a dataset. Note that if you define a color for a + dataset but not for a dataset with a lower number (and there is neither + a default value), the color for that dataset with the lower number will + be undefined. If you do not want any color, pass an invalid color + (i.e. a default-constructed QColor object). This is only useful + for chart types that have an outline (like bars or pies), + because you would not see anything otherwise.
+ In charts that can only display one dataset (like pies), the specified + colors are used for the different values instead. + + \param dataset the number of the dataset (or value for pies and similar + charts) for which the color is specified + \param color the color to use for this dataset/value + \sa setDataDefaultColors, setDataRainbowColors, setDataSubduedColors + \sa dataColor, maxDataColor + */ +void KDChartParams::setDataColor( uint dataset, QColor color ) +{ + QColor shadow1; + QColor shadow2; + calculateShadowColors( color, shadow1, shadow2 ); + _dataColors[ dataset ] = color; + _dataColorsShadow1[ dataset ] = shadow1; + _dataColorsShadow2[ dataset ] = shadow2; + _maxDatasetColor = QMAX( _maxDatasetColor, dataset ); + + emit changed(); +} + +/** + Specifies KD Chart's default colors for the datasets 0..11. + + This method may be usefull to re-set the colors after changing the + colors of the datasets. + + \sa setDataColor, setDataRainbowColors, setDataSubduedColors + \sa dataColor, maxDataColor + */ +void KDChartParams::setDataDefaultColors() +{ + setDataColor( 0, red ); + setDataColor( 1, green ); + setDataColor( 2, blue ); + setDataColor( 3, cyan ); + setDataColor( 4, magenta ); + setDataColor( 5, yellow ); + setDataColor( 6, darkRed ); + setDataColor( 7, darkGreen ); + setDataColor( 8, darkBlue ); + setDataColor( 9, darkCyan ); + setDataColor( 10, darkMagenta ); + setDataColor( 11, darkYellow ); +} + +/** + Specifies a set of eight rainbow-like colors for the datasets 0..7 + and sets the lighter versions of this colors to datasets 8..15. + + This is a convenience method setting colors that look best on + a dark gray or black background. + + \sa setDataColor, setDataDefaultColors, setDataSubduedColors + \sa dataColor, maxDataColor + */ +void KDChartParams::setDataRainbowColors() +{ + setDataColor( 0, QColor(255, 0,196) ); + setDataColor( 1, QColor(255, 0, 96) ); + setDataColor( 2, QColor(255, 128,64) ); + setDataColor( 3, Qt::yellow ); + setDataColor( 4, Qt::green ); + setDataColor( 5, Qt::cyan ); + setDataColor( 6, QColor( 96, 96,255) ); + setDataColor( 7, QColor(160, 0,255) ); + for( int i=8; i<16; ++i ) + setDataColor( i, dataColor(i-8).light() ); +} + +/** + Specifies a set of eighteen subdued colors for the datasets 0..17. + + This is a convenience method setting colors that is ideal for + area charts since the dark data value texts can be easily + read when printed onto such background colors. + + \param ordered if true all eighteen colors will be set according + to their appearance in the color circle, if false they will be + arranged in a logical order making it very easy ti distinguish + two neighboring colors. Set this parameter to true if you want + your neighboring colors look quite similiar, the default is false. + + \sa setDataColor, setDataDefaultColors, setDataRainbowColors + \sa dataColor, maxDataColor + */ +void KDChartParams::setDataSubduedColors( bool ordered ) +{ +static const int NUM_SUBDUEDCOLORS = 18; +static const QColor SUBDUEDCOLORS[ NUM_SUBDUEDCOLORS ] = { + QColor( 0xe0,0x7f,0x70 ), + QColor( 0xe2,0xa5,0x6f ), + QColor( 0xe0,0xc9,0x70 ), + QColor( 0xd1,0xe0,0x70 ), + QColor( 0xac,0xe0,0x70 ), + QColor( 0x86,0xe0,0x70 ), + QColor( 0x70,0xe0,0x7f ), + QColor( 0x70,0xe0,0xa4 ), + QColor( 0x70,0xe0,0xc9 ), + QColor( 0x70,0xd1,0xe0 ), + QColor( 0x70,0xac,0xe0 ), + QColor( 0x70,0x86,0xe0 ), + QColor( 0x7f,0x70,0xe0 ), + QColor( 0xa4,0x70,0xe0 ), + QColor( 0xc9,0x70,0xe0 ), + QColor( 0xe0,0x70,0xd1 ), + QColor( 0xe0,0x70,0xac ), + QColor( 0xe0,0x70,0x86 ), +}; + if( ordered ) + for(int i=0; i v ) + v = 0.0; + shadow1.setHsv( hue, saturation, static_cast < int > ( v ) ); + v = value; + v = v / 3.0 * shadowBrightnessFactor(); + if ( 255.0 < v ) + v = 255.0; + else if ( 1.0 > v ) + v = 0.0; + shadow2.setHsv( hue, saturation, static_cast < int > ( v ) ); + } +} + + +/** + Returns the color for a dataset. If no color has been defined for this + dataset and none for a higher dataset either, the number will be mapped + to the range of defined colors. If no color has been defined for this + dataset, but at least one for a higher dataset, the return value of + this method is undefined. + + \param dataset the number of the dataset for which to return the color + \return the color for this dataset + \sa setDataColor, maxDataColor + */ +QColor KDChartParams::dataColor( uint dataset ) const +{ + uint index = dataset % (_maxDatasetColor+1); + if( _dataColors.find( index ) != _dataColors.end() ) + return _dataColors[ index ]; + else + return QColor(); // documentation says undefined +} + + +QString KDChartParams::dataRegionFrameAreaName( uint dataRow, + uint dataCol, + uint data3rd ) +{ + return QString( "%1/%2/%3/%4" ) + .arg( KDChartEnums::AreaChartDataRegion, 5 ) + .arg( dataRow, 5 ) + .arg( dataCol, 5 ) + .arg( data3rd, 5 ); +} + + +/** + Recomputes the shadow colors by iterating over all configured + data colors and reassigning the data colors with exactly the + same values which in turn triggers computation of the shadow + colors. Expensive if many data colors are set, but performance + is OK for typical cases. + */ +void KDChartParams::recomputeShadowColors() +{ + // Simply reassign the available colors; this will trigger + // recomputation of the shadow colors. + for( QMap::Iterator it = _dataColors.begin(); + it != _dataColors.end(); ++it ) { + setDataColor( it.key(), it.data() ); + } +} + + + + +/** + Returns the first shadow color for a dataset. This is the color that + is used to draw the top bars with 3D effects. It is somewhat + darker than the original data color. If no color has been defined for this + dataset and none for a higher dataset either, the number will be mapped + to the range of defined colors. If no color has been defined for this + dataset, but at least one for a higher dataset, the return value of + this method is undefined. + + \param dataset the number of the dataset for which to return the color + \return the color for this dataset + \sa setDataColor, maxDataColor, dataShadow2Color + */ +QColor KDChartParams::dataShadow1Color( uint dataset ) const +{ + uint index = dataset % _maxDatasetColor; + if ( _threeDShadowColors ) + if( _dataColorsShadow1.find( index ) != _dataColorsShadow1.end() ) + return _dataColorsShadow1[ index ]; + else + return QColor(); // documentation says undefined + else + if( _dataColors.find( index ) != _dataColors.end() ) + return _dataColors[ index ]; + else + return QColor(); // documentation says undefined +} + + +/** + Returns the second shadow color for a dataset. This is the color that + is used to draw the sides of bars with 3D effects. It is + darker than the original data color. If no color has been defined for this + dataset and none for a higher dataset either, the number will be mapped + to the range of defined colors. If no color has been defined for this + dataset, but at least one for a higher dataset, the return value of + this method is undefined. + + \param dataset the number of the dataset for which to return the color + \return the color for this dataset + \sa setDataColor, maxDataColor, dataShadow1Color + */ +QColor KDChartParams::dataShadow2Color( uint dataset ) const +{ + uint index = dataset % _maxDatasetColor; + if ( _threeDShadowColors ) + if( _dataColorsShadow2.find( index ) != _dataColorsShadow2.end() ) + return _dataColorsShadow2[ index ]; + else + return QColor(); // documentation says undefined + else + if( _dataColors.find( index ) != _dataColors.end() ) + return _dataColors[ index ]; + else + return QColor(); // documentation says undefined +} + + +/** + Set the default axis types for all the axes the user might activate for this chart: + \li Pie charts by default have no axes at all + \li Bar/Line/Area charts may have up to 8 axes (up to 2 at each side of the chart) + \li charts representing 3-dimensional data may have up to 12 axes + + \note This function also specifies the default way how to calculate + the axis labels: abscissa starts with zero and counts by 1, ordinate + is calculating the labels automatically based upon the values found in + the associated dataset(s). + */ +void KDChartParams::setDefaultAxesTypes() +{ + // reset types of all axes + uint i = 0; + for ( i = 0; i < KDCHART_MAX_AXES; ++i ) + setAxisType( i, KDChartAxisParams::AxisTypeUnknown ); + + // Note that abscissa axes should start labeling at the very + // first position and end at the last position when drawing + // area charts. + // Bar charts and line charts look better with their abscissa labels + // in the respective middle positions below each bar (or point, resp.) + for ( i = KDChartAxisParams::AxisPosSTART; + i <= KDChartAxisParams::AxisPosEND; ++i ) + switch ( i ) { + // abscissa axes: + case KDChartAxisParams::AxisPosBottom: + case KDChartAxisParams::AxisPosTop: + case KDChartAxisParams::AxisPosBottom2: + case KDChartAxisParams::AxisPosTop2: + setAxisLabelsTouchEdges( i, Area == chartType() ); + break; + // ordinate axes: + case KDChartAxisParams::AxisPosLeft: + case KDChartAxisParams::AxisPosRight: + case KDChartAxisParams::AxisPosLeft2: + case KDChartAxisParams::AxisPosRight2: + setAxisLabelsTouchEdges( i, true ); //Polar != chartType() ); + break; + // additional axes for charts representing 3-dimensional data: + case KDChartAxisParams::AxisPosLowerRightEdge: + case KDChartAxisParams::AxisPosLowerLeftEdge: + case KDChartAxisParams::AxisPosLowerRightEdge2: + case KDChartAxisParams::AxisPosLowerLeftEdge2: + setAxisLabelsTouchEdges( i, false ); + break; + default: { + qDebug( "IMPLEMENTATION ERROR: axis type missing in KDChartParams::setDefaultAxesTypes()" ); + Q_ASSERT( !this ); + } + } + + // set default axis types according to chart type + switch ( chartType() ) { + case NoType: + break; + case Bar: + case Line: + case Area: + // default axes + setAxisType( KDChartAxisParams::AxisPosBottom, + KDChartAxisParams::AxisTypeEAST ); + setAxisShowGrid( KDChartAxisParams::AxisPosBottom, + true ); + setAxisType( KDChartAxisParams::AxisPosLeft, + KDChartAxisParams::AxisTypeNORTH ); + setAxisShowGrid( KDChartAxisParams::AxisPosLeft, + true ); + // 'other side' axes + setAxisType( KDChartAxisParams::AxisPosTop, + KDChartAxisParams::AxisTypeEAST ); + setAxisType( KDChartAxisParams::AxisPosRight, + KDChartAxisParams::AxisTypeNORTH ); + // additional, 2nd axes + setAxisType( KDChartAxisParams::AxisPosBottom2, + KDChartAxisParams::AxisTypeEAST ); + setAxisType( KDChartAxisParams::AxisPosLeft2, + KDChartAxisParams::AxisTypeNORTH ); + // additional, 2nd axes for 'other' sides + setAxisType( KDChartAxisParams::AxisPosTop2, + KDChartAxisParams::AxisTypeEAST ); + setAxisType( KDChartAxisParams::AxisPosRight2, + KDChartAxisParams::AxisTypeNORTH ); + + // Specify default numbering information + // for all 'non-ordinate' axes (this are the X axes): + // + // axisSteadyValueCalc flag is set to false + // Start value 1 + // End value following the number of entries + // in the associated dataset(s) + // Delta value 1.0 + // and dont show any Digits behind the comma. + setAxisLabelTextParams( KDChartAxisParams::AxisPosBottom, false, + 1.0, + KDCHART_AXIS_LABELS_AUTO_LIMIT, + 1.0, 0 ); + setAxisLabelTextParams( KDChartAxisParams::AxisPosTop, false, + 1.0, + KDCHART_AXIS_LABELS_AUTO_LIMIT, + 1.0, 0 ); + setAxisLabelTextParams( KDChartAxisParams::AxisPosBottom2, false, + 1.0, + KDCHART_AXIS_LABELS_AUTO_LIMIT, + 1.0, 0 ); + setAxisLabelTextParams( KDChartAxisParams::AxisPosTop2, false, + 1.0, + KDCHART_AXIS_LABELS_AUTO_LIMIT, + 1.0, 0 ); + + // no need to specify numbering information for + // the ordinate-axes since the default auto-calc + // feature is fine for here. + + break; + + // Code for charts representing 3-dimensional data. + + /* + + // ( not active since there are no such charts yet ) + + case KDChartParams::BarMatrix: + // default axes + setAxisType( KDChartAxisParams::AxisPosBottom, + KDChartAxisParams::AxisTypeEAST ); + setAxisType( KDChartAxisParams::AxisPosLowerRightEdge, + KDChartAxisParams::AxisTypeNORTH ); + setAxisType( KDChartAxisParams::AxisPosLeft, + KDChartAxisParams::AxisTypeUP ); + // 'other side' axes + setAxisType( KDChartAxisParams::AxisPosTop, + KDChartAxisParams::AxisTypeEAST ); + setAxisType( KDChartAxisParams::AxisPosLowerLeftEdge, + KDChartAxisParams::AxisTypeNORTH ); + setAxisType( KDChartAxisParams::AxisPosRight, + KDChartAxisParams::AxisTypeUP ); + // additional, 2nd axes + setAxisType( KDChartAxisParams::AxisPosBottom2, + KDChartAxisParams::AxisTypeEAST ); + setAxisType( KDChartAxisParams::AxisPosLowerRightEdge2, + KDChartAxisParams::AxisTypeNORTH ); + setAxisType( KDChartAxisParams::AxisPosLeft2, + KDChartAxisParams::AxisTypeUP ); + // additional, 2nd axes for 'other' sides + setAxisType( KDChartAxisParams::AxisPosTop2, + KDChartAxisParams::AxisTypeEAST ); + setAxisType( KDChartAxisParams::AxisPosLowerLeftEdge2, + KDChartAxisParams::AxisTypeNORTH ); + setAxisType( KDChartAxisParams::AxisPosRight2, + KDChartAxisParams::AxisTypeUP ); + + // Specify default numbering information + // for all 'non-ordinate' axes (this are the X and the Y axes): + // Start vaule 1 + // End value following the number of entries + // in the associated dataset(s) + // Delta value 1.0 + // and don't show any Digits behind the comma. + setAxisLabelTextParams( KDChartAxisParams::AxisPosBottom, false, + 1.0, KDCHART_AXIS_LABELS_AUTO_LIMIT, 1.0, 0 ); + setAxisLabelTextParams( KDChartAxisParams::AxisPosTop, false, + 1.0, KDCHART_AXIS_LABELS_AUTO_LIMIT, 1.0, 0 ); + setAxisLabelTextParams( KDChartAxisParams::AxisPosLowerRightEdge, + false, + 1.0, KDCHART_AXIS_LABELS_AUTO_LIMIT, 1.0, 0 ); + setAxisLabelTextParams( KDChartAxisParams::AxisPosLowerLeftEdge, + false, + 1.0, KDCHART_AXIS_LABELS_AUTO_LIMIT, 1.0, 0 ); + setAxisLabelTextParams( KDChartAxisParams::AxisPosBottom2, false, + 1.0, KDCHART_AXIS_LABELS_AUTO_LIMIT, 1.0, 0 ); + setAxisLabelTextParams( KDChartAxisParams::AxisPosTop2, false, + 1.0, KDCHART_AXIS_LABELS_AUTO_LIMIT, 1.0, 0 ); + setAxisLabelTextParams(KDChartAxisParams::AxisPosLowerRightEdge2, + false, + 1.0, KDCHART_AXIS_LABELS_AUTO_LIMIT, 1.0, 0 ); + setAxisLabelTextParams( KDChartAxisParams::AxisPosLowerLeftEdge2, + false, + 1.0, KDCHART_AXIS_LABELS_AUTO_LIMIT, 1.0, 0 ); + + false, + 1.0, KDCHART_AXIS_LABELS_AUTO_LIMIT, 1.0, 0 ); + + // no need to specify numbering information for + // the ordinate-axes since the default auto-calc + // feature is fine for here. + + break; + */ + + case KDChartParams::Pie: + case KDChartParams::Ring: + // by default there are no axes defined for pie and ring charts + break; + case KDChartParams::Polar: + setAxisType( KDChartAxisParams::AxisPosSaggital, + KDChartAxisParams::AxisTypeEAST ); + setAxisType( KDChartAxisParams::AxisPosCircular, + KDChartAxisParams::AxisTypeNORTH ); + setAxisLabelsVisible( KDChartAxisParams::AxisPosSaggital, true ); + setAxisLabelsFont( KDChartAxisParams::AxisPosSaggital, + QFont( "helvetica", 1, QFont::Bold ), + -30, + Qt::darkBlue ); + setAxisLabelsVisible( KDChartAxisParams::AxisPosCircular, true ); + setAxisLabelsFont( KDChartAxisParams::AxisPosCircular, + QFont( "helvetica", 1, QFont::Bold ), + -22, + Qt::darkBlue ); + setPolarRotateCircularLabels( false ); + break; + default: { + qDebug( "IMPLEMENTATION ERROR: type missing in KDChartParams::setDefaultAxesTypes()" ); + Q_ASSERT( !this ); + } + } + + emit changed(); +} + + +/** + activate the default axis types for this chart: + \li Pie charts by default have no axes at all + \li Bar/Line/Area by default have 2 axes: the abscissa and the ordinate + \li charts representing 3-dimensional data by default have 3 axes + */ +void KDChartParams::activateDefaultAxes() +{ + // deactivate all axes: specifying KDCHART_NO_DATASET will + // also remove their visability flag + for ( uint i = 0; i < KDCHART_MAX_AXES; ++i ) + setAxisDatasets( i, KDCHART_NO_DATASET ); + + switch ( chartType() ) { + case NoType: + break; + case Bar: + case Line: + case Area: + setAxisVisible( KDChartAxisParams::AxisPosBottom, true ); + setAxisDatasets( KDChartAxisParams::AxisPosBottom, KDCHART_ALL_DATASETS ); + setAxisVisible( KDChartAxisParams::AxisPosLeft, true ); + setAxisDatasets( KDChartAxisParams::AxisPosLeft, KDCHART_ALL_DATASETS ); + /* test: + setAxisVisible( KDChartAxisParams::AxisPosTop, true ); + setAxisDatasets(KDChartAxisParams::AxisPosTop, KDCHART_ALL_DATASETS ); + setAxisVisible( KDChartAxisParams::AxisPosRight, true ); + setAxisDatasets(KDChartAxisParams::AxisPosRight, KDCHART_ALL_DATASETS ); + + setAxisVisible( KDChartAxisParams::AxisPosBottom2, true ); + setAxisDatasets(KDChartAxisParams::AxisPosBottom2, KDCHART_ALL_DATASETS ); + setAxisVisible( KDChartAxisParams::AxisPosLeft2, true ); + setAxisDatasets(KDChartAxisParams::AxisPosLeft2, KDCHART_ALL_DATASETS ); + + setAxisVisible( KDChartAxisParams::AxisPosTop2, true ); + setAxisDatasets(KDChartAxisParams::AxisPosTop2, KDCHART_ALL_DATASETS ); + setAxisVisible( KDChartAxisParams::AxisPosRight2, true ); + setAxisDatasets(KDChartAxisParams::AxisPosRight2, KDCHART_ALL_DATASETS ); + */ + break; + // Code for charts representing 3-dimensional data. + + /* + + // ( not active since there are no such charts yet ) + + case KDChartParams::BarMatrix: + setAxisVisible( KDChartAxisParams::AxisPosBottom, true ); + setAxisDatasets(KDChartAxisParams::AxisPosBottom, KDCHART_ALL_DATASETS ); + setAxisVisible( KDChartAxisParams::AxisPosLeft, true ); + setAxisDatasets(KDChartAxisParams::AxisPosLeft, KDCHART_ALL_DATASETS ); + setAxisVisible( KDChartAxisParams::AxisPosLowerRightEdge, true ); + setAxisDatasets(KDChartAxisParams::AxisPosLowerRightEdge, + KDCHART_ALL_DATASETS); + break; + */ + case KDChartParams::Pie: + case KDChartParams::Ring: + case KDChartParams::Polar: + // by default there are no axes defined for pie, ring, and polar charts + break; + default: { + qDebug( "IMPLEMENTATION ERROR: type missing in KDChartParams::activateDefaultAxes()" ); + Q_ASSERT( !this ); + } + } +} + + + + + + + + +/** + \fn KDChartParams::setOptimizeOutputForScreen(bool) + + Specify whether drawing should be optimized for (low resolution) + screen output or whether other routines should be used to obtain + best quality when using a printer. + + \note The default of this flag is TRUE, so make sure to deactivate + it before painting your KDChart onto a QPrinter device! + + \note This setting is NOT stored together with the other parameters, + it is recommended to set the flag each time when the drawing targed + (printer or screen, resp) is changed. + + \sa optimizeOutputForScreen + */ + + +/** + \fn bool KDChartParams::optimizeOutputForScreen() const + Returns whether drawing is optimized for (low resolution) + screen output (this is the default) or whether other routines + are used to obtain best quality when using a printer. + + \sa setOptimizeOutputForScreen + */ + + +/** + Specifies the distance between the chart and the left border of the + painter area. If \c leading is a negative value it is interpreted + as per-mille value of the painter area, the true offset will then + be calculated dynamically at drawing time. + + \sa setGlobalLeading, setGlobalLeadingTop, setGlobalLeadingRight, + setGlobalLeadingBottom + \sa globalLeadingLeft, globalLeadingTop, globalLeadingRight, + globalLeadingBottom + */ +void KDChartParams::setGlobalLeading( int left, int top, int right, int bottom ) +{ + _globalLeadingLeft = left; + _globalLeadingTop = top; + _globalLeadingRight = right; + _globalLeadingBottom = bottom; + emit changed(); +} + + +/** + \fn void KDChartParams::setGlobalLeadingLeft( int ) + + Specifies the distance between the chart and the left border of the + painter area. If \c leading is a negative value it is interpreted + as per-mille value of the painter area, the true offset will then + be calculated dynamically at drawing time. + + \sa setGlobalLeading, setGlobalLeadingTop, setGlobalLeadingRight, + setGlobalLeadingBottom + \sa globalLeadingLeft, globalLeadingTop, globalLeadingRight, + globalLeadingBottom + */ + + +/** + \fn void KDChartParams::setGlobalLeadingTop( int ) + + Specifies the distance between the chart and the upper border of + the painter area. If \c leading is a negative value it is + interpreted as per-mille value of the painter area, the true offset + will then be calculated dynamically at drawing time. + + \sa setGlobalLeading, setGlobalLeadingLeft, setGlobalLeadingRight, + setGlobalLeadingBottom + \sa globalLeadingLeft, globalLeadingTop, globalLeadingRight, + globalLeadingBottom + */ + + +/** + \fn void KDChartParams::setGlobalLeadingRight( int ) + + Specifies the distance between the chart and the right border + of the painter area. If \c leading is a negative value it is + interpreted as per-mille value of the painter area, the true + offset will then be calculated dynamically at drawing time. + + \sa setGlobalLeading, setGlobalLeadingLeft, setGlobalLeadingTop, + setGlobalLeadingBottom + \sa globalLeadingLeft, globalLeadingTop, globalLeadingRight, + globalLeadingBottom + */ + + +/** + \fn void KDChartParams::setGlobalLeadingBottom( int ) + + Specifies the distance between the chart and the lower border of + the painter area. If \c leading is a negative value it is + interpreted as per-mille value of the painter area, the true offset + will then be calculated dynamically at drawing time. + + \sa setGlobalLeading, setGlobalLeadingLeft, setGlobalLeadingTop, + setGlobalLeadingRight + \sa globalLeadingLeft, globalLeadingTop, globalLeadingRight, + globalLeadingBottom + */ + + +/** + \fn int KDChartParams::globalLeadingLeft() const + + Return the distance between the chart and the left border of the + painter area. If \c leading is a negative value it is interpreted + as per-mille value of the painter area, the true offset will then + be calculated dynamically at drawing time. + + \sa setGlobalLeading, setGlobalLeadingLeft, setGlobalLeadingTop, + setGlobalLeadingRight, setGlobalLeadingBottom + \sa globalLeadingTop, globalLeadingRight, globalLeadingBottom + */ + + +/** + \fn KDChartParams::globalLeadingTop() const + + Return the distance between the chart and the upper border of the + painter area. If \c leading is a negative value it is interpreted + as per-mille value of the painter area, the true offset will then + be calculated dynamically at drawing time. + + \sa setGlobalLeading, setGlobalLeadingLeft, setGlobalLeadingTop, + setGlobalLeadingRight, setGlobalLeadingBottom + \sa globalLeadingLeft, globalLeadingRight, globalLeadingBottom + */ + + +/** + \fn KDChartParams::globalLeadingRight() const + + Return the distance between the chart and the right border of the + painter area. If \c leading is a negative value it is interpreted + as per-mille value of the painter area, the true offset will then + be calculated dynamically at drawing time. + + \sa setGlobalLeading, setGlobalLeadingLeft, setGlobalLeadingTop, + setGlobalLeadingRight, setGlobalLeadingBottom + \sa globalLeadingLeft, globalLeadingTop, globalLeadingBottom + */ + + +/** + \fn int KDChartParams::globalLeadingBottom() const + + Return the distance between the chart and the lower border of the + painter area. If \c leading is a negative value it is interpreted + as per-mille value of the painter area, the true offset will then + be calculated dynamically at drawing time. + + \sa setGlobalLeading, setGlobalLeadingLeft, setGlobalLeadingTop, + setGlobalLeadingRight, setGlobalLeadingBottom + \sa globalLeadingLeft, globalLeadingTop, globalLeadingRight + */ + + +/** + \fn void KDChartParams::setFrame( uint, const KDFrame&, int, int, + int, int, bool, bool ) + + \ifnot v200 + \deprecated Feature scheduled for future release, at present not implemented. + \else + Specify the frame settings to be used for one of the chart areas. + + The names and the meaning of the areas are explained with the enum + AreaName. The KDFrame class is explained in detail here: KDFrame + Note however: The \c innerRect settings of this KDFrame will + be ignored since position and size of this frame will be calculated + dynamically based upon the AreaName! + + \param area The area to be surrounded by a frame. + \param outerGap The distance between the frame and the surrounding + parts of the chart. + \param innerGap The distance between the frame and the inner area. + \param addFrameWidthToLayout Specifies whether the inner area will + shrink the area AND its frame will occupy the same space of the + chart as the area would occupy if no frame were drawn. If false, + the frame is drawn around the area without taking care not to + override other content of the chart. + + \note An easier way to specify a frame setting is selecting a pre-defined + setting using the setSimpleFrame methode. + + \sa setSimpleFrame, frameSettings, removeFrame + \endif + */ + +/** + \fn void KDChartParams::setSimpleFrame( uint, int, int, int, int, + bool, bool, KDFrame::SimpleFrame, int, int, QPen, QBrush, const + QPixmap*, KDFrame::BackPixmapMode, int, KDFrame::CornerName ) + + Select a pre-defined frame setting to be used for one of the chart areas. + + \param area The area to be surrounded by a frame. + \param outerGap The distance between the frame and the surrounding + parts of the chart. + \param innerGap The distance between the frame and the inner area. + \if v200 + \param addFrameWidthToLayout Specifies whether the inner area will + shrink the area AND its frame will occupy the same space of the + chart as the area would occupy if no frame were drawn. If false, + the frame is drawn around the area without taking care not to + override other content of the chart. + + The parameters specifying the pre-defined frame settings are + defined here: KDFrame::setSimpleFrame. + \sa setFrame, frameSettings + \else + \param addFrameWidthToLayout For internal use - must be \c true. + \param addFrameHeightToLayout For internal use - must be \c true. + \param simpleFrame For internal use - must be \c KDFrame::FrameFlat. + \param lineWidth For internal use - must be \c 1. + \param midLineWidth For internal use - must be \c 0. + \param pen The pen to be used for drawing the four frame border lines. + \param background The brush to be used for painting the frame background. + \param backPixmap The picture to be displayed as background image + of the frame. + \param backPixmapMode The way how backPixmap is to be modified to + fill the frame, these are possible: + \li \c KDFrame::PixCentered Image will not be scaled nor stretched + but shown in original size. + \li \c KDFrame::PixScaled Image will be scaled until it's height or + it's width match the frame's height (or width, resp.) - whichever + comes first - but image proportions will be preserved. + \li \c KDFrame::PixStretched Image will be stretched to have the + same height and the same width as the frame - normally this results + in changing the original image proportions. + \param shadowWidth For internal use - do not set this parameter or + set it to \c 0. + \param sunPos For internal use - do not set this parameter or set + it to \c KDFrame::CornerTopLeft. + \endif + + \sa removeFrame + */ + + +/** + \fn void KDChartParams::setDataRegionFrame( uint, uint, uint, int, int, int, int, + bool, bool, KDFrame::SimpleFrame, int, int, QPen, QBrush, const + QPixmap*, KDFrame::BackPixmapMode, int, KDFrame::CornerName ) + + Select a pre-defined frame setting to be used for one of the data representations + (e.g. to have the frame surrounding one of the bars in a Bar chart). + + \note KDChart currently supports specifying data frames without background only, + it is not possible to draw a special background behind a data representation. + + \param dataRow The table row of the cell to be surrounded by a frame. + \param dataCol The table column of the cell. + \param data3rd The third table coordinate of the cell (parameter not used, its value will be ignored, set to 0, reserved for future use). + \param innerGap The distance between the frame and the inner area. + \if v200 + \param addFrameWidthToLayout Specifies whether the inner area will + shrink the area AND its frame will occupy the same space of the + chart as the area would occupy if no frame were drawn. If false, + the frame is drawn around the area without taking care not to + override other content of the chart. + + The parameters specifying the pre-defined frame settings are + defined here: KDFrame::setSimpleFrame. + \sa setFrame, frameSettings + \else + \param addFrameWidthToLayout For internal use - must be \c true. + \param addFrameHeightToLayout For internal use - must be \c true. + \param simpleFrame For internal use - must be \c KDFrame::FrameFlat. + \param lineWidth For internal use - must be \c 1. + \param midLineWidth For internal use - must be \c 0. + \param pen The pen to be used for drawing the four frame border lines. + \param shadowWidth For internal use - do not set this parameter or + set it to \c 0. + \param sunPos For internal use - do not set this parameter or set + it to \c KDFrame::CornerTopLeft. + \endif + */ + + +/** + \fn bool KDChartParams::moveDataRegionFrame( uint, uint, uint, uint, uint, uint ) + + Move a frame that was previously specified using setDataRegionFrame + to another location: moves the frame from cell[ oldDataRow, oldDataCol ] + to cell[ newDataRow, newDataCol ] without changing looking of the frame, + or just removes the frame entirely. + + \param oldDataRow The table row of the frame to be removed. + \param oldDataCol The table column of the frame to be removed. + \param oldData3rd The third table coordinate of the old cell (parameter not used, its value will be ignored, set to 0, reserved for future use). + \param newDataRow The table row of the cell to be framed instead, or KDCHART_NO_DATASET if the frame is to be removed + without framing another cell then. + \param newDataCol The table column of the cell to be framed instead. + \param newData3rd The third table coordinate of the new cell (parameter not used, its value will be ignored, set to 0, reserved for future use). + + \note Using KDCHART_NO_DATASET for the newDataRow parameter will not + result in returning FALSE because it is an allowed action: the frame is just removed then. + + \return TRUE if the frame could be moved or was removed; FALSE if either there was no frame around the old cell or the target cell does not exist. + */ +bool KDChartParams::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 QString oldKey( dataRegionFrameAreaName( oldDataRow, oldDataCol, 0 ) ); // oldData3rd ) ); + KDChartFrameSettings* it = _areaDict.find( oldKey ); + bool bFound = ( it != 0 ); + if( bFound ){ + if( KDCHART_NO_DATASET != newDataRow ){ + KDChartFrameSettings* frame = new KDChartFrameSettings; + KDChartFrameSettings::deepCopy( *frame, *it ); + frame->setDataRow( newDataRow ); + frame->setDataCol( newDataCol ); + frame->setData3rd( 0 ); // newData3rd ); + _areaDict.setAutoDelete( TRUE ); + _areaDict.replace( + dataRegionFrameAreaName( newDataRow, newDataCol, 0 ), //data3rd 5 ), + frame ); + } + _areaDict.remove( oldKey ); + emit changed(); + } + return bFound; +} + +/** + \var KDChartParams::CustomBoxDict + + The type that stores the custom boxes in a chart. + */ + +/** + Return the frame settings of one of the chart areas. + + \sa nextFrameSettings, setSimpleFrame, setFrame, removeFrame + */ +const KDChartParams::KDChartFrameSettings* KDChartParams::frameSettings( uint area, + bool& bFound, + int* pIterIdx ) const +{ + if( pIterIdx ) + *pIterIdx = 0; + const QString key( QString( "%1/-----/-----/-----" ).arg( area, 5 ) ); + KDChartFrameSettings* it = _areaDict.find( key ); + bFound = ( it != 0 ); + if( bFound ) + return it; + else if( pIterIdx ){ + QString keyStart( key.left(6) ); + QDictIterator it2( _areaDict ); + for( ; it2.current(); ++it2 ){ + if( it2.currentKey().startsWith( keyStart ) ){ + bFound = true; + return it2.current(); + } + ++*pIterIdx; + } + } + return &_noFrameSettings; +} + + +/** + Remove the last frame, that was specified for this chart area. + If you have more than one frame attached to the same area, + make sure to call this method repeatedly, if you want + to remove all of them. + + \note This method can be used to remove frames, that were specified + via setFrame (or via setSimpleFrame, resp.), but if can not be used + to remove frames, that were specified using setDataRegionFrame. + + \sa nextFrameSettings, setSimpleFrame, setFrame + */ +bool KDChartParams::removeFrame( uint area ) +{ + return _areaDict.remove( QString( "%1/-----/-----/-----" ).arg( area, 5 ) ); +} + + +/** + Return the next frame settings specified for the same area type + as the frame that was retrieved by previous calls of \c frameSettings() + or \c nextFrameSettings(). + + \sa setDataRegionFrame, frameSettings + */ +const KDChartParams::KDChartFrameSettings* KDChartParams::nextFrameSettings( bool& bFound, + int* pIterIdx ) const +{ + bFound = false; + if( pIterIdx ){ + int i=0; + QDictIterator it( _areaDict ); + for( ; it.current(); ++it ){ + if( *pIterIdx == i ) + break; + ++i; + } + if( *pIterIdx == i ){ + QString keyStart( it.currentKey().left(6) ); + ++it; + for( ; it.current(); ++it ){ + ++*pIterIdx; + if( it.currentKey().startsWith( keyStart ) ){ + bFound = true; + return it.current(); + } + } + } + } + return &_noFrameSettings; +} + + +/** + Add a new custom box to the list of boxes. + To remove this box from the list lateron just call removeCustomBox + with the index that was returned by insertCustomBox. + + \sa removeCustomBox, removeAllCustomBoxes, customBox, maxCustomBoxIdx + */ +uint KDChartParams::insertCustomBox( const KDChartCustomBox & box ) +{ + _customBoxDict.setAutoDelete( true ); + uint newIdx; + if( _customBoxDictMayContainHoles ){ + _customBoxDictMayContainHoles = false; + const uint maxIndex = maxCustomBoxIdx(); + newIdx = 1 + maxIndex; + for( uint idx = 0; idx <= maxIndex; ++idx ) { + if( ! _customBoxDict.find( idx ) ) { + newIdx = idx; + _customBoxDictMayContainHoles = true; // we found a hole, so there might be more of them + break; + } + } + }else{ + newIdx = _customBoxDict.count(); + } + _customBoxDict.insert( newIdx, box.clone() ); + emit changed(); + return newIdx; +} + + +/** + Remove a custom box from the list of boxes. + Please fill in the index parameter with the value + that was returned by insertCustomBox. + + \note This method also removes the last frame, that was attached to this + box (if any), so the only reason for calling removeFrame() manually would + be, that you have specified more than one frame for this box. + + + \sa removeAllCustomBoxes, insertCustomBox, customBox, maxCustomBoxIdx + */ +bool KDChartParams::removeCustomBox( const uint & idx ) +{ + const bool bFound = _customBoxDict.remove( idx ); + if( bFound ){ + // also remove any frame, that was attached to this box + removeFrame( KDChartEnums::AreaCustomBoxesBASE + idx ); + } + _customBoxDictMayContainHoles = true; + emit changed(); + return bFound; +} + + +/** + \fn void KDChartParams::removeAllCustomBoxes() + Remove all custom boxes from the list of boxes. + + \sa removeCustomBox, insertCustomBox, customBox, maxCustomBoxIdx + */ + + +/** + Retrieve a const pointer to a custom box from the list. + You may fill in the index parameter with the value + that was returned by insertCustomBox, or you may use a numerical value, + e.g. when iterating from zero up to maxCustomBoxIdx(). + + \return Zero if the custom box has been removed by calling removeCustomBox. + + \sa insertCustomBox customBoxRef, removeCustomBox, removeAllCustomBoxes, maxCustomBoxIdx + */ +const KDChartCustomBox* KDChartParams::customBox( uint box ) const +{ + return _customBoxDict.find( box ); +} + +/** + Retrieve a non-const pointer to a custom box from the list. + You may fill in the index parameter with the value + that was returned by insertCustomBox, or you may use a numerical value, + e.g. when iterating from zero up to maxCustomBoxIdx(). + + \note The reference returned by this method may be used to directly + modify the properties of the respective box. + + \return Zero if the custom box has been removed by calling removeCustomBox. + + \sa insertCustomBox customBox, removeCustomBox, removeAllCustomBoxes, maxCustomBoxIdx + */ +KDChartCustomBox* KDChartParams::customBoxRef( uint box ) +{ + return _customBoxDict.find( box ); +} + +/** + Retrieve the biggest custom boxes ID used. + + \sa insertCustomBox, removeCustomBox, removeAllCustomBoxes, customBox + */ +uint KDChartParams::maxCustomBoxIdx() const +{ + uint cnt( _customBoxDict.count() ); + if( cnt ) { + int maxIndex = cnt-1; + QIntDictIterator it( _customBoxDict ); + for( ; it.current(); ++it ) + if( it.currentKey() > maxIndex ) + maxIndex = it.currentKey(); + return maxIndex; + } + return 0; +} + +/** + \enum KDChartParams::ChartType + + The chart type. Covers only built-in chart types. + + \sa setChartType, chartType + \sa setAdditionalChartType, additionalChartType, + \sa setChartSourceMode + */ + + +/** + Specifies the chart type. The default is bar charts (Bar). + + \note Allways call this before specifying other + axis properties and before calling \c setAdditionalChartType().
+ \c setChartType() deactivates the right axis and also sets the + axisLabelsTouchEdges back to their default for all bottom and + top axes. + + \note Calling setChartType() results in changing the default data value + texts font settings (i.e. the font size, colour, position, but not the + QFont itself) if these parameters were not changed by + setPrintDataValues(). + In order to re-activate this automatical adjustment of font settings + even after you have changed them manually you may call + setPrintDataValuesWithDefaultFontParams(). + \li When calling setPrintDataValuesWithDefaultFontParams() + before calling setChartType() make sure you set the + \c callSetPrintDataValues parameter to \c false. + \li When calling setPrintDataValuesWithDefaultFontParams() + after calling setChartType() you may set the \c + callSetPrintDataValues parameter to \c true or you may call + setPrintDataValues() yourself after calling + setPrintDataValuesWithDefaultFontParams() to specify additional + parameters. + + \param chartType the chart type to use + \sa chartType, ChartType + \sa setAdditionalChartType, additionalChartType, + \sa setBarChartSubType, barChartSubType + \sa setLineChartSubType, lineChartSubType + \sa setPolarChartSubType, polarChartSubType + \sa setChartSourceMode, chartSourceMode + \sa setAxisLabelsTouchEdges + */ +void KDChartParams::setChartType( ChartType chartType ) +{ + _chartType = chartType; + + // de-activate 2nd axis that might have been set automatically + // by a previous call of \c setAdditionalChartType() + setAxisVisible( KDChartAxisParams::AxisPosRight, false ); + + // Make sure abscissa axes start their labeling at the very + // first position and end at the last position when drawing + // area charts. + // Bar charts and line charts look better with their abscissa labels + // in the respective middle positions below each bar (or point, resp.) + bool bAbscissaAxisLabelsTouchEdges = ( Area == chartType ); + setAxisLabelsTouchEdges( KDChartAxisParams::AxisPosBottom, + bAbscissaAxisLabelsTouchEdges ); + setAxisLabelsTouchEdges( KDChartAxisParams::AxisPosTop, + bAbscissaAxisLabelsTouchEdges ); + setAxisLabelsTouchEdges( KDChartAxisParams::AxisPosBottom2, + bAbscissaAxisLabelsTouchEdges ); + setAxisLabelsTouchEdges( KDChartAxisParams::AxisPosTop2, + bAbscissaAxisLabelsTouchEdges ); + // activate default data value text settings for this chart type + if ( printDataValues( 0 ) + && printDataValuesWithDefaultFontParams( 0 ) ) + setPrintDataValues( true, 0 ); + emit changed(); +} + + +/** + \fn KDChartParams::ChartType KDChartParams::chartType() const + + Returns the chart type configured in this params object. + + \return the chart type configured in this params object. + \sa setChartType, ChartType + \sa setAdditionalChartType, additionalChartType, + \sa setBarChartSubType, barChartSubType + \sa setLineChartSubType, lineChartSubType + \sa setPolarChartSubType, polarChartSubType + \sa setChartSourceMode, chartSourceMode + */ + + + +/** + Specifies the additional chart type. + The default is no additional chart (NoType). + The additional chart will have no grid so either make sure you + specify the chart that should have a grid via \c setChartType() and + the other one as additional chart or specify the grid manually if you + need one for the additional chart too. + + The additional chart uses the same abscissa axis as the main chart, + but cannot change the abscissa settings: the abscissa range and step width + is determined according to the main chart's values. + + You may combine all different types of cartesian charts + (== Bar, Line, HiLo, ..., but not Polar, Pie, ...) + so e.g. the following combinations are possible:
+ + \verbatim + setChartType( KDChartParams::Bar ); + setAdditionalChartType( KDChartParams::Line ); + \endverbatim + or + \verbatim + setChartType( KDChartParams::Line ); + setAdditionalChartType( KDChartParams::HiLo ); + \endverbatim + or + \verbatim + setChartType( KDChartParams::Bar ); + setAdditionalChartType( KDChartParams::Bar ); + ... + \endverbatim + + \note When defining multiple charts it is mandatory to + call \c setChartSourceMode() for specifying the dataset(s) + and their respective charts after calling \c setAdditionalChartType(), + also it is recommended to call \c setAxisDatasets() for all + axes to be used by the different datasets - otherwise the + default setting will be used (all datasets except the last + one match the left axis, the last dataset matches the right axis), + so e.g. your code to have a bar chart for datasets 0..2 (using the + left axis) and a line chart for datasets 3..4 (using the right axis) + could look like this: + + \verbatim + setChartType( KDChartParams::Bar ); + setAdditionalChartType( KDChartParams::Line ); + setChartSourceMode( KDChartParams::DataEntry, 0,2, 0 ); + setChartSourceMode( KDChartParams::DataEntry, 3,4, 1 ); + setAxisDatasets( KDChartAxisParams::AxisPosLeft, 0,2, 0 ); + setAxisDatasets( KDChartAxisParams::AxisPosRight, 3,4, 1 ); + \endverbatim + + \note In case you DON'T want to use the right axis but the left axis #2 + make sure to reset the dataset assignment that is automatically done for + the right axis. Doing this will also clear the visibility flag of the + right axis that is automatically set by setAdditionalChartType() + implicitely assuming that the additional chart will use the right axis, + so there is no need to explicitely call setAxisVisible( false ) for + the right axis: specifying KDCHART_NO_DATASET is enough to disable it. + e.g. in the example shown above you would replace the + last line by these ones: + + \verbatim + setAxisDatasets( KDChartAxisParams::AxisPosLeft2, 3,4, 1 ); + setAxisDatasets( KDChartAxisParams::AxisPosRight, + KDCHART_NO_DATASET ); + \endverbatim + + Often your additional chart will look better when not overlapping with + the first chart, specifying different y-positions for the charts + is possible by \c KDChartAxisParams::setAxisUseAvailableSpace(), + e.g. like this: + +\verbatim +// specify which amount of the available space +// is to be used by the first y-axis: + +KDChartAxisParams pa( + _p->axisParams( KDChartAxisParams::AxisPosLeft ) ); +pa.setAxisUseAvailableSpace( 0, -499 ); +_p->setAxisParams( KDChartAxisParams::AxisPosLeft, pa ); + +// specify which amount of the available space +// is to be used by the second y-axis: + +pa = _p->axisParams( KDChartAxisParams::AxisPosLeft2 ); +pa.setAxisUseAvailableSpace( -750, -1000 ); +_p->setAxisParams( KDChartAxisParams::AxisPosLeft2, pa ); +\endverbatim + +\param chartType the additional chart type to use + +\sa additionalChartType, setChartSourceMode, setAxisDatasets +\sa
chartType, ChartType +\sa setBarChartSubType, barChartSubType +\sa setLineChartSubType, lineChartSubType + */ +void KDChartParams::setAdditionalChartType( ChartType chartType ) +{ + _additionalChartType = chartType; + if ( KDChartParams::NoType == chartType ) { + setAxisDatasets( KDChartAxisParams::AxisPosRight, + KDCHART_NO_DATASET ); + } else { + setAxisDatasets( KDChartAxisParams::AxisPosRight, + KDCHART_ALL_DATASETS, + KDCHART_ALL_DATASETS, + 1 ); + if( printDataValues( 1 ) + && printDataValuesWithDefaultFontParams( 1 ) ) + setPrintDataValues( true, 1 ); + } + emit changed(); +} + + +/** + \fn void KDChartParams::ChartType KDChartParams::additionalChartType() const + + Returns the additional chart type configured in this params object. + + \return the additional chart type configured in this params object. + \sa setAdditionalChartType, setChartSourceMode, chartSourceMode + \sa
setChartType, ChartType + \sa setBarChartSubType, barChartSubType + \sa setLineChartSubType, lineChartSubType + */ + + + +/** + \fn bool KDChartParams::neverUsedSetChartSourceMode() const + + Retrieves whether setChartSourceMode() was called or not + */ + + + + +/** + \fn uint KDChartParams::maxDatasetSourceMode() const + + Returns the number of the highest dataset for which a SourceMode has been + defined. + + \return the number of the highest dataset for which a SourceMode has been + defined. + \sa setChartSourceMode, chartSourceMode, findDataset + */ + +/** + \fn void KDChartParams::setNumValues( uint ) + + Specifies how many of the values should be shown. -1 means all + available values. + + \param numValues the number of values to be shown + \sa numValues + */ + +/** + \fn int KDChartParams::numValues() const + + Returns how many of the values should be shown. -1 means all + available values. + + \return the number of values to be shown + \sa setNumValues + */ + + +/** + \fn void KDChartParams::setShadowBrightnessFactor( double factor ) + + Specifies a factor to be used to adjust the + built-in brightness of shadow colors in + 3-dimensional drawings like e.g. 3D Bar charts. + + \param factor a factor that is to be taken into account for internal + calculation of shadow colors. By specifying values greater 1.0 you + may lighten the shadows until the most intensive brightness is + reached, while values smaller than 1.0 will darken the shadows until + the respective colors are black. + + \sa shadowBrightnessFactor + */ + + +/** + \fn double KDChartParams::shadowBrightnessFactor() const + + Returns a factor to be used to adjust the + built-in brightness of shadow colors in + 3-dimensional drawings like e.g. 3D Bar charts. + + \return a factor that is to be taken into account for internal + calculation of shadow colors. + + \sa setShadowBrightnessFactor + */ + + +/** + \fn void KDChartParams::setShadowPattern( Qt::BrushStyle style ) + + Specifies a filling style for filling the shadow areas in + 3-dimensional drawings like 3D bar charts. The default is to + fill with a solid color, the color is determined with \a + setThreeDShadowColors. + + \param style the fill style to use + \sa shadowPattern(), setThreeDShadowColors(), + threeDShadowColors() + */ + + +/** + \fn Qt::BrushStyle KDChartParams::shadowPattern() const + + Returns the filling style used for filling the shadow areas in + 3-dimensional drawings like 3D bar charts. The default is to + fill with a solid color, the fill color can be queried with \a + threeDShadowColors(). + + \return the fill style used + \sa setShadowPattern(), setThreeDShadowColors(), + threeDShadowColors() + */ + +/** + \fn void KDChartParams::setOutlineDataColor( QColor color ) + + Specifies a color for the outlines of data displays. The default is + black. + + \note Use setOutlineDataLineStyle( Qt::NoPen ) to hide the line. + + \param color the color to use for the outlines + \sa outlineDataColor, setOutlineDataLineStyle, setOutlineDataLineWidth + */ + + +/** + \fn QColor KDChartParams::outlineDataColor() const + + Returns the color for the outlines of data displays. + + \return the outline color + \sa setOutlineDataColor + */ + + +/** + \fn void KDChartParams::setOutlineDataLineWidth( uint width ) + + Specifies the width of the outlines of data displays. The default is 1 + pixel. + + \note Use setOutlineDataLineStyle( Qt::NoPen ) to hide the line. + + \param width the line width to use for the outlines + \sa outlineDataLineWidth, setOutlineDataLineStyle, setOutlineDataColor + */ + + +/** + \fn uint KDChartParams::outlineDataLineWidth() const + + Returns the width of the outlines of data displays. + + \param style the line width that is used for outlines + \sa setOutlineDataLineWidth + */ + + +/** + \fn void KDChartParams::setOutlineDataLineStyle( PenStyle style ) + + Specifies the line style of the outlines of data displays. The default + is a solid line. Warning: On Windows 95/98, the style setting (other + than NoPen and SolidLine) has no effect for lines with width greater + than 1, due to a bug in the operating system. + + \param width the line style to use for the outlines + \sa outlineDataLineStyle, setOutlineDataColor, setOutlineDataLineWidth + */ + + +/** + \fn PenStyle KDChartParams::outlineDataLineStyle() const + + Returns the style of the outlines of data displays. + + \param style the line style that is used for outlines + \sa setOutlineDataLineStyle + */ + + +/** + \fn uint KDChartParams::maxDataColor() const + + Returns the number of the highest dataset for which a color has been + defined. + + \return the number of the highest dataset for which a color has been + defined. + \sa setDataColor, dataColor + */ + + +/** + \fn void KDChartParams::setThreeDShadowColors( bool shadow ) + + Specifies whether the engine should draw the sides and tops of + 3D effects in shadowed versions of the data colors (the + default) or in the data colors themselves. Only used with 3D + effects in charts that support these. + + \param shadow true for shadowed colors, false for original colors + \sa threeDShadowColors + */ + + +/** + \fn bool KDChartParams::threeDShadowColors() const + + Returns whether the engine should draw the sides and tops of 3D effects in + shadowed versions of the data colors or in the data colors + themselves. Only used with 3D effects in charts that + support these. The default is true. + + \return true if shadowed colors are used for 3D effects + \sa setThreeDShadowColors + */ + + +/** + \fn void KDChartParams::setAllowOverlappingDataValueTexts( bool allow ) + + Specifies whether a data value text may be drawn even if it's + region intersects with another data value text's region. + + By default this is FALSE to prevent ugly mutual overwriting of + data value texts and to speed up drawing of cahrts containing + thousands of data points. + */ + + +/** + \fn bool KDChartParams::allowOverlappingDataValueTexts() const + + Returns whether a data value text may be drawn even if it's region + intersects with another data value text's region. + + By default this is FALSE to prevent ugly mutual overwriting of data + value texts and to speed up drawing of cahrts containing thousands + of data points. + */ + + +/** + Specifies how the data value text figures are modified before printing. + + This methode is provided for your convenience, to learn how to set the + other text parameters please have a look at setPrintDataValues. + + \sa printDataValuesWithDefaultFontParams, setPrintDataValues + \sa dataValuesColor + \sa setPrintDataValuesFontRelSize setPrintDataValuesBackground + */ +void KDChartParams::setDataValuesCalc( int divPow10, + int digitsBehindComma, + uint chart ) +{ + uint count = (KDCHART_ALL_CHARTS == chart) ? 2 : 1; + PrintDataValuesSettings * settings = (( 1 < count ) || ( 0 == chart )) + ? &_printDataValuesSettings + : &_printDataValuesSettings2; + for ( uint i = 0; i < count; ++i ) { + settings->_divPow10 = divPow10; + settings->_digitsBehindComma = digitsBehindComma; + if ( 0 < chart ) + settings = &_printDataValuesSettings2; + } + emit changed(); +} + +/** + Specifies the font to be used for printing the data value texts. + + This methode is provided for your convenience, to learn how to set the + other text parameters please have a look at setPrintDataValues. + + \sa printDataValuesWithDefaultFontParams, setPrintDataValues + \sa dataValuesColor + \sa setPrintDataValuesFontRelSize setPrintDataValuesBackground + */ +void KDChartParams::setDataValuesFont( QFont* font, + uint size, + uint chart ) +{ + uint count = (KDCHART_ALL_CHARTS == chart) ? 2 : 1; + PrintDataValuesSettings * settings = (( 1 < count ) || ( 0 == chart )) + ? &_printDataValuesSettings + : &_printDataValuesSettings2; + for ( uint i = 0; i < count; ++i ) { + settings->_useDefaultFontParams = false; + if( font ) + settings->_dataValuesFont = *font; + if( UINT_MAX != size ){ + settings->_dataValuesUseFontRelSize = ( 0 < size ); + settings->_dataValuesFontRelSize = size; + } + if ( 0 < chart ) + settings = &_printDataValuesSettings2; + } + emit changed(); +} + +/** + Specifies the position and rotation of the data value texts to be printed. + + This methode is provided for your convenience, to learn how to set the + other text parameters please have a look at setPrintDataValues. + + \sa printDataValuesWithDefaultFontParams, setPrintDataValues + \sa dataValuesColor + \sa setPrintDataValuesFontRelSize setPrintDataValuesBackground + */ +void KDChartParams::setDataValuesPlacing( KDChartEnums::PositionFlag position, + uint align, + int deltaX, + int deltaY, + int rotation, + bool specifyingPositiveValues, + uint chart ) +{ + uint count = (KDCHART_ALL_CHARTS == chart) ? 2 : 1; + PrintDataValuesSettings * settings = (( 1 < count ) || ( 0 == chart )) + ? &_printDataValuesSettings + : &_printDataValuesSettings2; + for ( uint i = 0; i < count; ++i ) { + if( specifyingPositiveValues ){ + // for values greater/equal zero: + settings->_dataValuesAnchorPositivePosition = position; + settings->_dataValuesAnchorPositiveAlign = align; + settings->_dataValuesAnchorPositiveDeltaX = deltaX; + settings->_dataValuesAnchorPositiveDeltaY = deltaY; + settings->_dataValuesPositiveRotation = rotation; + }else{ + // for values below zero: + settings->_dataValuesAnchorNegativePosition = position; + settings->_dataValuesAnchorNegativeAlign = align; + settings->_dataValuesAnchorNegativeDeltaX = deltaX; + settings->_dataValuesAnchorNegativeDeltaY = deltaY; + settings->_dataValuesNegativeRotation = rotation; + } + if ( 0 < chart ) + settings = &_printDataValuesSettings2; + } + emit changed(); +} + +/** + Specifies the text color and background brush to be used for + printing the data value texts. + + To have the color calculated automatically - useful when printing + inside the bars (or pie slices, areas, ... resp.) - please use + \c KDCHART_DATA_VALUE_AUTO_COLOR instead of a QColor*. + + Setting the background is normally not needed since reasonable + settings are done by default: Area charts have a white background + behind the data value texts while all other chart types use no + special background (the value is Qt::NoBrush then). + + In case you want to use it to remove the extra background from + your Area chart's data value texts you should consider changing + the dataset colors as well: an idea might be trying the subdued + colorset by calling \c setSubduedColors(). + + \sa printDataValuesWithDefaultFontParams + \sa setPrintDataValues + \sa dataValuesColor + \sa setPrintDataValuesFontRelSize + */ +void KDChartParams::setDataValuesColors( const QColor* color, + const QBrush& background, + uint chart ) +{ + // first store the color + if( color ) + setPrintDataValuesColor( chart, color ); + // now store the background + uint count = (KDCHART_ALL_CHARTS == chart) ? 2 : 1; + PrintDataValuesSettings * settings = (( 1 < count ) || ( 0 == chart )) + ? &_printDataValuesSettings + : &_printDataValuesSettings2; + for ( uint i = 0; i < count; ++i ) { + settings->_dataValuesBrush = background; + if ( 0 < chart ) + settings = &_printDataValuesSettings2; + } + emit changed(); +} + + +/* sorry, but policy handling is not implemnted yet: */ +void KDChartParams::setDataValuesPolicy( + KDChartEnums::TextLayoutPolicy policy, + uint chart ) +{ + uint count = (KDCHART_ALL_CHARTS == chart) ? 2 : 1; + PrintDataValuesSettings * settings = (( 1 < count ) || ( 0 == chart )) + ? &_printDataValuesSettings + : &_printDataValuesSettings2; + for ( uint i = 0; i < count; ++i ) { + settings->_dataValuesLayoutPolicy = policy; + if ( 0 < chart ) + settings = &_printDataValuesSettings2; + } + emit changed(); +} + + +/** + Specifies whether data value texts should be printed even if the + value is KDCHART_POS_INFINITE (or KDCHART_NEG_INFINITE). + + Printing of an infinite symbol (lemniskate) is done by default, + ou may use this function to disable it. + + \sa printDataValuesWithDefaultFontParams + \sa setPrintDataValues + \sa dataValuesColor + \sa setPrintDataValuesFontRelSize + */ +void KDChartParams::setDataValuesShowInfinite( bool dataValuesShowInfinite, + uint chart) +{ + uint count = (KDCHART_ALL_CHARTS == chart) ? 2 : 1; + PrintDataValuesSettings * settings = (( 1 < count ) || ( 0 == chart )) + ? &_printDataValuesSettings + : &_printDataValuesSettings2; + for ( uint i = 0; i < count; ++i ) { + settings->_dataValuesShowInfinite = dataValuesShowInfinite; + if ( 0 < chart ) + settings = &_printDataValuesSettings2; + } + emit changed(); +} + + +/* function only there for backward compatibility */ +void KDChartParams::setPrintDataValuesColor( uint chart, const QColor* color ) +{ + uint count = (KDCHART_ALL_CHARTS == chart) ? 2 : 1; + PrintDataValuesSettings * settings = (( 1 < count ) || ( 0 == chart )) + ? &_printDataValuesSettings + : &_printDataValuesSettings2; + for ( uint i = 0; i < count; ++i ) { + if ( KDCHART_DATA_VALUE_AUTO_COLOR == color ) { + settings->_dataValuesAutoColor = true; // !!! + settings->_dataValuesColor = QColor( Qt::black ); + } + else { + settings->_dataValuesAutoColor = false; + if ( 0 == color ) + settings->_dataValuesColor + = QColor( i ? Qt::darkBlue : Qt::black ); + else + settings->_dataValuesColor = *color; + } + if ( 0 < chart ) + settings = &_printDataValuesSettings2; + } + emit changed(); +} + + +/** + Specifies the dynamic font size to be used for printing the data + value texts. To change settings for all charts specify \c + KDCHART_ALL_CHARTS as \chart parameter. + + This methode is provided for your convenience, to learn how to set the + other text parameters please have a look at setPrintDataValues. + + \sa printDataValuesWithDefaultFontParams, setPrintDataValues + \sa setPrintdataValuesColor, dataValuesFontRelSize + */ +void KDChartParams::setPrintDataValuesFontRelSize( uint chart, uint size ) +{ + uint count = (KDCHART_ALL_CHARTS == chart) ? 2 : 1; + PrintDataValuesSettings * settings = (( 1 < count ) || ( 0 == chart )) + ? &_printDataValuesSettings + : &_printDataValuesSettings2; + uint theSize( UINT_MAX == size ? 16 : size ); + for ( uint i = 0; i < count; ++i ) { + settings->_dataValuesUseFontRelSize = ( 0 < theSize ); + settings->_dataValuesFontRelSize = theSize; + if ( 0 < chart ) + settings = &_printDataValuesSettings2; + } + emit changed(); +} + + +/** + Specifies that data value texts are to be printed with default font + parameters. Calling this methode results in resetting the + respective font size and colour and position parameters but not the + QFont itself. By setting \c callSetPrintDataValues to true you + select general enabling of text printing, when doing so it is + not neccessary to call setPrintDataValues() after calling + setPrintDataValuesWithDefaultFontParams(). + + \note If you want to call setChartType() after calling + setPrintDataValuesWithDefaultFontParams() you should set the \c + callSetPrintDataValues parameter to false to prevent + setPrintDataValues() from being called twice since it is called + internally each time you call setChartType() if the default + font params are to be set. + + \sa printDataValuesWithDefaultFontParams, setPrintDataValues + */ +void KDChartParams::setPrintDataValuesWithDefaultFontParams( uint chart, + bool callSetPrintDataValues ) +{ + uint count = (KDCHART_ALL_CHARTS == chart) ? 2 : 1; + PrintDataValuesSettings * settings = (( 1 < count ) || ( 0 == chart )) + ? &_printDataValuesSettings + : &_printDataValuesSettings2; + for ( uint i = 0; i < count; ++i ) { + settings->_printDataValues = true; + settings->_useDefaultFontParams = true; + if ( 0 < chart ) + settings = &_printDataValuesSettings2; + } + if ( callSetPrintDataValues ) + setPrintDataValues( true, chart ); +} + + +/** + \fn bool KDChartParams::printDataValuesWithDefaultFontParams( uint chart ) const + + Retrieves whether data value texts are to be printed with + non-default font parameters or not - when text printing is + active. + + \note You might also want to call printDataValues to see if text + printing is active since this default flag remains set in + background even when printing has been de-activated. + + \sa setPrintDataValuesWithDefaultFontParams, printDataValues + */ + + +/** + \fn bool KDChartParams::printDataValues( uint chart ) const + + Returns whether the data values will be printed near their + respective entries. + + \param chart The number of the chart: 0 for the first chart, 1 for + the second chart in case there are two charts to be drawn sharing the + same data area. + + \return whether the data values will be printed near their + respective entries. + + \sa setPrintDataValues + */ + + +/** + \fn QFont KDChartParams::dataValuesFont( uint chart ) const + + Returns the font to be used for printing the data values + + \param chart The number of the chart: 0 for the first chart, 1 for + the second chart in case there are two charts to be drawn sharing the + same data area. + + \returns the font to be used for printing the data values + + \sa setPrintDataValues + */ + + +/** + \fn bool KDChartParams::dataValuesUseFontRelSize( uint chart ) const + + Returns whether the font size to be used for printing the + data values is calculated dynamically. + + \param chart The number of the chart: 0 for the first chart, 1 for + the second chart in case there are two charts to be drawn sharing the + same data area. + + \return whether the font size to be used for printing the + data values is calculated dynamically. + + \sa setPrintDataValues, setPrintDataValuesFontRelSize + */ + + +/** + \fn int KDChartParams::dataValuesFontRelSize( uint chart ) const + + Returns the relative size (in per mille of the chart width) + of font size to be used for printing the + data values. + + \param chart The number of the chart: 0 for the first chart, 1 for + the second chart in case there are two charts to be drawn sharing the + same data area. + + \return the relative size (in per mille of the chart width) + of font size to be used for printing the + data values. + + \sa setPrintDataValues, setPrintDataValuesFontRelSize + */ + + +/** + \fn QColor KDChartParams::dataValuesColor( uint chart ) const + + Returns the colour of the font to be used for printing the + data values. + + \param chart The number of the chart: 0 for the first chart, 1 for + the second chart in case there are two charts to be drawn sharing the + same data area. + + \return the colour of the font to be used for printing the + data values. + + \sa setPrintDataValues, setPrintDataValuesColor + */ + + +/** + \fn bool KDChartParams::dataValuesAutoColor( uint chart ) const + + Returns whether the font to be used for printing the data values + texts shall have automatically calculated colors fitting to their + respectivs data representations. + + \param chart The number of the chart: 0 for the first chart, 1 for + the second chart in case there are two charts to be drawn sharing the + same data area. + + \return whether the font to be used for printing the data values texts + shall have automatically calculated colors fitting to their respectivs data representations. + + \sa setPrintDataValues + */ + + +/** + Returns the anchor position which the text is to be aligned to. + + \param chart The number of the chart: 0 for the first chart, 1 for + the second chart in case there are two charts to be drawn sharing the + same data area. + + \param negative If true the return value is only valid for data + values less than zero, if false it applies to data values greater + or equal to zero. + + \returns the anchor position which the text is to be aligned to in case of + the value being less than zero. + + \sa setPrintDataValues + */ +KDChartEnums::PositionFlag KDChartParams::dataValuesAnchorPosition( uint chart, bool negative ) const +{ + if ( negative ) + return chart ? _printDataValuesSettings2._dataValuesAnchorNegativePosition + : _printDataValuesSettings._dataValuesAnchorNegativePosition; + else + return chart ? _printDataValuesSettings2._dataValuesAnchorPositivePosition + : _printDataValuesSettings._dataValuesAnchorPositivePosition; +} + + +/** + Returns the way how the text is to be aligned to the anchor. + + This must be a reasonable combination of Qt::AlignmentFlags. + + \param chart The number of the chart: 0 for the first chart, 1 for + the second chart in case there are two charts to be drawn sharing the + same data area. + + \param negative If true the return value is only valid for data + values less than zero, if false it applies to data values greater + or equal to zero. + + \returns the way how the text is to be aligned to the anchor in case of + the value being less than zero. + + \sa setPrintDataValues + */ +uint KDChartParams::dataValuesAnchorAlign( uint chart, bool negative ) const +{ + if ( negative ) + return chart ? _printDataValuesSettings2._dataValuesAnchorNegativeAlign + : _printDataValuesSettings._dataValuesAnchorNegativeAlign; + else + return chart ? _printDataValuesSettings2._dataValuesAnchorPositiveAlign + : _printDataValuesSettings._dataValuesAnchorPositiveAlign; +} + + +/** + Returns the X distance between the text and its anchor. + + \note For better compatibility to the dynamic font size, + this parameter is always interpreted as being a per-mille + value of the logical width of the drawing area. If greater 0, the X + position is increased, if less than 0, it is reduced, this is + calculated dynamically before painting. + + \param chart The number of the chart: 0 for the first chart, 1 for + the second chart in case there are two charts to be drawn sharing the + same data area. + + \param negative If true the return value is only valid for data + values less than zero, if false it applies to data values greater + or equal to zero. + + \returns the X distance between the text and its anchor. + + \sa setPrintDataValues + */ +int KDChartParams::dataValuesAnchorDeltaX( uint chart, bool negative ) const +{ + if ( negative ) + return chart ? _printDataValuesSettings2._dataValuesAnchorNegativeDeltaX + : _printDataValuesSettings._dataValuesAnchorNegativeDeltaX; + else + return chart ? _printDataValuesSettings2._dataValuesAnchorPositiveDeltaX + : _printDataValuesSettings._dataValuesAnchorPositiveDeltaX; +} + + +/** + Returns the Y distance between the text and its anchor. + + \note For better compatibility to the dynamic font size this + parameter is always interpreted as being a per-mille value + of the logical width of the drawing area. If greater 0, the Y + position is increased, if less than 0, it is reduced, this is + calculated dynamically before painting. + + \param chart The number of the chart: 0 for the first chart, 1 for + the second chart in case there are two charts to be drawn sharing the + same data area. + + \param negative If true the return value is only valid for data + values less than zero, if false it applies to data values greater + or equal to zero. + + \returns the Y distance between the text and its anchor. + + \sa setPrintDataValues + */ +int KDChartParams::dataValuesAnchorDeltaY( uint chart, bool negative ) const +{ + if ( negative ) + return chart ? _printDataValuesSettings2._dataValuesAnchorNegativeDeltaY + : _printDataValuesSettings._dataValuesAnchorNegativeDeltaY; + else + return chart ? _printDataValuesSettings2._dataValuesAnchorPositiveDeltaY + : _printDataValuesSettings._dataValuesAnchorPositiveDeltaY; +} + + +/** + Returns the amount of degrees (using a circle of 360 degrees) taken to + rotate the text. Positive values rotate clockwise, negative values rotate counter-clockwise. + + \param chart The number of the chart: 0 for the first chart, 1 for + the second chart in case there are two charts to be drawn sharing the + same data area. + + \param negative If true the return value is only valid for data + values less than zero, if false it applies to data values greater + or equal to zero. + + \returns the amount of degrees (using a circle of 360 degrees) taken to + rotate the text. + + \sa setPrintDataValues + */ +int KDChartParams::dataValuesRotation( uint chart, bool negative ) const +{ + if ( negative ) + return chart ? _printDataValuesSettings2._dataValuesNegativeRotation + : _printDataValuesSettings._dataValuesNegativeRotation; + else + return chart ? _printDataValuesSettings2._dataValuesPositiveRotation + : _printDataValuesSettings._dataValuesPositiveRotation; +} + + +/** + \fn KDChartEnums::TextLayoutPolicy KDChartParams::dataValuesLayoutPolicy( uint chart ) const + + Returns the way to handle too narrow space conflicts: what to do if + a data text covers a neighboring data text (or a neighboring data + area, resp.). + + \note A layout policy different from LayoutJustOverwrite from does + not mean that this policy is followed in any case. Rather than + giving up when the selected policy does not result in a good layout + the program will automatically try the next policy: if + LayoutPolicyRotate did not succeed LayoutPolicyShiftVertically will + be tried, if this did not succeed either + LayoutPolicyShiftHorizontally will be tried. + + \param chart The number of the chart: 0 for the first chart, 1 for + the second chart in case there are two charts to be drawn sharing the + same data area. + + \returns the way to handle too narrow space conflicts. + + \sa setPrintDataValues + */ + +/** + \fn void KDChartParams::changed() + + This signal is emitted when any of the chart parameters has changed. + */ + +/** + \var const uint KDCHART_MAX_AXES + + Charts have up to 12 axes: + up to two axes on both sides for X, Y + and Z (if data is 3-dimensional). This constant is located here and + in KDChartAxisParams, because one KDChartAxisParams object + describes only one axis. + */ + +/** + \var static const int KDCHART_PROPSET_NORMAL_DATA; + + Default (built-in) property ID, used for data cells + without any special properties. + + Use this IDs without previously defining a respective + set of properties via KDChartParams::registerProperties(...). + + \note While (in theory) it is possible to assign special + property values to this build-in property set this normally might not + a very good idea since these values would apply to every(!) data cell + that has no other property set assigned. Such general changes + would rather be done calling KDChartParam's main functions, e.g. you + would invoke KDChartParams::setLineMarker(true) instead of changing + the normal-data property set. + + \sa KDCHART_PROPSET_TRANSPARENT_DATA + \sa KDCHART_PROPSET_HORI_LINE, KDCHART_PROPSET_VERT_LINE + \sa KDChartData::setPropertySet + \sa KDChartParams::registerProperties, KDChartParams::setProperties, KDChartParams::properties + */ + +/** + \var static const int KDCHART_PROPSET_TRANSPARENT_DATA; + + Predefined (build-in) property ID. used to specify a cell that should be displayed + using a null pen: neither the data representation nor + the connecting line to the next point will be shown, + but the line will be drawn using line style Qt::NoPen. + + Use this IDs without previously defining a respective + set of properties via KDChartParams::registerProperties(...). + + \note: Assigning this property to a data cell will result in the + cell being invisible: there will be no marker for this point and + there will be a 'gap' in this dataset's line from the point to the next one. + In case you want to change this default behavior, + use KDChartParams::setProperties(), + e.g. the following piece of code still has an invisible line while now + enabeling showing of the marker - but only if it was set active by + KDChartParams::setLineMarker(true). + + \verbatim + KDChartPropertySet transpProps; + bool bDummy; + if( properties(KDCHART_PROPSET_TRANSPARENT_DATA, + transpProps) ){ +// build-in property was found, let's modify it a bit: +transpProps.setShowMarker( +KDCHART_PROPSET_NORMAL_DATA, bDummy ); +setProperties(KDCHART_PROPSET_TRANSPARENT_DATA, +transpProps); +}else{ +// Ooops? The build-in property was NOT found! +// OK, never mind, let's specify it from scratch: +transpProps.setName("transparent data"); +transpProps.setLineStyle(KDChartPropertySet::OwnID, Qt::NoPen); +transpProps.setShowMarker( +KDCHART_PROPSET_NORMAL_DATA, bDummy); +setProperties(KDCHART_PROPSET_TRANSPARENT_DATA, +transpProps); +} +\endverbatim + +\note The example above uses setProperties (in the last line) to +define a property set. This is the right way for build-in property sets, +but it is not recomended for your additional user-defined property sets: +these should be registered with the registerProperties function +to initially obtain a unique ID number for your new property set, +see the second example given with \c KDCHART_PROPSET_VERT_LINE. + +\sa KDCHART_PROPSET_NORMAL_DATA +\sa KDCHART_PROPSET_HORI_LINE, KDCHART_PROPSET_VERT_LINE +\sa KDChartData::setPropertySet +\sa KDChartParams::registerProperties, KDChartParams::setProperties, KDChartParams::properties +*/ + +/** + \var static const int KDCHART_PROPSET_HORI_LINE; + + Predefined (build-in) property ID. may be used to specify a special cell + which is not part of the normal data but to be used for positioning + a separate horizontal line. + Data display will be surpressed for this point: neither the data + representation nor the connecting line to the next point will + be shown, actually the point will remain invisible but a horizontal + line will be drawn instead: using line style Qt::DotLine and the + respective dataset's line color. + + Use this IDs without previously defining a respective + set of properties via KDChartParams::registerProperties(...). + + In case you want to change this default behavior, + use KDChartParams::setProperties(), + e.g. the following piece of code still has an invisible line and + also does not show the point's marker while now showing two + separate markers at the horizontal line's start and end. + + \verbatim + KDChartPropertySet horiProps; + if( properties(KDCHART_PROPSET_HORI_LINE, + horiProps) ){ +// build-in property was found, let's modify it a bit: +horiProps.setExtraMarkersAlign( +KDChartPropertySet::OwnID, +Qt::AlignLeft | Qt::AlignRight ); +setProperties(KDCHART_PROPSET_HORI_LINE, +horiProps); +}else{ +// Ooops? The build-in property was NOT found! +// OK, never mind, let's specify it from scratch: +horiProps.setName("horizontal line"); +horiProps.setLineStyle(KDChartPropertySet::OwnID, Qt::NoPen); +horiProps.setShowMarker( KDChartPropertySet::OwnID, false ); +horiProps.setExtraMarkersAlign( KDChartPropertySet::OwnID, +Qt::AlignLeft | Qt::AlignRight ); +horiProps.setExtraMarkersAlign( +KDChartPropertySet::OwnID, +Qt::AlignLeft | Qt::AlignRight ); +setProperties(KDCHART_PROPSET_HORI_LINE, +horiProps); +} +\endverbatim + +\note The example above uses setProperties (in the last line) to +define a property set. This is the right way for build-in property sets, +but it is not recomended for your additional user-defined property sets: +these should be registered with the registerProperties function +to initially obtain a unique ID number for your new property set, +see the second example given with \c KDCHART_PROPSET_VERT_LINE. + +\sa KDCHART_PROPSET_NORMAL_DATA +\sa KDCHART_PROPSET_VERT_LINE +\sa KDChartData::setPropertySet +\sa KDChartParams::registerProperties, KDChartParams::setProperties, KDChartParams::properties +*/ + +/** + \var static const int KDCHART_PROPSET_VERT_LINE; + + Predefined (build-in) property ID. may be used to specify a special cell + which is not part of the normal data but to be used for positioning + a separate vertical line. + Data display will be surpressed for this point: neither the data + representation nor the connecting line to the next point will + be shown, actually the point will remain invisible but a vertical + line will be drawn instead: using line style Qt::DotLine and the + respective dataset's line color. + + Use this IDs without previously defining a respective + set of properties via KDChartParams::registerProperties(...). + + In case you want to change this default behavior, + use KDChartParams::setProperties(), + e.g. the following piece of code still has an invisible line and + also does not show the point's marker while now showing a + separate marker at the top end of the vertical line which + will not run across the complete data area but start + on the respective point's Y position and go to the top edge + of the chart's area. + + \verbatim + KDChartPropertySet vertProps; + if( properties(KDCHART_PROPSET_VERT_LINE, + vertProps) ){ +// build-in property was found, let's modify it a bit: +vertProps.setExtraMarkersAlign( +KDChartPropertySet::OwnID, Qt::AlignTop ); +setProperties(KDCHART_PROPSET_VERT_LINE, +vertProps); +}else{ +// Ooops? The build-in property was NOT found! +// OK, never mind, let's specify it from scratch: +vertProps.setName("vertical line"); +vertProps.setLineStyle(KDChartPropertySet::OwnID, Qt::NoPen); +vertProps.setShowMarker( KDChartPropertySet::OwnID, false ); +vertProps.setExtraMarkersAlign( KDChartPropertySet::OwnID, +Qt::AlignTop ); +vertProps.setExtraMarkersAlign( +KDChartPropertySet::OwnID, +Qt::AlignTop ); +setProperties(KDCHART_PROPSET_VERT_LINE, +vertProps); +} +\endverbatim + +\note The example above uses setProperties (in the last line) to +define a property set. This is the right way for build-in property sets, +but it is not recomended for your additional user-defined property sets: +these should be registered with the registerProperties function +to initially obtain a unique ID number for your new property set, +see the following example: + +The code shown below demonstrates how to specify a new +property set which then can be used for adding a red vertical +line with marker to some of your normal data points: + +\verbatim +// 1. specify and register the new property set +KDChartPropertySet dataWithTopLineProps; +dataWithTopLineProps.setName( +"normal data with red vertical line on top"); +dataWithTopLineProps.setExtraLinesAlign( +KDChartPropertySet::OwnID, +Qt::AlignTop ); +dataWithTopLineProps.setExtraLinesWidth( +KDChartPropertySet::OwnID, +-2 ); +dataWithTopLineProps.setExtraLinesColor( +KDChartPropertySet::OwnID, + Qt::red ); +dataWithTopLineProps.setExtraLinesStyle( + KDChartPropertySet::OwnID, + Qt::SolidLine ); +dataWithTopLineProps.setExtraMarkersAlign( + KDChartPropertySet::OwnID, + Qt::AlignTop ); +dataWithTopLineProps.setExtraMarkersSize( + KDChartPropertySet::OwnID, + QSize(-10, -10) ); +dataWithTopLineProps.setExtraMarkersColor( + KDChartPropertySet::OwnID, + Qt::darkRed ); +dataWithTopLineProps.setExtraMarkersStyle( + KDChartPropertySet::OwnID, + KDChartParams::LineMarkerCircle ); +int idDataWithTopLineProps += registerProperties( dataWithTopLineProps ); +// 2. assign this property set +// to some of your data cells +d = new KDChartTableData( 5, 10 ); +// ... +d->cell( 0, 2 ).setPropertySet( idDataWithTopLineProps ); +d->cell( 2, 5 ).setPropertySet( idDataWithTopLineProps ); +\endverbatim + +\sa KDCHART_PROPSET_NORMAL_DATA +\sa KDCHART_PROPSET_HORI_LINE +\sa KDChartData::setPropertySet +\sa KDChartParams::registerProperties, KDChartParams::setProperties, KDChartParams::properties +*/ + + + +//@} +// END GENERAL + +// START BARCHART +/** @name Bar chart-specific methods. + + These methods query and set barchart-specific parameters. + */ +//@{ + +/** + \enum KDChartParams::BarChartSubType + + The bar subtype. Only used when chartType() == Bar + + \sa setBarChartSubType, barChartSubType + */ + + +/** + \fn void KDChartParams::setBarChartSubType( BarChartSubType barChartSubType ) + Specifies the bar chart subtype. + + This setting only has an effect in bar charts. + + \param barChartSubType the bar chart subtype + \sa barChartSubType, BarChartSubType, setChartType, chartType + */ + + +/** + \fn KDChartParams::BarChartSubType KDChartParams::barChartSubType() const + + Returns the bar chart subtype. + + This setting only has an effect in bar charts. + + \return the bar chart sub type + \sa setBarChartSubType, BarChartSubType, setChartType, chartType + */ + + + +/** + \fn void KDChartParams::setThreeDBars( bool threeDBars ) + + Specifies whether the engine should draw the bars in 3D. + + This setting only has an effect in bar charts. + + \param threeDBars true if bars should be drawn with a 3D effect + \sa threeDBars, setThreeDBarAngle, threeDBarAngle + */ + + +/** + \fn bool KDChartParams::threeDBars() const + + Returns whether the engine should draw any bars in 3D. + + This setting only has an effect in bar charts. + + \return true if bars should be draws with a 3D effect, false + otherwise + \sa setThreeDBars, threeDBarAngle, setThreeDBarAngle + */ + +/** + \fn void KDChartParams::setThreeDBarsShadowColors( bool shadow ) + \obsolete + Specifies whether the engine should draw the sides and tops of 3D bars + in shadowed versions of the data colors or in the data colors + themselves. Only used if threeDBars() == true. The default is true. + + This setting only has an effect in bar charts. + + This method is obsolete; use setThreeDShadowColors instead + + \param shadow true for shadowed colors, false for original colors + \sa setThreeDShadowColors + */ + +/** + \fn bool KDChartParams::threeDBarsShadowColors() const + + \obsolete + Returns whether the engine should draw the sides and tops of 3D bars in + shadowed versions of the data colors or in the data colors + themselves. Only used if threeDBars() == true. The default is true. + + This setting only has an effect in bar charts. + + This method is obsolete; use threeDShadowColors instead + + \return true if bars use shadowed colors for 3D effects + \sa setThreeDBarsShadowColors + */ + + +/** + Specifies the angle used for 3D bars. Only used if threeDBars() == true. + + This setting only has an effect in bar charts. + + \param angle the angle in degrees. The default (and most useful + value) is 45. Angle can be between 0 and 90, all other values + are ignored. Values close to 0 or close to 90 may look + strange, depending on the resolution of the output device. + \sa setThreeDBars, threeDBars + \sa threeDBarAngle, cosThreeDBarAngle + \sa setThreeDBarDepth, threeDBarDepth + */ +void KDChartParams::setThreeDBarAngle( uint angle ) +{ + if ( angle > 90 ) /* since angle is an uint, we do not need to + test for < 0 */ + return ; + _threeDBarAngle = angle; + + // cache the cosine of this value + _cosThreeDBarAngle = cos( static_cast < double > ( _threeDBarAngle ) * M_PI / 180.0 ); + emit changed(); +} + + +/** + \fn uint KDChartParams::threeDBarAngle() const + + Returns the angle in degrees used for 3D bars. Only used if threeDBars() == true. + + This setting only has an effect in bar charts. + + \return the angle in degrees used for 3D bars, always between 0 and 90. + \sa setThreeDBars, threeDBars + \sa setThreeDBarAngle, cosThreeDBarAngle + \sa setThreeDBarDepth, threeDBarDepth + */ + + +/** + \fn double KDChartParams::cosThreeDBarAngle() const + + Returns the cosine in rad of the angle used for 3D bars. Only used + if threeDBars() == true. + + This setting only has an effect in bar charts. + + \return the cosine in rad of the angle used for 3D bars, always + between 0 and 90. \sa setThreeDBars, threeDBars \sa + setThreeDBarAngle, threeDBarAngle \sa setThreeDBarDepth, + threeDBarDepth + */ + + +/** + \fn void KDChartParams::setThreeDBarDepth( double depth ) + + Specifies the depth of the 3D Effect used for 3D bars. + Only used if threeDBars() == true. + + This setting only has an effect in bar charts. + + \param depth the depth of the 3D Effect in relation to + the bar width. The default (and most useful) value of + 1.0 may be used to specify bars with square basis. + \sa threeDBarDepth + \sa setThreeDBars, threeDBars + \sa setThreeDBarAngle, threeDBarAngle, cosThreeDBarAngle + */ + + +/** + \fn double KDChartParams::threeDBarDepth() const + + Returns the depth of the 3D Effect used for 3D bars. + Only used if threeDBars() == true. + + This setting only has an effect in bar charts. + + \return the depth of the 3D Effect in relation to the bar width. + \sa setThreeDBarDepth + \sa setThreeDBars, threeDBars + \sa setThreeDBarAngle, threeDBarAngle, cosThreeDBarAngle + */ + + +/** + \fn void KDChartParams::setDatasetGap( int gap ) + + Specifies the number of pixels between two dataset values. + In addition you might want to use \c setOutlineDataLineStyle( Qt::NoPen ) to hide the line. + + Also the method \c setValueBlockGap might be usefull, please read the information given there ... + + This setting only has an effect in bar charts: if there is more than one dataset shown by your chart. + + \note Use negative values for overlaps, use \c + setDatasetGapIsRelative to specify that the \c gap + value is a per mille value of the chart data area width. + + The default is 6 per mille of the data area of the chart. + + \param gap the number of pixels between two dataset values. + \sa setValueBlockGap + \sa datasetGap + \sa datasetGapIsRelative, setDatasetGapIsRelative + \sa setOutlineDataLineStyle + */ + + +/** + \fn int KDChartParams::datasetGap() const + + Returns the number of pixels between two dataset values. + + This setting only has an effect in bar charts. + + \note Negative values signify overlaps, use \c datasetGapIsRelative + to find out if the \datasetGap value is a per mille value of the + chart data area width. + + \return the number of pixels between two dataset values. + \sa setDatasetGap + \sa datasetGapIsRelative, setDatasetGapIsRelative + */ + + +/** + \fn void KDChartParams::setDatasetGapIsRelative( bool gapIsRelative ) + + Specifies if the value set by \c setDatasetGap is a + per mille value of the chart data area width. + + This setting only has an effect in bar charts. + + \param gapIsRelative specifies if the value set by \c setDatasetGap + is a per mille value of the chart data area width. + \sa datasetGapIsRelative, datasetGap, setDatasetGap + */ + + +/** + \fn bool KDChartParams::datasetGapIsRelative() const + + Returns if the value set by \c setDatasetGap + is a per mille value of the chart data area width. + + This setting only has an effect in bar charts. + + \return if the value set by \c setDatasetGap + is a per mille value of the chart data area width. + \sa setDatasetGap, setDatasetGapIsRelative, datasetGap, setDatasetGap + */ + + +/** + \fn void KDChartParams::setValueBlockGap( int gap ) + + Specifies the number of pixels between each value block. + If there is only one dataset shown this gap is appearing between each of the bars, otherwise it is appearing between each of the bar blocks. + In addition you might want to use \c setOutlineDataLineStyle( Qt::NoPen ) to hide the line. + + Also the method \c setDatasetGap might be usefull, please read the information given there ... + + This setting only has an effect in bar charts. + + Use negative values for overlaps (which might look strange), + use \c setValueBlockGapIsRelative to specify that the \c gap + value is a per mille value of the chart data area width. + + The default is 15 per mille of the data area of the chart. + + \note Specifying a value block gap width AND a bar width + may result in KD Chart not being able to display all bars + if the data area is not wide enough. To make your + application notice when this + happens you should consider connecting the + barsDisplayed() signal emitted by your KDChartWidget object + to an appropriate slot function. Additionally (or in case + you are not using the KDChartWidget class, resp.) + you may access the number of actually displayed/not displayed + bars by the KDChartParams functions numBarsDisplayed + and numBarsLeft, the return value of these functions + are not not defined if they are called before drawing is done. + + \param gap the number of pixels between each value block. + \sa setDatasetGap + \sa setBarWidth, valueBlockGap + \sa KDChartWidget::barsDisplayed, KDChart::barsDisplayed + \sa numBarsDisplayed, numBarsLeft + \sa valueBlockGapIsRelative, setValueBlockGapIsRelative + \sa setOutlineDataLineStyle + */ + + +/** + \fn int KDChartParams::valueBlockGap() const + + Returns the number of pixels between each value block. + + This setting only has an effect in bar charts. + + \note Negative values signify overlaps, use \c valueBlockGapIsRelative + to find out if the \valueBlockGap value is a per mille value of the + chart data area width. + + \return the number of pixels between each value block. + \sa valueBlockGap + \sa valueBlockGapIsRelative, setValueBlockGapIsRelative + */ + + +/** + \fn void KDChartParams::setBarWidth( int width ) + + Specifies the width of one bar: makes sure that all of + the bars have exactly the same width. + + This setting only has an effect in bar charts. + + \note Use negative values for to specify that the \c width + value is a per mille value of the chart data area width, + use no value or the default KDCHART_AUTO_SIZE + to (re)activate normal calculation mode making sure that all + bars fit into the available space but might not look so nice + if many bars are there. + + \note Specifying a bar width AND a value block gap width + may result in KD Chart not being able to display all bars + if the data area is not wide enough. To make your + application notice when this + happens you should consider connecting the + barsDisplayed() signal emitted by your KDChartWidget object + to an appropriate slot function. Additionally (or in case + you are not using the KDChartWidget class) + you may access the number of actually displayed/not displayed + bars by the KDChartParams functions numBarsDisplayed + and numBarsLeft, the return value of these functions + are not not defined if they are called before drawing is done. + + \param width the width of one bar. + \sa KDChartWidget::barsDisplayed, KDChart::barsDisplayed + \sa numBarsDisplayed, numBarsLeft + \sa setValueBlockGap + */ + +/** + \fn int KDChartParams::barWidth() const + + Returns the width of one bar as set by setBarWidth + or KDCHART_AUTO_SIZE if setBarWidth + was never called. + + This setting only has an effect in bar charts. + + \note Negative values signify that the bar width is + a per mille value of the chart data area width. + + \return the width of one bar as set by setBarWidth + or KDCHART_AUTO_SIZE if setBarWidth + was never called. + \sa setBarWidth + */ + +/** + \fn int KDChartParams::numBarsDisplayed() const + + Returns the number of bars that were displayed last + time your bar chart was drawn. + + This setting only has an effect in bar charts. + + This can be different from the number of bars you + actually wanted to display: by specifying both + the bar width and the value block gap width you + may controll your chart very well but take the risk + of not getting all bars drawn if there is not enough + horizontal space to display them with the given width + and gap width. + + To quickly determine if all bars were drawn just check + if the numBarsLeft() function returns a zero value. + + \return the number of bars that were drawn. + \sa KDChartWidget::barsDisplayed, KDChart::barsDisplayed + \sa numBarsLeft + \sa setBarWidth, setValueBlockGap + */ + +/** + \fn int KDChartParams::numBarsLeft() const + + Returns the number of bars that could NOT be painted + last time your bar chart was drawn. + + This setting only has an effect in bar charts. + + If this value is greater than zero, the bar chart + shows less bars than you + actually wanted to display: by specifying both + the bar width and the value block gap width you + may controll your chart very well but take the risk + of not getting all bars drawn if there is not enough + horizontal space to display them with the given width + and gap width. + + You may call the numBarsDisplayed() function to see + how many bars were drawn. + + \return the number of bars that could not be drawn. + \sa KDChartWidget::barsDisplayed, KDChart::barsDisplayed + \sa numBarsDisplayed + \sa setBarWidth, setValueBlockGap + */ + +/** + \fn void KDChartParams::setValueBlockGapIsRelative( bool gapIsRelative ) + + Specifies if the value set by \c setValueBlockGap is a + per mille value of the chart data area width. + + This setting only has an effect in bar charts. + + \param gapIsRelative specifies if the value set by \c setValueBlockGap + is a per mille value of the chart data area width. + \sa valueBlockGapIsRelative, valueBlockGap, setValueBlockGap + */ + + +/** + \fn bool KDChartParams::valueBlockGapIsRelative() const + + Returns if the value set by \c setValueBlockGap + is a per mille value of the chart data area width. + + This setting only has an effect in bar charts. + + \return if the value set by \c setValueBlockGap + is a per mille value of the chart data area width. + \sa setValueBlockGapIsRelative, setValueBlockGap, valueBlockGap + \sa setValueBlockGap + */ + + +/** + \fn void KDChartParams::setDrawSolidExcessArrows( bool solidArrows ) + + Specifies whether arrows showing excess values in bar charts should + be drawn solidly or split. + + This setting only has an effect in bar charts. + + If \a solidArrows is true, the bars with excess values (like + infinity, or any other value that exceeds the y-axis labelling) will + have an integrated arrow head. If \a solidArrows is false, they will + still have an integrated arrow head at a lower position, but also + two flat arrows on top of them to better indicate that there could + be a large gap. It is recommended to set this value to false (this + is also the default), as this makes the excess value situation much + more obvious. + + This setting only has an effect in bar charts. + + \param solidArrows whether excess arrows shown be drawn solidly or + split + \sa drawSolidExcessArrows +*/ + + +/** + \fn bool KDChartParams::drawSolidExcessArrows() const + + Returns whether arrows showing excess values in bar charts should + be drawn solidly or split. + + This setting only has an effect in bar charts. + + \return true if excess arrows are drawn solidly, false if they are + split + \sa setDrawSolidExcessArrows +*/ + + +//@} +// END BARCHART + +// START LINECHART +/** @name Line and area chart-specific methods. + + These methods query and set line and area chart-specific parameters. + */ +//@{ + +/** + \enum KDChartParams::LineChartSubType + + The line subtype. Only used when chartType == Line + + \sa setLineChartSubType, lineChartSubType + */ + + +/** + \fn void KDChartParams::setLineChartSubType( LineChartSubType lineChartSubType ) + + Specifies the line chart subtype. Only used if chartType() == + Line. The default is LineNormal. + + \param lineChartSubType the line chart subtype + \sa lineChartSubType, LineChartSubType, setChartType, chartType + */ + + +/** + \fn KDChartParams::LineChartSubType KDChartParams::lineChartSubType() const + + Returns the line chart subtype. Only used if chartType() == + Line. + + \return the line chart sub type + \sa setLineChartSubType, LineChartSubType, setChartType, chartType + */ + + + +/** + \fn void KDChartParams::setLineMarker( bool marker ) + + Specifies whether there should be a marker at each data + point. Only used if chartType() == Line and if threeDLines() == + false. The default is not to draw markers. + + \note Use the setLineMarkerStyle function to specify the shape + of the markers, use the setLineWidth function to set the + width of the lines connecting the markers (or to surpress + drawing of such lines, resp.) + + \param marker true if markers should be drawn + \sa setLineMarker, setLineMarkerSize + \sa setLineMarkerStyle, setLineColor, setLineWidth, setLineStyle + */ + + +/** + \fn bool KDChartParams::lineMarker() const + + Returns whether line markers should be drawn at each data + point. Only used if chartType() == Line and if threeDLines() == + false. + + \return true if markers should be drawn. + */ + + +/** + \enum KDChartParams::LineMarkerStyle + + The available line marker styles. + */ + + +/** + Specifies the line marker to be used for a dataset. Only used if + chartType() == Line and lineMarker() == true. If you specify a + marker for a dataset, but not for a dataset with a lower + value, then the marker for the dataset with the lower value + will be undefined unless it was previously defined. The default + is a circle for the first dataset, a square for the second, a + diamond for the third and undefined for all subsequent + datasets. + + \note Extra marker styles LineMarker1Pixel and LineMarker4Pixels + are intended for drawing charts representing large numbers + of data cells, when using these styles it might be a good + idea to set the line width to zero. This would surpress + drawing of the lines resulting in drawing the markers only. + + \param dataset the dataset for which to set the line marker + \param style the style to set for the specified dataset + \sa LineMarkerStyle, lineMarkerStyle, setLineMarkerSize + \sa setLineColor, setLineWidth, setLineStyle + */ +void KDChartParams::setLineMarkerStyle( uint dataset, LineMarkerStyle style ) +{ + _lineMarkerStyles[ dataset ] = style; + _maxDatasetLineMarkerStyle = QMAX( dataset, + _maxDatasetLineMarkerStyle ); + emit changed(); +} + +/** + Returns the marker to be used for a dataset. Only used if + chartType() == Line and lineMarker() == true. + + \param dataset the dataset for which to return the line marker + \return the line marker for the specified data set + \sa LineMarkerStyle, setLineMarkerStyle + */ +KDChartParams::LineMarkerStyle KDChartParams::lineMarkerStyle( uint dataset ) const +{ + if( _lineMarkerStyles.find( dataset ) != _lineMarkerStyles.end() ) + return _lineMarkerStyles[ dataset ]; + else + return LineMarkerCircle; // default +} + + + + +/** + \var KDChartParams::LineMarkerStyleMap; + + The type of the storage structure for line marker styles. You + should normally not need to use this. + */ + + +/** + Sets a whole map of line marker styles. You can use this for + assigning many line marker styles at the same time, but + typically it is better to set them individually with \a + setLineMarkerStyle(). + + \param map the map of styles + \sa lineMarkerStyles, setLineMarker, setLineMarkerStyle, setLineMarkerSize + \sa setLineColor, setLineWidth, setLineStyle + */ +void KDChartParams::setLineMarkerStyles( LineMarkerStyleMap map ) { + _lineMarkerStyles = map; + // update _maxDatasetLineMarkerStyle + uint maxDataset = 0; + for( LineMarkerStyleMap::ConstIterator it = _lineMarkerStyles.begin(); + it != _lineMarkerStyles.end(); ++it ) + maxDataset = QMAX( maxDataset, it.key() ); + _maxDatasetLineMarkerStyle = maxDataset; +} + + +/** + \fn KDChartParams::LineMarkerStyleMap KDChartParams::lineMarkerStyles() const + + Returns the whole map of line marker styles. You will typically + not need this. You can query individual line marker styles by + calling \a lineMarkerStyle(). + + \return the map of styles + \sa lineMarkerStyle, setLineMarkerStyles + */ + + +/** + \fn uint KDChartParams::maxDatasetLineMarkerStyle() const + + + Returns the highest dataset for which a line marker style has been + defined. Not all datasets with a lower number necessarily have + a defined line marker. + + \return the highest dataset with a defined line marker + \sa LineMarkerStyle, setLineMarkerStyle, lineMarkerStyle + */ + + +/** + \fn void KDChartParams::setLineMarkerSize( QSize size ) + + Specifies the sizes of line markers. Only used if chartType() == Line + and lineMarker() == true. The default is 6x6. + + Negative values of \c size.width() and/or \c size.height() will + be interpreted as per-mille value of the chart's drawing area, + the true marker width (or height, resp.) will then be calculated + dynamically depending on the actual chart size. + + \param size the size of the line marker in pixels + \sa lineMarkerSize, setLineMarker, setLineMarkerStyle + \sa setLineColor, setLineWidth, setLineStyle + */ + + +/** + \fn QSize KDChartParams::lineMarkerSize() const + + Returns the sizes of line markers. Only used if chartType() == Line and + lineMarker() == true. + + \return the size of the line marker in pixels + \sa setLineMarkerSize + */ + + +/** + \fn void KDChartParams::setLineWidth( int width ) + + Specifies the width for lines in line charts. Default is 1. + Only used if threeDLines() == false. + + If \c width is negative it is interpreted as per-mille + value of the chart's drawing area, the true line width + will then be calculated dynamically depending on the + actual chart size. + + \note Set the line width to zero to surpress drawing of the lines + but do not forget to call setLineMarker( true ) and specify an + appropriate marker style to have the data points drawn. + + \param width the new width + \sa lineWidth, setLineColor, setLineStyle + \sa setLineMarker, setLineMarkerSize, setLineMarkerStyle + */ + + +/** + \fn int KDChartParams::lineWidth() const + + Returns the line width of the lines in line charts. + + \return the line width of lines in line charts + \sa lineWidth + */ + + +/** + \fn void KDChartParams::setLineColor( QColor color = QColor() ) + + Specifies the color of the lines in line charts. By default + line chart lines are drawn in the color specified by the + respective setDataColor function, to reset your chart to + this default just call setLineColor() without specifying a + parameter. + + \note Setting the line color to a special value is usefull to + visualize gaps in a normally very narrow series of data values. + + e.g. You might want to specify setLineMarkerStyle( i, LineMarker4Pixels ) + or even setLineMarkerStyle( i, LineMarker1Pixel ) and have your + marker dots normally form a contiguous line without the need of + any connecting lines except at the places where missing data + values would interrupt the 'line'. Using setLineColor( Qt::darkGray) + could make your chart more readable in such cases. + + \param color of the lines in line charts + \sa lineColor, setLineWidth, setLineStyle + \sa setLineMarker, setLineMarkerSize, setLineMarkerStyle + */ + + +/** + \fn QColor KDChartParams::lineColor() const + + Returns the color of the lines in line charts. + + \return the color of the lines in line charts + \sa setLineColor + */ + + +/** + Specifies a line style to be used for line charts. + + The dataset parameter is optional, by default saying + KDCHART_GLOBAL_LINE_STYLE, you may use it to + set a dataset specific line style for one the lines. + + Global and dataset specific line styles may be used + simultaneously: If no dataset specific style is + defined the global style is used which by default + is Qt::SolidLine. + + Warning: On Windows 95/98, the style setting (other + than NoPen and SolidLine) has no effect for lines with width greater + than 1, due to a bug in the operating system. + + \param style the line style of the line + \param dataset the number of the dataset controlling the respective line + \sa lineStyle, setLineWidth, setLineColor + \sa setLineMarker, setLineMarkerSize, setLineMarkerStyle + */ +void KDChartParams::setLineStyle( Qt::PenStyle style, uint dataset ) +{ + if( KDCHART_GLOBAL_LINE_STYLE == dataset ) + _lineStyle = style; + else + _datasetLineStyles[ dataset ] = style; + emit changed(); +} + +/** + Returns the line style of one of the lines in a line chart + or the global line style if no style was specified for the + dataset or if the optional dataset parameter has its default + value KDCHART_GLOBAL_LINE_STYLE. + + Warning: On Windows 95/98, the style setting (other than NoPen and + SolidLine) has no effect for lines with width greater than 1, due + to a bug in the operating system. + + \param dataset the dataset for which to return the line style + \return the line style for the specified data set + \sa setLineStyle, setLineMarkerStyle + */ +Qt::PenStyle KDChartParams::lineStyle( uint dataset ) const +{ + if( KDCHART_GLOBAL_LINE_STYLE == dataset ) + // global line style + return _lineStyle; + else if( _datasetLineStyles.find( dataset ) == _datasetLineStyles.end() ) + return lineStyle(); + else + return _datasetLineStyles[ dataset ]; +} + + +/** + \fn void KDChartParams::setThreeDLines( bool threeD ) + + Specifies whether lines should be drawn three-dimensionally or + not. The default is to draw two-dimensionally. Only used if + chartType() == Line. + + \param threeD if true, draw three-dimensionally, otherwise draw + two-dimensionally. + \sa threeDLines(), setThreeDLineDepth(), threeDLineDepth(), +// setThreeDLineXRotation(), threeDLineXRotation(), +// setThreeDLineYRotation(), threeDLineYRotation() +*/ + + +/** + \fn bool KDChartParams::threeDLines() const + + Returns whether lines are drawn three-dimensionally or not. The + default is to draw two-dimensionally. Only used if chartType() == + Line. + + \return true if lines are drawn three-dimensionally, false + otherwise. + \sa setThreeDLines(), setThreeDLineDepth(), threeDLineDepth(), +// setThreeDLineXRotation(), threeDLineXRotation(), +// setThreeDLineYRotation(), threeDLineYRotation() +*/ + + +/** + \fn void KDChartParams::setThreeDLineDepth( int depth ) + + Specifies the depth of 3D lines (the "width" in Z + direction). Only used if chartType() == Line and threeDLines() == + true. The default is 20 pixels. + + \param depth the depth in pixels + \sa setThreeDLines(), threeDLines(), threeDLineDepth() + */ + + +/** + \fn int KDChartParams::threeDLineDepth() const + + Returns the depth of 3D lines (the "width" in Z direction). Only + used if chartType() == Line and threeDLines() == true. The + default is 20 pixels. + + \return the depth in pixels + \sa setThreeDLines(), threeDLines(), setThreeDLineDepth() + */ + + +/** + \fn void KDChartParams::setThreeDLineXRotation( int degrees ) + + \deprecated Feature scheduled for future release, at present not implemented. + */ +/* + \fn void KDChartParams::setThreeDLineXRotation( int degrees ) + + Specifies the rotation around the X axis in degrees. The value + may be between 0 and 90. Only used if chartType() == Line and + threeDLines() == true. The default is 30 degrees. If 0 degrees is + specified for both the X and the Y rotation, the lines will look + like 2D lines. + + \param rotation the rotation in degrees. Must be between 0 and + 90. + \sa setThreeDLines(), threeDLines(), threeDLineXRotation() + */ + + + +/** + \fn int KDChartParams::threeDLineXRotation() const + + \deprecated Feature scheduled for future release, at present not implemented. + */ +/* + \fn int KDChartParams::threeDLineXRotation() const + + Returns the rotation around the X axis in degrees. The value may + be between 0 and 90. Only used if chartType() == Line and + threeDLines() == true. The default is 30 degrees. + + \return the rotation in degrees. Is always between 0 and 90. + */ + + +/** + \fn void KDChartParams::setThreeDLineYRotation( int degrees ) + + \deprecated Feature scheduled for future release, at present not implemented. + */ +/* + \fn void KDChartParams::setThreeDLineYRotation( int degrees ) + + Specifies the rotation around the Y axis in degrees. The value + may be between 0 and 90. Only used if chartType() == Line and + threeDLines() == true. The default is 30 degrees. If 0 degrees is + specified for both the X and the Y rotation, the lines will look + like 2D lines. + + \param rotation the rotation in degrees. Must be between 0 and + 90. + \sa setThreeDLines(), threeDLines(), threeDLineYRotation() + */ + +/** + \fn int KDChartParams::threeDLineYRotation() const + + \deprecated Feature scheduled for future release, at present not implemented. + */ +/* + \fn int KDChartParams::threeDLineYRotation() const + + Returns the rotation around the X axis in degrees. The value may + be between 0 and 90. Only used if chartType() == Line and + threeDLines() == true. The default is 30 degrees. + + \return the rotation in degrees. Is always between 0 and 90. + */ + + +/** + \enum KDChartParams::AreaChartSubType + + The area subtype. Only used when chartType == Area + + \sa setAreaChartSubType, areaChartSubType + */ + + +/** + \fn void KDChartParams::setAreaChartSubType( AreaChartSubType areaChartSubType ) + + Specifies the area chart subtype. Only used if chartType() == + Area. The default is AreaNormal. + + \param areaChartSubType the area chart subtype + \sa areaChartSubType, AreaChartSubType, setChartType, chartType + */ + + +/** + \fn KDChartParams::AreaChartSubType KDChartParams::areaChartSubType() const + + + Returns the area chart subtype. Only used if chartType() == + Area. + + \return the area chart sub type + \sa setAreaChartSubType, AreaChartSubType, setChartType, chartType + */ + + +/** + \enum KDChartParams::AreaLocation + + Specifies whether the area above the value points or below the + value points should be filled. The default is to fill below the + value points. + + \sa setAreaLocation(), areaLocation() + */ + + +/** + \fn void KDChartParams::setAreaLocation( AreaLocation location ) + + Specifies whether the area above or below the value points + should be filled. The default is to fill below the value + points. + + This setting is not used with percent areas + (i.e. areaChartSubType() == AreaPercent), because these always + cover the whole chart. + + \param location whether to fill above or below the value points + \sa AreaLocation, areaLocation() + */ + + +/** + \fn KDChartParams::AreaLocation KDChartParams::areaLocation() const + + Returns whether the area above or below the value points is + filled. + + \return whether the area above or below the value points is + filled. + \sa AreaLocation, setAreaLocation() + */ + + +//@} +// END LINECHART + +// START POLARCHART +/** @name Polar chart-specific methods. + + These methods query and set polar chart-specific parameters. + */ +//@{ + + +/** + \enum KDChartParams::PolarChartSubType + + The polar subtype. Only used when chartType == Polar + + \sa setPolarChartSubType, polarChartSubType + */ + + +/** + \fn void KDChartParams::setPolarChartSubType( PolarChartSubType polarChartSubType ) + + Specifies the polar chart subtype. Only used if chartType() == + Polar. The default is PolarNormal. + + \param polarChartSubType the polar chart subtype + \sa polarChartSubType, PolarChartSubType, setChartType, chartType + */ + + +/** + \fn KDChartParams::PolarChartSubType KDChartParams::polarChartSubType() const + + Returns the polar chart subtype. Only used if chartType() == + Polar. + + \return the polar chart sub type + \sa setPolarChartSubType, PolarChartSubType, setChartType, chartType + */ + + +/** + \fn void KDChartParams::setPolarMarker( bool marker ) + + Specifies whether there should be a marker at each data + point. Only used if chartType() == Polar. The default is not to + draw markers. + + \param marker true if markers should be drawn + */ + + +/** + \fn bool KDChartParams::polarMarker() const + + Returns whether polar markers should be drawn at each data + point. Only used if chartType() == Polar. + + \return true if markers should be drawn. + */ + + +/** + \enum KDChartParams::PolarMarkerStyle + + The available polar marker styles. + */ + + +/** + Specifies the polar marker to be used for a dataset. Only used if + chartType() == Polar and polarMarker() == true. If you specify a + marker for a dataset, but not for a dataset with a lower + value, then the marker for the dataset with the lower value + will be undefined unless it was previously defined. The default + is a circle for the first dataset, a square for the second, a + diamond for the third and undefined for all subsequent + datasets. + + \param dataset the dataset for which to set the polar marker + \param style the style to set for the specified dataset + \sa PolarMarkerStyle, polarMarkerStyle + */ +void KDChartParams::setPolarMarkerStyle( uint dataset, PolarMarkerStyle style ) +{ + _polarMarkerStyles[ dataset ] = style; + _maxDatasetPolarMarkerStyle = QMAX( dataset, + _maxDatasetPolarMarkerStyle ); + emit changed(); +} + +/** + Returns the marker to be used for a dataset. Only used if + chartType() == Polar and polarMarker() == true. + + \param dataset the dataset for which to return the polar marker + \return the polar marker for the specified data set + \sa PolarMarkerStyle, setPolarMarkerStyle + */ +KDChartParams::PolarMarkerStyle KDChartParams::polarMarkerStyle( uint dataset ) const +{ + if( _polarMarkerStyles.find( dataset ) != _polarMarkerStyles.end() ) + return _polarMarkerStyles[ dataset ]; + else + return PolarMarkerCircle; // default +} + + +/** + \var KDChartParams::PolarMarkerStyleMap + + The type of the storage structure for polar marker styles. You + should normally not need to use this. + */ + + + +/** + Sets a whole map of polar marker styles. You can use this for + assigning many polar marker styles at the same time, but + typically it is better to set them individually with \a + setPolarMarkerStyle(). + + \param map the map of styles + \sa polarMarkerStyles(), setPolarMarkerStyle() + */ +void KDChartParams::setPolarMarkerStyles( PolarMarkerStyleMap map ) { + _polarMarkerStyles = map; + // update _maxDatasetPolarMarkerStyle + uint maxDataset = 0; + for( PolarMarkerStyleMap::ConstIterator it = _polarMarkerStyles.begin(); + it != _polarMarkerStyles.end(); ++it ) + maxDataset = QMAX( maxDataset, it.key() ); + _maxDatasetPolarMarkerStyle = maxDataset; +} + + +/** + \fn KDChartParams::PolarMarkerStyleMap KDChartParams::polarMarkerStyles() const + + Returns the whole map of polar marker styles. You will usually + not need this. You can query individual polar marker styles by + calling \a polarMarkerStyle(). + + \return the map of styles + \sa polarMarkerStyle(), setPolarMarkerStyles() + */ + + +/** + \fn uint KDChartParams::maxDatasetPolarMarkerStyle() const + + Returns the highest dataset for which a polar marker style has been + defined. Not all datasets with a lower number necessarily have + a defined polar marker. + + \return the highest dataset with a defined polar marker + \sa PolarMarkerStyle, setPolarMarkerStyle, polarMarkerStyle + */ + + +/** + \fn void KDChartParams::setPolarMarkerSize( QSize ) + + Specifies the sizes of polar markers. Only used if chartType() == Polar + and polarMarker() == true. The default is -40 x -40. + + \param size the size of the polar marker in pixels, if negative this is a + per mille value of the chart min. size (the chart width or height, depending + what is smaller), if positive the value is taken as absolute number of pixels. + + \sa polarMarkerSize + */ + + +/** + \fn QSize KDChartParams::polarMarkerSize() const + + Returns the sizes of polar markers. Only used if chartType() == + Polar and polarMarker() == true. + + \return the size of the polar marker in pixels + \sa setPolarMarkerSize + */ + + +/** + \fn void KDChartParams::setPolarLineWidth( int width ) + + Specifies the width for lines in polar charts. Default is -3. + + \param width the new width + \sa polarLineWidth + */ + + +/** + \fn int KDChartParams::polarLineWidth() const + + Returns the line width of the lines in polar charts. + + \return the line width of lines in polar charts + \sa setPolarLineWidth + */ + + +/** + \fn void KDChartParams::setPolarZeroDegreePos( int degrees ) + + Specifies the zero degree position in polar charts. + + Use this function to have the zero degree point on a position + different from the right side of the circle. Valid parameters + are -359..359. + + \sa polarZeroDegreePos + */ + + +/** + \fn int KDChartParams::polarZeroDegreePos() const + + Returns the zero degree position in polar charts. + + \sa setPolarZeroDegreePos + */ + + +/** + \fn void KDChartParams::setPolarRotateCircularLabels( bool rotateCircularLabels ) + + Specifies whether to rotate circular labels in polar charts. + + \sa polarRotateCircularLabels, setPolarDelimsAndLabelsAtPos + */ + + +/** + \fn bool KDChartParams::polarRotateCircularLabels() const + + Returns whether circular labels will be rotated in polar charts. + + \sa setPolarRotateCircularLabels, polarDelimAtPos, polarLabelsAtPos + */ + + +/** + Specifies whether to show circular delimiters and labels at a given + position in polar charts. + + \note Value \c KDChartEnums::PosCenter will be ignored. + + \sa setPolarRotateCircularLabels, polarDelimAtPos, polarLabelsAtPos + */ +void KDChartParams::setPolarDelimsAndLabelsAtPos( KDChartEnums::PositionFlag pos, + bool showDelimiters, + bool showLabels ) +{ + if( KDCHART_MAX_POLAR_DELIMS_AND_LABELS_POS >= pos ) { + _polarDelimsAndLabels[ pos ].showDelimiters = showDelimiters; + _polarDelimsAndLabels[ pos ].showLabels = showLabels; + } +} + +/** + Returns whether to show circular delimiters at a given + position in polar charts. + + \sa polarRotateCircularLabels, setPolarDelimAndLabelsPos, polarLabelsAtPos + */ +bool KDChartParams::polarDelimAtPos( KDChartEnums::PositionFlag pos ) const +{ + if( KDCHART_MAX_POLAR_DELIMS_AND_LABELS_POS >= pos ) + return _polarDelimsAndLabels[ pos ].showDelimiters; + else + return false; +} + +/** + Returns whether to show circular labels at a given + position in polar charts. + + \sa polarRotateCircularLabels, setPolarDelimAndLabelsPos, polarDelimAtPos + */ +bool KDChartParams::polarLabelsAtPos( KDChartEnums::PositionFlag pos ) const +{ + if( KDCHART_MAX_POLAR_DELIMS_AND_LABELS_POS >= pos ) + return _polarDelimsAndLabels[ pos ].showLabels; + else + return false; +} + + + +//@} +// END LINECHART + +// START RING/PIECHART +/** @name Ring and pie chart-specific methods. + + These methods query and set ring and pie chart-specific parameters. + */ +//@{ + +/** + \fn void KDChartParams::setExplode( bool explode ) + + Specifies whether the pie chart or ring chart should be + exploding (all pies or ring segments are slightly displaced + from the center) or not. The default is not to explode. Only + used if chartType() == Pie or chartType() == Ring. + + Note that calling this method by passing true turns on + exploding for all segments. You can turn exploding on and off + for individual segments by calling setExplodeValues() and also + change the explode factors by calling setExplodeFactor() or + setExplodeFactors(). + + Note that in ring charts, only the outermost ring is + exploded. Also note that exploding rings are only useful if + none of the values in the outermost dataset covers more than + 1/4 of the ring, otherwise the exploded ring will look funny. + + \param explode true if the pie or ring should be exploding, + false otherwise + \sa exploding(), setExplodeFactor(), explodeFactor(), + setExplodeFactors(), explodeFactors(), setExplodeValues(), + explodeValues() + */ + + +/** + \fn bool KDChartParams::explode() const + + Returns whether the pie or ring chart should be exploding or not + + \return true if the pie should be exploding + \sa setExplode, setExplodeFactor(), explodeFactor(), + setExplodeFactors(), explodeFactors(), setExplodeValues(), + explodeValues() + */ + + +/** + \fn void KDChartParams::setExplodeValues( QValueList explodeList ) + + Specifies which values to explode. Explosion of values only + happens if setExplode( true ) has been called. Normally, all + values are exploded (all values on the outer ring in the case of a + ring chart). With this function, you have a finer control about + the explosion. You can specify the values that should be exploded + by their position. Passing an empty list here turns on explosion + for all pies or ring segments (but only if explosion is turned on + in general). + + To repeat: Setting anything here has no effect if setExplode( true ) + is not called. You can, however, set any values here even if explosion is + not turned on; they will be saved in case explosion will be turned on in + the future and then be valid automatically. + + The explode factor, i.e., the amount with which a segment is moved + from the center can either be set for all segments with + \a setExplodeFactor() or for individual segments with + \a setExplodeFactors(). The default is 10%. + + \param explodeList the list of positions in the displayed dataset that + should be drawn in an exploded position. Pass an empty list here to + explode all values. + \sa setExplode(), explode(), setExplodeFactor(), explodeFactor(), + explodeValues(), setExplodeFactors(), explodeFactors() + */ + + +/** + \fn QValueList KDChartParams::explodeValues() const + + Returns which values are exploded in a pie or ring chart. For a detailed + explanation of this feature, please see \a setExplodeValues(). + + \return the list of values that are exploded + \sa setExplode(), explode(), setExplodeFactor(), explodeFactor(), + setExplodeValues() + */ + + +/** + \fn void KDChartParams::setExplodeFactors( QMap factors ) + + Specifies the explode factors for each segment in percent, + i.e. how much an exploded pie or ring segment is displaced from + the center. The factor is given as a double value between 0 and 1; + 0.1 means 10%. Only used if chartType() == Pie or chartType() == + Ring and explode() == true. + + Segments that are not contained in the map specified here will + have the default explode factor of 10%, if exploding is turned on + for them at all. This also means that passing an empty list to + this method does not turn off exploding in general; use \a + setExplode( false ) for that. + +Note: This method has no immediate effect if setExplode( true ) +has not been called. It is, however, possible to preset explode +factors and then turn on exploding later. + +Note: Besides giving a segment an explode factor and turning on +exploding in general, you also need to specify to explode a +certain segment by calling \a setExplodeValues(). This gives maximum +flexibility as it allows you to preset explode factors and then +explode or not not explode a segment at leisure - at the expense +of one more method call. + +\param factors the list of explode factors +\sa setExplode(), explode(), setExplodeValues(), explodeValues(), +setExplodeFactor(), explodeFactor(), explodeFactors() +*/ + + +/** + \fn QMap KDChartParams::explodeFactors() const { + + Returns the list of explode factors. Each explode factor in the + list corresponds to the segment at the same position. + + \return the list of explode factors + \sa setExplode(), explode(), setExplodeValues(), explodeValues(), + setExplodeFactor(), explodeFactor(), setExplodeFactors() + */ + + +/** + \fn void KDChartParams::setExplodeFactor( double factor ) + + Specifies the explode factor in percent, i.e. how much an + exploded pie or ring segment is displaced from the center. The + factor is given as a double value between 0 and 1; 0.1 means + 10% and is the default. Only used if + chartType() == Pie or chartType() == Ring and explode() == true. + + Note that this method sets the explode factor for all segments + that are exploded but for which no more specific explode factor + has been set with \a setExplodeFactors(). Thus, to make the value + specified here the default value, you can pass an empty list to + \a setExplodeFactors() (which also is the default). + + \param factor the explode factor + \sa setExplode(), explode(), explodeFactor(), + setExplodeValues(), explodeValues(), setExplodeFactors(), + explodeFactors() + */ + + +/** + \fn double KDChartParams::explodeFactor() const + + Returns the default explode factor, i.e., the explode factor + used for those segments which should be exploded but for which + no more specific explode factor has been set. See \a + setExplodeFactor() for an explanation of the value. + + \return the explode factor + \sa setExplodeFactor(), setExplode(), explode() + */ + + +/** + \fn void KDChartParams::setThreeDPies( bool threeDPies ) + + Specifies whether the engine should draw the pies in 3D. Only + used if chartType() == Pie. + + \param threeDPies true if pies should be drawn with a 3D effect + \sa threeDPies(), setThreeDPieHeight(), threeDPieHeight() + */ + + +/** + \fn bool KDChartParams::threeDPies() const + + Returns whether the engine should draw any pies in 3D. Only + used if chartType() == Pie. + + \return true if pies should be drawn with a 3D effect, false + otherwise + \sa setThreeDPies(), threeDPieHeight(), setThreeDPieHeight() + */ + + +/** + \fn void KDChartParams::setThreeDPieHeight( int pixels ) + + Specifies the height of the 3D effect for pies in pixels. Only used if + chartType() == Pie and threeDPies() == true. Negative values are + interpreted relative to the height of the pie where -100 means + that the 3D effect has the same height as the pie itself; values + smaller than -25 are hardly useful. Positive values are + interpreted as absolute sizes in pixels. The default is an + absolute value of 20 pixels. + + \param height the height of the 3D effect in pixels + \sa threeDHeight(), setThreeDPies(), threeDPies() + */ + + +/** + \fn int KDChartParams::threeDPieHeight() const + + Returns the height of the 3D effect for pies in pixels. See \a + setThreeDPieHeight for the interpretation of the value. + + \return the height of the 3D effect in pixels + \sa setThreeDPieHeight(), setThreeDPies(), threeDPies() + */ + + +/** + \fn void KDChartParams::setPieStart( int degrees ) + + Specifies the starting point of the pie circle. The default is the 3 o' + clock position which equals to 0. Positive values are angles in degrees + counterclockwise, negative values are angles in degrees + clockwise. All values will be normalized to [0;360[. + + \param degrees the starting point in degrees + \sa pieStart() + */ + + +/** + \fn int KDChartParams::pieStart() const + + Returns the starting point of the pie circle. See \a setPieStart() for + the interpretation of these values. The return value is + always in the interval [0;360[ + + \return the starting point of the pie circle in degrees + \sa setPieStart() + */ + + +/** + \fn void KDChartParams::setRingStart( int degrees ) + + Specifies the starting point of the ring circle. The default is the 3 o' + clock position which equals to 0. Positive values are angles in degrees + counterclockwise, negative values are angles in degrees + clockwise. All values will be normalized to [0;360[. + + \param degrees the starting point in degrees + \sa pieStart() + */ + + +/** + \fn int KDChartParams::ringStart() const + + Returns the starting point of the ring circle. See \a + setRingStart() for the interpretation of these values. The + return value is always in the interval [0;360[ + + \return the starting point of the ring circle in degrees + \sa setRingStart() + */ + + +/** + \fn void KDChartParams::setRelativeRingThickness( bool relativeThickness ) + + Specifies whether the ring thickness should be relative to the sum of the + values in the dataset that the ring represents. The default is to have all + the rings with the same thickness which itself depends on the size of the + chart and the number of rings. + + \param relativeThickness if true, ring thickness is relative, if false, it + is constant. + \sa relativeThickness() + */ + + +/** + \fn bool KDChartParams::relativeRingThickness() const + + Returns whether the ring thickness is relative to the sum of values in the + dataset that the ring represents, or whether the ring thickness should be + constant. + + \return true if thickness is relative, false if it is constant + \sa setRelativeRingThickness() + */ + + + +//@} +// END RING/PIECHART + +// START HILO CHART +/** @name Hi-lo chart-specific methods. + + These methods query and set hi-lo chart-specific parameters. + */ +//@{ + +/** + \enum KDChartParams::HiLoChartSubType + + The HiLo subtype. Only used when chartType == HiLo + + \sa setHiLoChartSubType, hiLoChartSubType + */ + +/** + \fn void KDChartParams::setHiLoChartSubType( HiLoChartSubType hiLoChartSubType ) + + Specifies the HiLo chart subtype. Only used if chartType() == + HiLo + + \param hiLoChartSubType the HiLo chart subtype + \sa hiLoChartSubType, HiLoChartSubType, setChartType, chartType + */ + + +/** + \fn KDChartParams::HiLoChartSubType KDChartParams::hiLoChartSubType() const + + Returns the HiLo chart subtype. Only used if chartType() == + HiLo. + + \return the HiLo chart sub type + \sa setHiLoChartSubType, HiLoChartSubType, setChartType, chartType + */ + + +/** + Specifies if and how a HiLo chart will print the Low + values below their respective entries. Only used if chartType() == HiLo + + \note setHiLoChartPrintLowValues( false ) will + deactivate printing of Low values. + + \param active specifies whether the values are to be printed or not. + \param font a Pointer to the font to be used. + \param size (in per mille of the chart width) the dynamic size of + the font to be used. If this parameter is zero the size of the + \c font is used instead - regardless of the size of the chart! + \param color the color to be used when printing the values. + \sa setChartType, chartType + \sa setHiLoChartSubType, hiLoChartSubType + \sa setHiLoChartPrintHighValues + \sa hiLoChartPrintLowValues, hiLoChartPrintLowValues + \sa hiLoChartLowValuesFontColor, hiLoChartLowValuesFontColor + \sa hiLoChartLowValuesFontUseRelSize, hiLoChartLowValuesFontUseRelSize + \sa hiLoChartLowValuesFontRelSize, hiLoChartLowValuesFontRelSize + \sa hiLoChartPrintHighValues, hiLoChartPrintHighValues + \sa hiLoChartHighValuesFontColor, hiLoChartHighValuesFontColor + \sa hiLoChartHighValuesFontUseRelSize, hiLoChartHighValuesFontUseRelSize + \sa hiLoChartHighValuesFontRelSize, hiLoChartHighValuesFontRelSize + */ +void KDChartParams::setHiLoChartPrintLowValues( bool active, QFont* font, + int size, QColor* color ) +{ + _hiLoChartPrintLowValues = active; + if ( font ) + _hiLoChartLowValuesFont = *font; + else + _hiLoChartLowValuesFont = _defaultFont; + _hiLoChartLowValuesUseFontRelSize = ( 0 < size ); + _hiLoChartLowValuesFontRelSize = size; + if ( 0 == color ) + _hiLoChartLowValuesColor = QColor( 0, 0, 0 ); + else + _hiLoChartLowValuesColor = *color; + emit changed(); +} + + +/** + \fn bool KDChartParams::hiLoChartPrintLowValues() const + + Returns whether the low values + will be printed under their respective entries. + + \return whether the low values + will be printed under their respective entries. + + \sa setHiLoChartPrintLowValues, setHiLoChartPrintHighValues + \sa setHiLoChartSubType, hiLoChartSubType + \sa setChartType, chartType + */ + + +/** + \fn QFont KDChartParams::hiLoChartLowValuesFont() const + + Returns the font to be used for printing the + low values + + \returns the font to be used for printing the + low values + + \sa setHiLoChartPrintLowValues, setHiLoChartPrintHighValues + \sa setHiLoChartSubType, hiLoChartSubType + \sa setChartType, chartType + */ + + +/** + \fn bool KDChartParams::hiLoChartLowValuesUseFontRelSize() const + + Returns whether the font size to be used for printing the + low values is calculated dynamically. + + \return whether the font size to be used for printing the + low values is calculated dynamically. + + \sa setHiLoChartPrintLowValues, setHiLoChartPrintHighValues + \sa setHiLoChartSubType, hiLoChartSubType + \sa setChartType, chartType + */ + + +/** + \fn int KDChartParams::hiLoChartLowValuesFontRelSize() const + + Returns the relative size (in per mille of the chart width) + of font size to be used for printing the + low values. + + \return the relative size (in per mille of the chart width) + of font size to be used for printing the + low values. + + \sa setHiLoChartPrintLowValues, setHiLoChartPrintHighValues + \sa setHiLoChartSubType, hiLoChartSubType + \sa setChartType, chartType + */ + + +/** + \fn QColor KDChartParams::hiLoChartLowValuesColor() const + + Returns the colour of the font size to be used for printing the + low values. + + \return the colour of the font size to be used for printing the + low values. + + \sa setHiLoChartPrintLowValues, setHiLoChartPrintHighValues + \sa setHiLoChartSubType, hiLoChartSubType + \sa setChartType, chartType + */ + + +/** + Specifies if and how a HiLo chart will print the High + values below their respective entries. + Only used if chartType() == HiLo + + \note setHiLoChartPrintHighValues( false ) will + deactivate printing of High values. + + \param active specifies whether the values are to be printed or not. + \param font specifies a Pointer to the font to be used. + \param size (in per mille of the chart width) specifies the + dynamic size of the font to be used. If this parameter is zero + the size of the + \c font is used instead - regardless of the size of the chart! + \param specifies the color the color to be used when printing + the values. + \sa setHiLoChartPrintLowValues + \sa setHiLoChartSubType, hiLoChartSubType + \sa setChartType, chartType + \sa hiLoChartPrintHighValues, hiLoChartPrintHighValues + \sa hiLoChartHighValuesFontColor, hiLoChartHighValuesFontColor + \sa hiLoChartHighValuesFontUseRelSize, hiLoChartHighValuesFontUseRelSize + \sa hiLoChartHighValuesFontRelSize, hiLoChartHighValuesFontRelSize + \sa hiLoChartPrintLowValues, hiLoChartPrintLowValues + \sa hiLoChartLowValuesFontColor, hiLoChartLowValuesFontColor + \sa hiLoChartLowValuesFontUseRelSize, hiLoChartLowValuesFontUseRelSize + \sa hiLoChartLowValuesFontRelSize, hiLoChartLowValuesFontRelSize + */ +void KDChartParams::setHiLoChartPrintHighValues( bool active, QFont* font, + int size, QColor* color ) +{ + _hiLoChartPrintHighValues = active; + if ( font ) + _hiLoChartHighValuesFont = *font; + else + _hiLoChartHighValuesFont = _defaultFont; + _hiLoChartHighValuesUseFontRelSize = ( 0 < size ); + _hiLoChartHighValuesFontRelSize = size; + if ( 0 == color ) + _hiLoChartHighValuesColor = QColor( 0, 0, 0 ); + else + _hiLoChartHighValuesColor = *color; + emit changed(); +} + + +/** + \fn bool KDChartParams::hiLoChartPrintHighValues() const + + Returns whether the high values + will be printed under their respective entries. + + \return whether the high values + will be printed under their respective entries. + + \sa setHiLoChartPrintHighValues, setHiLoChartPrintLowValues + \sa setHiLoChartSubType, hiLoChartSubType + \sa setChartType, chartType + */ + + +/** + \fn QFont KDChartParams::hiLoChartHighValuesFont() const + + Returns the font to be used for printing the + high values. + + \returns the font to be used for printing the + high values. + + \sa setHiLoChartPrintHighValues, setHiLoChartPrintLowValues + \sa setHiLoChartSubType, hiLoChartSubType + \sa setChartType, chartType + */ + + +/** + \fn bool KDChartParams::hiLoChartHighValuesUseFontRelSize() const + + Returns whether the font size to be used for printing the + high values is calculated dynamically. + + \return whether the font size to be used for printing the + high values is calculated dynamically. + + \sa setHiLoChartPrintHighValues, setHiLoChartPrintLowValues + \sa setHiLoChartSubType, hiLoChartSubType + \sa setChartType, chartType + */ + + +/** + \fn int KDChartParams::hiLoChartHighValuesFontRelSize() const + + Returns the relative size (in per mille of the chart width) + of font size to be used for printing the + high values. + + \return the relative size (in per mille of the chart width) + of font size to be used for printing the + high values. + + \sa setHiLoChartPrintHighValues, setHiLoChartPrintHighValues + \sa setHiLoChartSubType, hiLoChartSubType + \sa setChartType, chartType + */ + + +/** + \fn QColor KDChartParams::hiLoChartHighValuesColor() const + + Returns the colour of the font size to be used for printing the + high values. + + \return the colour of the font size to be used for printing the + high values. + + \sa setHiLoChartPrintHighValues, setHiLoChartPrintLowValues + \sa setHiLoChartSubType, hiLoChartSubType + \sa setChartType, chartType + */ + + +/** + Specifies if and how a HiLo chart will print the Open values + below their respective entries. + Only used if chartType() == HiLo and if the HiLo chart sub type + shows open values. + + \note setHiLoChartPrintOpenValues( false ) will + deactivate printing of Open values. + + \param active specifies whether the values are to be printed or not. + \param font a Pointer to the font to be used. + \param size (in per mille of the chart width) the dynamic size of + the font to be used. If this parameter is zero the size of the + \c font is used instead - regardless of the size of the chart! + \param color the color to be used when printing the values. + \sa setHiLoChartPrintCloseValues + \sa setHiLoChartSubType, hiLoChartSubType + \sa setChartType, chartType + \sa hiLoChartPrintOpenValues, hiLoChartPrintOpenValues + \sa hiLoChartOpenValuesFontColor, hiLoChartOpenValuesFontColor + \sa hiLoChartOpenValuesFontUseRelSize, hiLoChartOpenValuesFontUseRelSize + \sa hiLoChartOpenValuesFontRelSize, hiLoChartOpenValuesFontRelSize + \sa hiLoChartPrintCloseValues, hiLoChartPrintCloseValues + \sa hiLoChartCloseValuesFontColor, hiLoChartCloseValuesFontColor + \sa hiLoChartCloseValuesFontUseRelSize, hiLoChartCloseValuesFontUseRelSize + \sa hiLoChartCloseValuesFontRelSize, hiLoChartCloseValuesFontRelSize + */ +void KDChartParams::setHiLoChartPrintOpenValues( bool active, QFont* font, + uint size, QColor* color ) +{ + _hiLoChartPrintOpenValues = active; + if ( font ) + _hiLoChartOpenValuesFont = *font; + else + _hiLoChartOpenValuesFont = _defaultFont; + _hiLoChartOpenValuesUseFontRelSize = ( 0 < size ); + _hiLoChartOpenValuesFontRelSize = size; + if ( 0 == color ) + _hiLoChartOpenValuesColor = QColor( 0, 0, 0 ); + else + _hiLoChartOpenValuesColor = *color; + emit changed(); +} + + +/** + \fn bool KDChartParams::hiLoChartPrintOpenValues() const + + Returns whether the open values will be printed under their + respective entries. + + \return whether the open values will be printed under their + respective entries. + + \sa setHiLoChartPrintOpenValues, setHiLoChartPrintCloseValues + \sa setHiLoChartSubType, hiLoChartSubType + \sa setChartType, chartType + */ + + +/** + \fn QFont KDChartParams::hiLoChartOpenValuesFont() const + + Returns the font to be used for printing the + open values. + + \returns the font to be used for printing the + open values. + + \sa setHiLoChartPrintOpenValues, setHiLoChartPrintCloseValues + \sa setHiLoChartSubType, hiLoChartSubType + \sa setChartType, chartType + */ + + +/** + \fn bool KDChartParams::hiLoChartOpenValuesUseFontRelSize() const + + Returns whether the font size to be used for printing the + open values is calculated dynamically. + + \return whether the font size to be used for printing the + open values is calculated dynamically. + + \sa setHiLoChartPrintOpenValues, setHiLoChartPrintCloseValues + \sa setHiLoChartSubType, hiLoChartSubType + \sa setChartType, chartType + */ + + +/** + \fn int KDChartParams::hiLoChartOpenValuesFontRelSize() const + + Returns the relative size (in per mille of the chart width) + of font size to be used for printing the open values. + + \return the relative size (in per mille of the chart width) of + font size to be used for printing the open values. + + \sa setHiLoChartPrintOpenValues, setHiLoChartPrintCloseValues + \sa setHiLoChartSubType, hiLoChartSubType + \sa setChartType, chartType + */ + + +/** + \fn QColor KDChartParams::hiLoChartOpenValuesColor() const + + Returns the colour of the font size to be used for printing the + open values. + + \return the colour of the font size to be used for printing the + open values. + + \sa setHiLoChartPrintOpenValues, setHiLoChartPrintCloseValues + \sa setHiLoChartSubType, hiLoChartSubType + \sa setChartType, chartType + */ + + +/** + Specifies if and how a HiLo chart will print the Close + values next to their respective entries. + Only used if chartType() == HiLo and the HiLo chart sub type + contains Close values. + + \note setHiLoChartPrintCloseValues( false ) will + deactivate printing of Close values. + + \param active specifies whether the values are to be printed or not. + \param font specifies a Pointer to the font to be used. + \param size (in per mille of the chart width) specifies the dynamic size of + the font to be used. If this parameter is zero the size of the + \c font is used instead - regardless of the size of the chart! + \param specifies the color the color to be used when printing the values. + \sa setHiLoChartPrintOpenValues + \sa setHiLoChartSubType, hiLoChartSubType + \sa setChartType, chartType + \sa hiLoChartPrintCloseValues, hiLoChartPrintCloseValues + \sa hiLoChartCloseValuesFontColor, hiLoChartCloseValuesFontColor + \sa hiLoChartCloseValuesFontUseRelSize, hiLoChartCloseValuesFontUseRelSize + \sa hiLoChartCloseValuesFontRelSize, hiLoChartCloseValuesFontRelSize + \sa hiLoChartPrintOpenValues, hiLoChartPrintOpenValues + \sa hiLoChartOpenValuesFontColor, hiLoChartOpenValuesFontColor + \sa hiLoChartOpenValuesFontUseRelSize, hiLoChartOpenValuesFontUseRelSize + \sa hiLoChartOpenValuesFontRelSize, hiLoChartOpenValuesFontRelSize + */ +void KDChartParams::setHiLoChartPrintCloseValues( bool active, QFont* font, + int size, QColor* color ) +{ + _hiLoChartPrintCloseValues = active; + if ( font ) + _hiLoChartCloseValuesFont = *font; + else + _hiLoChartCloseValuesFont = _defaultFont; + _hiLoChartCloseValuesUseFontRelSize = ( 0 < size ); + _hiLoChartCloseValuesFontRelSize = size; + if ( 0 == color ) + _hiLoChartCloseValuesColor = QColor( 0, 0, 0 ); + else + _hiLoChartCloseValuesColor = *color; + emit changed(); +} + +/** + \fn bool KDChartParams::hiLoChartPrintCloseValues() const + + Returns whether the close values will be printed under their + respective entries. + + \return whether the close values will be printed under their + respective entries. + + \sa setHiLoChartPrintCloseValues, setHiLoChartPrintOpenValues + \sa setHiLoChartSubType, hiLoChartSubType + \sa setChartType, chartType + */ + + +/** + \fn QFont KDChartParams::hiLoChartCloseValuesFont() const + + Returns the font to be used for printing the close values. + + \returns the font to be used for printing the close values. + + \sa setHiLoChartPrintCloseValues, setHiLoChartPrintOpenValues + \sa setHiLoChartSubType, hiLoChartSubType + \sa setChartType, chartType + */ + + +/** + \fn bool KDChartParams::hiLoChartCloseValuesUseFontRelSize() const + + Returns whether the font size to be used for printing the close + values is calculated dynamically. + + \return whether the font size to be used for printing the close + values is calculated dynamically. + + \sa setHiLoChartPrintCloseValues, setHiLoChartPrintOpenValues + \sa setHiLoChartSubType, hiLoChartSubType + \sa setChartType, chartType + */ + + +/** + \fn int KDChartParams::hiLoChartCloseValuesFontRelSize() const + Returns the relative size (in per mille of the chart width) of + font size to be used for printing the close values. + + \return the relative size (in per mille of the chart width) of + font size to be used for printing the close values. + + \sa setHiLoChartPrintCloseValues, setHiLoChartPrintOpenValues + \sa setHiLoChartSubType, hiLoChartSubType + \sa setChartType, chartType + */ + + +/** + \fn QColor KDChartParams::hiLoChartCloseValuesColor() const + + Returns the colour of the font size to be used for printing the + close values. + + \return the colour of the font size to be used for printing the + close values. + + \sa setHiLoChartPrintCloseValues, setHiLoChartPrintOpenValues + \sa setHiLoChartSubType, hiLoChartSubType + \sa setChartType, chartType + */ + + +/** + \fn void KDChartParams::setHiLoChartPrintFirstValues( bool, QFont*, uint, QColor* ) + + \obsolete + + This method is obsolete; use \a setHiLoChartPrintOpenValues(). + */ + + +/** + \fn bool KDChartParams::hiLoChartPrintFirstValues() const + + \obsolete + + This method is obsolete; use \a hiLoChartPrintOpenValues() + instead. + */ + + +/** + \fn QFont KDChartParams::hiLoChartFirstValuesFont() const + + \obsolete + + This method is obsolete; use \a hiLoChartOpenValuesFont() + instead. + */ + + +/** + \fn bool KDChartParams::hiLoChartFirstValuesUseFontRelSize() const + + \obsolete + + This method is obsolete; use \a + hiLoChartOpenValuesUseFontRelSize() instead. + */ + + +/** + \fn int KDChartParams::hiLoChartFirstValuesFontRelSize() const + + \obsolete + + This method is obsolete; use \a + hiLoChartOpenValuesFontRelSize() instead. + */ + + +/** + \fn QColor KDChartParams::hiLoChartFirstValuesColor() const + + \obsolete + + This method is obsolete; use \a hiLoChartOpenValuesColor() + instead. + */ + + +/** + \fn void KDChartParams::setHiLoChartPrintLastValues( bool, QFont*, int, QColor* ) + + \obsolete + + This method is obsolete; use \a setHiLoChartPrintCloseValues() + instead. + */ + + +/** + \fn bool KDChartParams::hiLoChartPrintLastValues() const + + \obsolete + + This method is obsolete; use \a hiLoChartPrintCloseValues() + instead. + */ + + +/** + \fn QFont KDChartParams::hiLoChartLastValuesFont() const + + \obsolete + + This method is obsolete; use \a hiLoChartCloseValuesFont() + instead. + */ + + +/** + \fn bool KDChartParams::hiLoChartLastValuesUseFontRelSize() const + + \obsolete + + This method is obsolete; use \a hiLoChartCloseValuesUseFontRelSize() + instead. + */ + + +/** + \fn int KDChartParams::hiLoChartLastValuesFontRelSize() const + + \obsolete + + This method is obsolete; use \a hiLoChartCloseValuesFontRelSize() + instead. + */ + + +/** + \fn QColor KDChartParams::hiLoChartLastValuesColor() const + + \obsolete + + This method is obsolete; use \a hiLoChartCloseValuesColor() + instead. + */ + + + +//@} +// END HILO CHART + +// START BOX/WHISKER CHART +/** @name Box-and-whisker chart-specific methods. + + These methods query and set box-and-whisker chart-specific parameters. + */ +//@{ + +/** + \enum KDChartParams::BWChartSubType + + The BoxWhisker subtype. Only used when chartType == BoxWhisker + + \sa setBWChartSubType, bWChartSubType + */ + + +/** + \enum KDChartParams::BWStatVal + + The different statistical values that can be printed into or + asked from a Box and Whisker chart. Only used when chartType == BoxWhisker + + \sa setBWChartSubType, bWChartSubType + */ // use the following syntax to avoid warnings: + + +/** + \fn void KDChartParams::setBWChartSubType( BWChartSubType bWChartSubType ) + + Specifies the BoxWhisker chart subtype. Only used if chartType() == + BoxWhisker + + \param bWChartSubType the BoxWhisker chart subtype + \sa bWChartSubType, BWChartSubType, setChartType, chartType + */ + + +/** + \fn KDChartParams::BWChartSubType KDChartParams::bWChartSubType() const + + Returns the BoxWhisker chart subtype. Only used if chartType() == + BoxWhisker. + + \return the BoxWhisker chart sub type + \sa setBWChartSubType, BWChartSubType, setChartType, chartType + */ + + + +/** + Specifies the factors to be used to calculate the position of + the inner (or outer, resp.) fences. + + Default values for both inner fences are 1.5 times the + interquartile range from the corresponding quartile, + for both outer fences default is 3.0 times the IQR. + + \sa bWChartFences + \sa setBWChartOutValMarkerSize, setBWChartPrintStatistics + \sa setBWChartSubType, bWChartSubType + \sa setChartType, chartType + */ +void KDChartParams::setBWChartFences( double upperInner, double lowerInner, + double upperOuter, double lowerOuter ) +{ + _BWChartFenceUpperInner = upperInner; + _BWChartFenceLowerInner = lowerInner; + _BWChartFenceUpperOuter = upperOuter; + _BWChartFenceLowerOuter = lowerOuter; +} +/** + Retrievs the factors to be used to calculate the position of + the inner (or outer, resp.) fences. + + \sa setBWChartFences + \sa setBWChartOutValMarkerSize, setBWChartPrintStatistics + \sa setBWChartSubType, bWChartSubType + \sa setChartType, chartType + */ +void KDChartParams::bWChartFences( double& upperInner, double& lowerInner, + double& upperOuter, double& lowerOuter ) const +{ + upperInner = _BWChartFenceUpperInner; + lowerInner = _BWChartFenceLowerInner; + upperOuter = _BWChartFenceUpperOuter; + lowerOuter = _BWChartFenceLowerOuter; +} + + +/** + \fn void KDChartParams::setBWChartBrush( const QBrush& bWChartBrush ) + + Specifies the brush to be used to fill the BoxWhisker charts. + + \param bWChartBrush the brush to be used + \sa bWChartBrush, setChartType, chartType + */ + + +/** + \fn QBrush KDChartParams::bWChartBrush() const + + Returns the brush to be used to fill the BoxWhisker charts. + + \return the brush to be used + \sa setBWChartBrush, setChartType, chartType + */ + + +/** + \fn void KDChartParams::setBWChartOutValMarkerSize( int size ) + + Specifies how big outlier markers (representing the values outside + the inner fences) will be drawn. + + When specifying a value different from 0 the chart will show the outlier + markers in the respective size, use zero to disable showing the outliers, + use negative values to have the marker size calculated dynamically + (in percent of the current boxes' width). Thus marker sizes will be + recalculated after modification of either the number of boxes + or the size of the entire chart. + + \note Shapes of the outlier markers depend on their distance to the + respective fence: circles are used to represent near outside values + while asteriscs indicate far outside values (the ones outside the + outer fence), you may use setBWChartFences() to specify the factor + to be used to calculate the value of the inner and outer fence. + + \sa bWChartOutValMarkerSize + \sa setBWChartFences, setBWChartPrintStatistics + \sa setBWChartSubType, bWChartSubType + \sa setChartType, chartType + */ + + +/** + \fn int KDChartParams::bWChartOutValMarkerSize() const + + Returns how big outlier markers (representing the values outside + the inner fences) will be drawn. + + \return how big outside value markers will be drawn, zero means + they will be invisible, negative values indicate that the size + is calculated dynamically based upon the current boxes' width. + + \sa setBWChartOutValMarkerSize + \sa setBWChartFences, setBWChartPrintStatistics + \sa setBWChartSubType, bWChartSubType + \sa setChartType, chartType + */ + + +/** + Specifies if and how a BoxWhisker chart will print the + respective statistical values near to the drawing. + Only used if chartType() == BoxWhisker + + \note setBWChartPrintStatistics( BWStatVal, false ) will + deactivate printing of the respective statistical values. + + \param statValue specifies the statistical value to be set, use + BWStatValALL to define equal settings for all + of the statistical values. + \param active specifies whether the values are to be printed or not. + \param font a Pointer to the font to be used. + \param size (relative to the boxes' width) the dynamic size of + the font to be used. If this parameter is zero the size of the + \c font is used instead - regardless of the size of the chart + and regardless of the number of boxes! + \param color the color to be used when printing the values. + \param brush the brush to be used to fill the text's area before printing + \sa setChartType + \sa setBWChartSubType + \sa bWChartPrintStatistics + \sa bWChartStatisticsColor, + \sa bWChartStatisticsBrush, + \sa bWChartStatisticsFontUseRelSize + \sa bWChartStatisticsFontRelSize + */ +void KDChartParams::setBWChartPrintStatistics( BWStatVal statValue, + bool active, + QFont* font, + int size, + QColor* color, + QBrush* brush ) +{ + BWStatVal statValA = (BWStatValALL == statValue) ? BWStatValSTART : statValue; + BWStatVal statValZ = (BWStatValALL == statValue) ? BWStatValEND : statValue; + for( int i = statValA; i <= statValZ; ++i ){ + _BWChartStatistics[ i ].active = active; + if ( font ) + _BWChartStatistics[ i ].font = *font; + else + _BWChartStatistics[ i ].font = _defaultFont; + _BWChartStatistics[ i ].useRelSize = ( 0 < size ); + _BWChartStatistics[ i ].relSize = size; + if ( 0 == color ) + _BWChartStatistics[ i ].color = QColor( 0, 0, 0 ); + else + _BWChartStatistics[ i ].color = *color; + if ( 0 == brush ) + _BWChartStatistics[ i ].brush = QBrush( Qt::white ); + else + _BWChartStatistics[ i ].brush = *brush; + } + emit changed(); +} + + +/** + \fn bool KDChartParams::bWChartPrintStatistics( BWStatVal statValue ) const + + Returns whether the respective statistical values + will be printed near to the drawing. + + \return whether the respective statistical values + will be printed near to the drawing. + + \sa setBWChartPrintStatistics + \sa setBWChartSubType, bWChartSubType + \sa setChartType, chartType + */ + + +/** + \fn QFont KDChartParams::bWChartStatisticsFont( BWStatVal statValue ) const + + Returns the font to be used for printing the respective statistical values + + \returns the font to be used for printing the respective statistical values + + \sa setBWChartPrintStatistics + \sa setBWChartSubType, bWChartSubType + \sa setChartType, chartType + */ + + +/** + \fn bool KDChartParams::bWChartStatisticsUseRelSize( BWStatVal statValue ) const + + Returns whether the font size to be used for printing the respective statistical values + is calculated dynamically. + + \returns whether the font size to be used for printing the respective statistical values + is calculated dynamically. + + \sa setBWChartPrintStatistics + \sa setBWChartSubType, bWChartSubType + \sa setChartType, chartType + */ + + +/** + \fn int KDChartParams::bWChartStatisticsFontRelSize( BWStatVal statValue ) const + + Returns the relative size (in per mille of the chart width) + of the font to be used for printing the respective statistical values. + + \returns the relative size (in per mille of the chart width) + of the font to be used for printing the respective statistical values. + + \sa setBWChartPrintStatistics + \sa setBWChartSubType, bWChartSubType + \sa setChartType, chartType + */ + + +/** + \fn QColor KDChartParams::bWChartStatisticsColor( BWStatVal statValue ) const + + Returns the colour + of the font to be used for printing the respective statistical values. + + \returns the colour + of the font to be used for printing the respective statistical values. + + \sa setBWChartPrintStatistics + \sa setBWChartSubType, bWChartSubType + \sa setChartType, chartType + */ + + +/** + \fn QBrush KDChartParams::bWChartStatisticsBrush( BWStatVal statValue ) const + + Returns the brush used + to fill the text's area before printing the respective statistical values. + + \returns the brush used + to fill the text's area before printing the respective statistical values. + + \sa setBWChartPrintStatistics + \sa setBWChartSubType, bWChartSubType + \sa setChartType, chartType + */ + + +//@} +// END BOX/WHISKER CHART + +// START LEGENDS +/** @name Legend methods. + + These methods query and set legend parameters. + */ +//@{ + +/** + \enum KDChartParams::LegendPosition + + The possible positions for a legend. NoLegend turns legend display + off. + + \sa setLegendPosition, legendPosition + */ + + +/** + \fn void KDChartParams::setLegendPosition( LegendPosition position ) + + Specifies where the legend should be shown. NoLegend turns legend + display off. The default is LegendRight which positions the legend + right to the data display. + + \param the position for the legend + \sa LegendPosition, legendPosition, setLegendOrientation, setLegendShowLines + */ + + +/** + \fn KDChartParams::LegendPosition KDChartParams::legendPosition() const + + Returns where the legend will be shown. + + \return where the legend will be shown + \sa LegendPosition, setLegendPosition, setLegendShowLines + */ + + +/** + \fn void KDChartParams::setLegendOrientation( Qt::Orientation orientation ) + + Specifies how the legend should be printed. Qt::Vertical (the default) + prints the legend entries below each other, Qt::Horizontal prints them + aside each other. + + \note Horizontal orientation is only possible if the chart is NOT making + room in horizontal direction, this means you may specify horizontal + orientation if the legend position in one of the following values + only: LegendTop, LegendBottom, LegendTopLeftTop, LegendTopRightTop, + LegendBottomLeftBottom, LegendBottomRightBottom + + \param the orientation for the legend + \sa legendOrientation, setLegendPosition, setLegendShowLines + */ + + +/** + \fn Qt::Orientation KDChartParams::legendOrientation() const + + Returns how the legend will be printed. + + \return how the legend will be printed. + \sa setLegendOrientation, setLegendPosition, setLegendShowLines + */ + +/** + \fn void KDChartParams::setLegendShowLines( bool legendShowLines ) + + Specifies whether the legend shall show lines or just + show the markers (or squares, resp.). + + \note By default no lines are drawn but just the markers are shown, + for Line charts you might want to set this flag to true. + + \param flag whether lines are drawn or only the markers + \sa legendShowLines, setLegendOrientation, setLegendPosition + */ + + +/** + \fn bool KDChartParams::legendShowLines() const + + Returns whether the legend shows lines or just + the markers (or squares, resp.). + + \return whether the legend shows lines or just the markers (or squares, resp.). + \sa setLegendShowLines, setLegendOrientation, setLegendPosition + */ + + + +/** + \enum KDChartParams::LegendSource + + The possible ways for getting the legend text. Available are: +

    +
  • Manual - Uses texts set with setLegendText(); if no text is set for + a dataset, the legend text will be empty. +
  • FirstColumn - Uses values from the first column, no matter what + this contains. +
  • Automatic - Tries first to use values from the first column; if + this does not contain any string values, tries to use values set + manually with setLegendText(). If there are no values set manually + either, resolves to standard texts like Series 1, Series 2, .... This + is the default. +
+ \sa setLegendSource, legendSource, setLegendText, legendText + */ + + +/** + \fn void KDChartParams::setLegendSource( LegendSource source ) + + Specifies where the legend text is coming from. See LegendSource for an + explanation of the possible values. + + \param source the source of the legend texts + \sa legendSource, LegendSource, setLegendText, legendText + */ + + +/** + \fn LegendSource KDChartParams::legendSource() const + + Returns where the legend text is coming from. See LegendSource for an + explanation of the possible return values. + + \return where the legend text is coming from + \sa LegendSource, setLegendSource, setLegendText, legendText + */ + + + +/** + \fn void KDChartParams::setLegendText( uint dataset, const QString& text ) + + Manually specifies a legend text for a certain dataset. This is only + used if legendSource() == Manual or if legendSource() == Automatic and + it is not possible to retrieve values from the first column. + + \param dataset the dataset for which to set the legend text + \param the legend text to be set for a given dataset + \sa LegendSource, setLegendSource, legendSource, legendText + */ + + +/** + \fn QString KDChartParams::legendText( uint dataset ) const + + Returns the manually specified legend text for a given dataset. + + \return the manually specified legend text for the specified dataset + \sa setLegendText, LegendSource, setLegendSource, legendSource + */ + + +/** + \fn void KDChartParams::setLegendTextColor( const QColor& color ) + + Specifies the color to be used for the legend texts. The + default is black. + + \param color the color to be used for the legend texts + \sa legendTextColor(), setLegendTitleTextColor() + */ + + +/** + \fn QColor KDChartParams::legendTextColor() const + + Returns the color in which the legend texts are drawn. The + default is black. + + \return the color in which the legend texts are drawn + \sa setLegendTextColor(), legendTitleTextColor() + */ + + +/** + \fn void KDChartParams::setLegendFont( const QFont& font, bool useFontSize ) + + Specifies the font in which the legend texts are drawn. The default is a + 10pt helvetica font. + + \note The font size will be ignored if \c useFontSize is false, + in this case the font size will be calculated dynamically using + the value stored by you calling setLegendFontRelSize(). + + \param font the font to draw the legend texts in + \sa setLegendFontUseRelSize, legendFont + */ + + +/** + \fn QFont KDChartParams::legendFont() const + + Returns the font in which the legend texts are drawn. + + \return the font in which the legend texts are drawn + \sa setLegendFont, setLegendFontUseRelSize + */ + + +/** + \fn void KDChartParams::setLegendFontUseRelSize( bool legendFontUseRelSize ) + + Specifies whether the legend shall be drawn + using relative font size. + + \param legendFontUseRelSize whether legend shall be drawn + using relative font size. + If true the absolute value of the value set by \c + setLegendFontRelSize is per thousand + of of the average value of the printable area height and width. + This will make the legend look nice even if scaled to very + different size. + + \sa setLegendFontRelSize, setAxisLabelsFont + */ + + +/** + \fn bool KDChartParams::legendFontUseRelSize() const + + Returns whether the legend font size is used. + + \return whether the fix legend font size is used. + \sa setLegendFontRelSize, setLegendFont + */ + + +/** + \fn void KDChartParams::setLegendFontRelSize( int legendFontRelSize ) + + Specifies the legend relative font size. + + \param legendFontRelSize the relative legend size. + If this value unequals zero the absolute value is per thousand + of of the average value of the printable area height and width. + This will make the legend look nice even if scaled to very + different size. + + \sa setLegendFontUseRelSize, setLegendFont + */ + + +/** + \fn int KDChartParams::legendFontRelSize() const + + Returns the relative legend font size. + + \return the relative legend font size. + \sa setLegendFontRelSize, setLegendFontUseRelSize + */ + + +/** + \fn void KDChartParams::setLegendTitleText( const QString& text ) + + Specifies a text to be shown as the title of the legend. The + default is "Legend" (possibly localized). To turn off the + legend title completely, pass an empty string. + + \param text the text to use as the legend title + \sa legendTitleText(), setLegendTitleFont(), + setLegendTitleFontUseRelSize() + */ + + + + +/** + \fn QString KDChartParams::legendTitleText() const + + Returns the text that is shown as the title of the legend. + + \return the text that is used as the legend title + \sa setLegendTitleText(), legendTitleFont(), + legendTitleFontUseRelSize() + */ + + +/** + \fn void KDChartParams::setLegendTitleTextColor( const QColor& color ) + + Specifies the color to be used for the legend title. The + default is black. Note that this color is only the default when + rich text is used; tags in the rich text might change the color. + + \param color the color to be used for the legend title + \sa legendTitleTextColor(), setLegendTextColor() + */ + + +/** + \fn QColor KDChartParams::legendTitleTextColor() const + + Returns the color in which the legend title is drawn. The + default is black. + + \return the color in which the legend title is drawn + \sa setLegendTitleTextColor(), legendTextColor() + */ + + +/** + \fn void KDChartParams::setLegendTitleFont( const QFont& font, bool useFontSize ) + + Specifies the font in which the legend title (if any) is drawn. The + default is a 12pt helvetica font. + + \note The font size will be ignored if \c useFontSize is false, + in this case the font size will be calculated dynamically using + the value stored by you calling setLegendFontRelSize(). + + \param font the font to draw the legend texts in + \sa setLegendTitleFontUseRelSize, legendTitleFont + */ + + +/** + \fn QFont KDChartParams::legendTitleFont() const + + Returns the font in which the legend title (if any) is drawn. + + \return the font in which the legend texts are drawn + \sa setLegendTitleFont, setLegendTitleFontUseRelSize + */ + + +/** + \fn void KDChartParams::setLegendTitleFontUseRelSize( bool legendTitleFontUseRelSize ) + + + Specifies whether the legend title (if any) shall be drawn using + relative font size. + + \param legendTitleFontUseRelSize whether the legend title shall + be drawn using relative font size. + If true the absolute value of the value set by \c + setLegendTitleFontRelSize is per thousandth of the average + value of the printable area height and width. + This will make the legend title look nice even if scaled to a very + different size. + + \sa setLegendTitleFontRelSize, setAxisLabelsFont + */ + + +/** + \fn bool KDChartParams::legendTitleFontUseRelSize() const + + Returns whether the legend title font size is used. + + \return whether the fixed legend title font size is used. + \sa setLegendTitleFontRelSize, setLegendTitleFont + */ + + +/** + \fn void KDChartParams::setLegendTitleFontRelSize( int legendTitleFontRelSize ) + + + Specifies the legend title relative font size. + + \param legendTitleFontRelSize the relative legend size. + If this value unequals zero the absolute value is per thousand + of of the average value of the printable area height and width. + This will make the legend title look nice even if scaled to a very + different size. + + \sa setLegendTitleFontUseRelSize, setLegendTitleFont + */ + + +/** + \fn int KDChartParams::legendTitleFontRelSize() const + + Returns the relative legend title font size. + + \return the relative legend title font size. + \sa setLegendTitleFontRelSize, setLegendTitleFontUseRelSize + */ + + +/** + \fn void KDChartParams::setLegendSpacing( uint space ) + + Specifies how much space in pixels there should be between the legend + and the data display. The default is 20 pixels. + + \param space the space in pixels between the legend and the data + display + \sa legendSpacing + */ + + +/** + \fn uint KDChartParams::legendSpacing() const + + Returns how much space in pixels there is between the legend and the + data display. + + \return the space in pixels between the legend and the data display + \sa setLegendSpacing + */ + +//@} +// END LEGENDS + +// START AXES +/** @name Axis methods. + + These methods query and set axis parameters. + */ +//@{ + +/** + \fn void KDChartParams::setAxisType( uint n, const KDChartAxisParams::AxisType axisType ) + + Specifies the axis type. + + \param n the number of the axis settings to be modified + \param axisType the type of the axis. + \sa axisVisible + */ + + +/** + \fn void KDChartParams::setAxisVisible( uint n, const bool axisVisible ) + + Specifies if the axis will be drawn. The default is false. + + \param n the number of the axis settings to be modified + \param axisVisible set true to make visible the respective axis. + \sa axisVisible + */ + + +/** + \fn bool KDChartParams::axisVisible( uint n ) const + + Returns if the axis will be drawn. + + \return if the axis is visible or not. + \sa setAxisVisible + */ + + +/** + Specifies whether a grid should be drawn at the chart data area. + + The grid will show a solid line for each delimiter. + (or a line with a pattern defined by \c KDChartAxisParams::setAxisGridStyle(), resp.) + + \note If true and axisShowSubDelimiters is also true the grid + will show a thin dotted line for each sub-delimiter. + (or a line with a pattern defined by \c KDChartAxisParams::setAxisGridSubStyle(), resp.) + + \param n the number of the axis for which to specify whether a grid should be drawn. + \param axisShowGrid if true a grid will be drawn on the chart data area. + \sa axisShowGrid, setAxisGridStyle, setAxisGridSubStyle + */ +void KDChartParams::setAxisShowGrid( uint n, bool axisShowGrid ) +{ + if ( n < KDCHART_MAX_AXES ) { + _axisSettings[ n ].params.setAxisShowGrid( axisShowGrid ); + emit changed(); + } +} + +/** + Returns if any grid will be drawn at the data area. + + \return if any grid will be drawn at the data area. + \sa KDChartAxisParams::setAxisShowGrid + */ +bool KDChartParams::showGrid() const +{ + for ( uint i = 0; i < KDCHART_MAX_AXES; ++i ) { + if ( _axisSettings[ i ].params.axisVisible() + && _axisSettings[ i ].params.axisShowGrid() ) + return true; + } + return false; +} + +/** + Specifies which data are to be represented by a given axis.
+ If you specify a valid dataset-number for parameter dataset + you may use the same number or a greater number for + parameter dataset2 to specify a range of contiguous series + of datasets.
+ If you specify KDCHART_ALL_DATASETS for dataset + the value of dataset2 does not matter.
+ By setting the \c chart parameter you may specify which chart is + represented by the axis, you may use this when displaying + more than one chart in the same widget. + + Calling setAxisDataset() with a dataset number will automatically set + the visability flag of the respective axis (or axes, resp.) while calling + it with KDCHART_NO_DATASET will clear the visibility flag so there is no + need to explicitely call \c setAxisVisible() after calling setAxisDatasets(). + + \note If you specify \c KDCHART_ALL_DATASETS the axis will + represent all the datasets with SourceMode DataEntry + (see \c setChartSourceMode for explanation) that have been + specified for this chart.
+ + \param n the number of the axis for which to specify the dataset(s) + \param dataset the dataset represented by axis \c n + + \sa axisDatasets, chartAxes, setChartSourceMode, setAdditionalChartType + */ +void KDChartParams::setAxisDatasets( uint n, uint dataset, + uint dataset2, + uint chart ) +{ + uint a1 = ( KDCHART_ALL_AXES == n ) + ? 0 + : QMIN( n, KDCHART_MAX_AXES-1 ); + uint a2 = ( KDCHART_ALL_AXES == n ) + ? KDCHART_MAX_AXES-1 + : QMIN( n, KDCHART_MAX_AXES-1 ); + for( uint i = a1; i <= a2; ++i ) { + _axisSettings[ i ].params.setAxisVisible( KDCHART_NO_DATASET != dataset ); + _axisSettings[ i ].dataset = dataset; + _axisSettings[ i ].dataset2 = + ( KDCHART_ALL_DATASETS == dataset + || KDCHART_NO_DATASET == dataset + || KDCHART_ALL_DATASETS == dataset2 + || KDCHART_NO_DATASET == dataset2 ) + ? dataset + : dataset2; + _axisSettings[ i ].chart = chart; + } + emit changed(); +} + +/** + Returns which data are to be represented by a given axis. + ( see explanation given with \c setAxisDatasets() ) + + \param n the axis for which to return the dataset number(s) + \param dataset the starting number of the series of datasets represented by axis \c n or KDCHART_ALL_DATASETS + \param dataset2 the end number of the series of datasets + \param chart the chart represented by axis \c n + \return true if a valid axis number was specified by parameter n + \sa setAxisDataset, chartAxes + */ +bool KDChartParams::axisDatasets( uint n, uint& dataset, + uint& dataset2, uint& chart ) const +{ + bool bOk = ( n < KDCHART_MAX_AXES ); + if ( bOk ) { + dataset = _axisSettings[ n ].dataset; + dataset2 = _axisSettings[ n ].dataset2; + chart = _axisSettings[ n ].chart; + } + return bOk; +} + + +/** + Returns which ORDINATE axis(axes) is(are) representing a given chart. + This will look for the following axes: AxisPosLeft, AxisPosRight, + AxisPosLeft2, AxisPosRight2. + + It is allowed to specify the same variable as axis1, axis2, axis3, + axis4 - when doing this you will get the last axis number that was + found for this chart. In case you are sure there is only one axis + per chart you may act that way. + + \param chart the chart for which to return the axis number(s) + \param cnt the count of axis numbers returned + \param axes on return, a vector with the numbers of the axes + \return true if at least one axis is representing the chart \c chart + \sa setAxisDataset, axisDataset + */ +bool KDChartParams::chartAxes( uint chart, uint& cnt, AxesArray& axes ) const +{ + cnt = 0; + axes.resize( KDCHART_CNT_ORDINATES ); + for ( int i2 = 0; i2 < KDCHART_CNT_ORDINATES; ++i2 ) { + axes[ i2 ] = KDCHART_NO_AXIS; + } + for ( uint i = 0; i < KDCHART_MAX_AXES; ++i ) { + if ( chart == _axisSettings[ i ].chart + && ( KDChartAxisParams::AxisPosLeft == i + || KDChartAxisParams::AxisPosRight == i + || KDChartAxisParams::AxisPosLeft2 == i + || KDChartAxisParams::AxisPosRight2 == i ) ) { + for( int j = 0; j < KDCHART_CNT_ORDINATES; ++j ) { + if( KDCHART_NO_AXIS == axes[ j ] || axes[ j ] == i ) { + if( KDCHART_NO_AXIS == axes[ j ] ) { + ++cnt; + axes[ j ] = i; + } + break; + } + } + } + } + return (0 < cnt); +} + + + + +/** + \fn QRect KDChartParams::axisArea( const uint n ) const + + Returns the true axis area rectangle as it was was calculate + by KD Chart. + + \param n the number of the axis + + \note This special function may be called *after* calling + KDChart::setupGeometry(). Normally you don't need to call + it at all, its only purpose is to provide you with a way to + retrieve the true position and size of an axis area. + + \sa dataArea + */ + +/** + \fn QRect KDChartParams::legendArea() const + + Returns the true legend area rectangle as it was was calculate + by KD Chart. + + \note This special function may be called *after* calling + KDChart::setupGeometry(). Normally you don't need to call + it at all, its only purpose is to provide you with a way to + retrieve the true position and size of an legend area. + + \sa dataArea + */ + +/** + \fn QRect KDChartParams::dataArea() const + + Returns the true data area rectangle as it was was calculate + by KD Chart. + + \note This special function may be called *after* calling + KDChart::setupGeometry(). Normally you don't need to call + it at all, its only purpose is to provide you with a way to + retrieve the true position and size of the data area. + + \sa axisArea + */ + + +/** + \fn void KDChartParams::setAxisArea( const uint n, const QRect& areaRect ) + + Specifies the true axis area rectangle. + + \note Do not call this function unless you are knowing + exactly what you are doing. \c setAxisTrueAreaRect is normally + reserved for internal usage by methods calculating the area + size based upon \c axisAreaMin and \c axisAreaMax. Thus the + signal \c changed() is not sended here. + + \sa axisAreaMax, axisAreaMin, setAxisAreaMode, setAxisAreaMin + \sa setAxisArea + */ + + +/** + \fn void KDChartParams::setAxisLabelsTouchEdges( uint n, bool axisLabelsTouchEdges ) + + Specifies whether the axis labels start and end at the + edges of the charts instead being positioned in the + middle of the first data point (or the last one, resp.) + + \note If you decide to call setAxisLabelsTouchEdges() to + override the default settings of abscissa axes + (AxisPosBottom, AxisPosTop, AxisPosBottom2, AxisPosTop2) + make sure to call it again each time you have called + setChartType() since your settings will be overwritten + when changing the chart type. + + \param axisLabelsTouchEdges if the axis labels start and end at + the edges of the charts instead being positioned in the + middle of the first data point (or the last one, resp.) + + \sa axisLabelsTouchEdges + */ + + +/** + \fn void KDChartParams::setAxisLabelsVisible( uint n, bool axisLabelsVisible ) + + Specifies whether the axis labels of an axis are to be shown. + + \param axisLabelsVisible if true the labels of this axis will be drawn. + + \sa setAxisLabelsFont + */ + + +/** + Specifies the axis labels font for one axis. + + \note The font size will be ignored if \c axisLabelsFontSize is not zero, + in this case the font size will be calculated dynamically using + the value axisLabelsFontSize. + + \param axisLabelsFont the font to be used for the axis' labels. + \param axisLabelsFontSize the (fixed or relative) axis font size. + If this value is less than zero the absolute value is per thousand + of the average value of the printable area height and width + to be used. This will make the axis look the same even if scaled + to very different size. + \param axisLabelsColor the axis labels colour. + + \sa setAxisLabelsVisible + \sa setAxisLabelsFontUseRelSize, setAxisLabelsFontRelSize + \sa KDChartAxisParams::setAxisLabelsFontMinSize + */ +void KDChartParams::setAxisLabelsFont( uint n, + QFont axisLabelsFont, + int axisLabelsFontSize, + QColor axisLabelsColor ) +{ + if ( n < KDCHART_MAX_AXES ) { + bool extraSize = (0 != axisLabelsFontSize); + QFont theFont( axisLabelsFont ); + bool useFontFixedSize = true; + if ( extraSize ){ + if( 0 > axisLabelsFontSize ){ + useFontFixedSize = false; + _axisSettings[ n ].params.setAxisLabelsFontRelSize( -axisLabelsFontSize ); + }else{ + theFont.setPointSize( axisLabelsFontSize ); + } + } + _axisSettings[ n ].params.setAxisLabelsFont( theFont, useFontFixedSize ); + _axisSettings[ n ].params.setAxisLabelsColor( axisLabelsColor ); + } +} + + +/** + \fn void KDChartParams::setAxisLabelTextParams( uint n, bool axisSteadyValueCalc, + KDChartData axisValueStart, KDChartData axisValueEnd, + double axisValueDelta, int axisDigitsBehindComma, + int axisMaxEmptyInnerSpan, + KDChartAxisParams::LabelsFromDataRow takeLabelsFromDataRow, + int labelTextsDataRow, QStringList* axisLabelStringList, + QStringList* axisShortLabelsStringList ) + + Specifies the label text parameters for one axis. + + \sa KDChartAxisParams::setAxisLabelTextParams + */ + + +/** + Specifies a \c QStringList which the axis label texts for one + axis are to be taken from, the optional short-labels parameter + (if not zero) may be used to specify an alternative list of + strings that are to be displayed in case the axis area size + is too small for showing the full-length names. + + \note Normally axis labeling starts with the list's first string + and end with its last string, but by specifying a start and an + end value as additional parameters you can make KDChart repeat + the strings between these two values only, as shown here: + + \verbatim + QStringList abscissaNames; + abscissaNames << "Sunday" << "Monday" << "Tuesday" << "Wednesday" + << "Thursday" << "Friday" << "Saturday"; + QStringList abscissaShortNames; + abscissaShortNames << "Sun" << "Mon" << "Tue" << "Wed" + << "Thu" << "Fri" << "Sat"; + + setAxisLabelStringParams( KDChartAxisParams::AxisPosBottom, + &names, &shortNames, + "Monday", "Friday") + \endverbatim + + + \param n the ID of the axis + \param QStringList* axisLabelStringList points to the list of labels to be displayed + \param QStringList* axisShortLabelStringList points to + an alternative list of short names to be displayed if the long labels take too much place + \param QString valueStart ( default null ) the label to begin with + \param QString valueEnd ( default null ) the label to end with + + \sa KDChartAxisParams::setAxisLabelStringLists + */ +void KDChartParams::setAxisLabelStringParams( uint n, + QStringList* axisLabelStringList, + QStringList* axisShortLabelStringList, + const QString& valueStart, + const QString& valueEnd ) +{ + if ( n < KDCHART_MAX_AXES ) { + _axisSettings[ n ].params.setAxisLabelStringLists( axisLabelStringList, + axisShortLabelStringList, + valueStart, + valueEnd ); + emit changed(); + } +} + + +/** + Specifies the parameters for one axis. + + \param axisParams the axis parameters to be used. + \sa axisParams, AxisParams + */ +void KDChartParams::setAxisParams( uint n, + const KDChartAxisParams& axisParams ) +{ + if ( n < KDCHART_MAX_AXES ) { + _axisSettings[ n ].params = axisParams; + emit changed(); + } +} + + +/** + \fn const KDChartAxisParams& KDChartParams::axisParams( uint n ) const + + Returns the parameters that are currently defined for axis n. + + \return all the parameters defined for axis n. If called with invalid + value for \c n it returns the default axis parameters. + \sa setAxisParams, AxisParams + */ + + +//@} +// END AXES + +// START HEADERFOOTER + +/** @name Header and footer methods. + + These methods query and set header and footer parameters. + + The names of the Header and Footer sections. + + You may use up to 9 header and/or up to 9 footer sections. + + \li Up to three leading headers ( \c HdFtPosHeader0 , \c + HdFtPosHeader0L , \c HdFtPosHeader0R ) may be drawn at the very upper + edge of the printable area.
+ You might want to use those sections to show some marginal information + like department name, print date, page number...
+ Note: Those headers share the same area so make sure to + specify propper horizontal alignment for each section when using more than + one of them. By default \c HdFtPosHeader0 has centered alignement, + \c HdFtPosHeader0L is aligned to the left and \c HdFtPosHeader0R to the + right side. All of them are vertically aligned to the bottom, you may + change this at your own risk: the resulting output might look strange.
+ also note: Alignment to bottom here means their baselines are + horizontally adjusted to each other when more than one of them is used - it + does not mean the lowest pixel positions of their output will + be at the very same y coordinate since those might vary depending from the + font size and or the font size you have specified for each of the sections. + + \li Up to three main headers ( \c HdFtPosHeader , \c + HdFtPosHeaderL , \c HdFtPosHeaderR ) may be drawn under the + leading header(s).
+ You could use this headers to show the main information such as project name, + chart title or period of time (e.g. census year).
+ Like their counterparts they share the same part of the printable area so the + restrictions regarding alignment mentioned above apply also to these three + sections. + + \li Up to three additional headers ( \c HdFtPosHeader2 , \c + HdFtPosHeader2L , \c HdFtPosHeader2R ) may be drawn under the main + header(s).
+ This headers could show additional information such as project phase, chart + sub-title or sub-period of time (e.g. census quarter-year).
+ Like their counterparts they share the same part of the printable area so the + restrictions regarding alignment mentioned above apply also to these three + sections. + +

+ + \li Up to three main footers ( \c HdFtPosFooter , \c + HdFtPosFooterL , \c HdFtPosFooterR ) may be drawn under the chart data + area (or the legend that might be shown below that area, resp.).
+ You might want to use these footers instead of (or additional to) the + main header(s) for showing the main information...
+ Like their header-counterparts they share the same part of the printable area + so the restrictions regarding alignment mentioned above apply also to these + three sections. + + \li Up to three additional footers ( \c HdFtPosFooter2 , \c + HdFtPosFooter2L , \c HdFtPosHeader2R ) may be drawn under the main + footer(s).
+ This footers could show additional information instead of (or additional to) + the additional header(s).
+ Like their counterparts they share the same part of the printable area so the + restrictions regarding alignment mentioned above apply also to these three + sections. + + \li Up to three trailing footers ( \c HdFtPosFooter0 , \c + HdFtPosFooter0L , \c HdFtPosFooter0R ) may be drawn at the very lower + edge of the printable area: under the other footer sections
+ You might want to use those sections to show some marginal information + instead of (or additional to) the leading header(s).
+ Like their counterparts they share the same part of the printable area so the + restrictions regarding alignment mentioned above apply also to these three + sections. + +\note The names \c HdFtPosHeader or \c HdFtPosFooter are the basic names also returned by \c basicAxisPos. + +

+Usage: Please see example code at \c setHeaderFooterText function explanation. + +\sa setHeaderFooterText, headerFooterText +\sa setHeaderFooterFont, headerFooterFont +\sa setHeaderFooterFontUseRelSize, headerFooterFontUseRelSize +\sa setHeaderFooterFontRelSize, headerFooterFontRelSize +*/ +//@{ + + +/** + \enum KDChartParams::HdFtPos + + This enum lists the positions that headers and footers can take. + */ + + +/** + \enum KDChartParams::HdFtPosSTART, + + start of all sections + */ + +/** + \enum KDChartParams::HdFtPosHeadersSTART + + start of header sections + */ + +/** + \enum KDChartParams::HdFtPosHeader0 + + leading header (at the very top of the printable area) + */ + +/** + \enum KDChartParams::HdFtPosHeader0L + + another leading header, by default left-aligned + */ + +/** + \enum KDChartParams::HdFtPosHeader0R + + yet another leading header, by default right-aligned + */ + +/** + \enum KDChartParams::HdFtPosHeader + + main header (below the leading header) + */ + +/** + \enum KDChartParams::HdFtPosHeaderL + + another main header, by default left-aligned + */ + +/** + \enum KDChartParams::HdFtPosHeaderR + + yet another main header, by default right-aligned + */ + +/** + \enum KDChartParams::HdFtPosHeader2 + + additional header (below the main header) + */ + +/** + \enum KDChartParams::HdFtPosHeader2L + + another additional header, by default left-aligned + */ + +/** + \enum KDChartParams::HdFtPosHeader2R + + yet another additional header, by default right-aligned + */ + +/** + \enum KDChartParams::HdFtPosHeadersEND + + end of header sections + */ + +/** + \enum KDChartParams::HdFtPosFootersSTART + + start of footer sections + */ + + +/** + \enum KDChartParams::HdFtPosFooter + + main footer (below the data area or the bottom legend (if any), resp.) + */ + +/** + \enum KDChartParams::HdFtPosFooterL + + another main footer, by default left-aligned + */ + +/** + \enum KDChartParams::HdFtPosFooterR + + yet another main footer, by default right-aligned + */ + + +/** + \enum KDChartParams::HdFtPosFooter2 + + additional footer (below the main footer) + */ + +/** + \enum KDChartParams::HdFtPosFooter2L + + another additional footer, by default left-aligned + */ + +/** + \enum KDChartParams::HdFtPosFooter2R + + yet another additional footer, by default right-aligned + */ + + +/** + \enum KDChartParams::HdFtPosFooter0 + + trailing footer (below the additional footer) + */ + +/** + \enum KDChartParams::HdFtPosFooter0L + + another trailing footer, by default left-aligned + */ + +/** + \enum KDChartParams::HdFtPosFooter0R + + yet another trailing footer, by default right-aligned + */ + +/** + \enum KDChartParams::HdFtPosFootersEND + + end of footer sections + */ + +/** + \enum KDChartParams::HdFtPosEND + + end of all sections + */ + + +/** + Specifies the text to be displayed in the header (or footer, resp.) + section specified by \c pos. + The default is not to display any header text nor footer text. + + \note To learn about the different header (or footer, resp.) + sections please see information given at \c HdFtPos enum explanation. + + \param pos the section in which the text is to be shown + \param text the text to be shown + \sa HdFtPos, headerFooterText() + \sa setHeaderFooterFont, headerFooterFont + \sa setHeaderFooterFontUseRelSize, headerFooterFontUseRelSize + \sa setHeaderFooterFontRelSize, headerFooterFontRelSize + \sa setHeader1Text(), header1Text() + \sa setHeader2Text(), header2Text() + \sa setFooterText(), footerText() + */ +void KDChartParams::setHeaderFooterText( uint pos, const QString& text ) +{ + if ( HdFtPosEND >= pos ) { + _hdFtParams[ pos ]._text = text; + emit changed(); + } +} + + +/** + Returns the text that is displayed in the header (or footer, resp.) + section specified by \c pos. + + \note To learn about the different header (or footer, resp.) + sections please see information given at \c HdFtPos enum explanation. + + \param pos the section for which to return the text + \return the displayed text + \sa HdFtPos, setHeaderFooterText() + \sa setHeaderFooterFont, headerFooterFont + \sa setHeaderFooterFontUseRelSize, headerFooterFontUseRelSize + \sa setHeaderFooterFontRelSize, headerFooterFontRelSize + \sa setHeader1Text(), header1Text() + \sa setHeader2Text(), header2Text() + \sa setFooterText(), footerText() + */ +QString KDChartParams::headerFooterText( uint pos ) const +{ + if ( HdFtPosEND >= pos ) + return _hdFtParams[ pos ]._text; + else + return QString::null; +} + + + +/** + \note This methode for internal use. + Return the position and size of one header/footer area. + Will return valid data only if called after KDChartPainter::setupGeometry()! + */ +const QRect& KDChartParams::headerFooterRect( uint pos ) const +{ + if ( HdFtPosEND >= pos ) + return _hdFtParams[ pos ].rect(); + else + return _noRect; +} + + +/** + Specifies the colour to be used for the header text (or footer text, resp.) + of the header/footer section specified by \c pos. + The default colour is QColor( Qt::black ). + + \note To learn about the different header (or footer, resp.) + sections please see information given at \c HdFtPos enum explanation. + + \param pos the section for which the colour is to be changed + \param color the text colour to be used + \sa HdFtPos, headerFooterText() + \sa setHeaderFooterFont, headerFooterFont + \sa setHeaderFooterFontUseRelSize, headerFooterFontUseRelSize + \sa setHeaderFooterFontRelSize, headerFooterFontRelSize + \sa setHeader1Text(), header1Text() + \sa setHeader2Text(), header2Text() + \sa setFooterText(), footerText() + */ +void KDChartParams::setHeaderFooterColor( uint pos, const QColor color ) +{ + if ( HdFtPosEND >= pos ) { + _hdFtParams[ pos ]._color = color; + emit changed(); + } +} + + +/** + Returns the colour used for the header text (or footer text, resp.) + of the header/footer section specified by \c pos. + + \note To learn about the different header (or footer, resp.) + sections please see information given at \c HdFtPos enum explanation. + + \param pos the section for which to return the text colour + \return the text colour + \sa HdFtPos, setHeaderFooterText() + \sa setHeaderFooterFont, headerFooterFont + \sa setHeaderFooterFontUseRelSize, headerFooterFontUseRelSize + \sa setHeaderFooterFontRelSize, headerFooterFontRelSize + \sa setHeader1Text(), header1Text() + \sa setHeader2Text(), header2Text() + \sa setFooterText(), footerText() + */ +QColor KDChartParams::headerFooterColor( uint pos ) const +{ + if ( HdFtPosEND >= pos ) + return _hdFtParams[ pos ]._color; + else + return QColor( Qt::black ); +} + + +/** + Specifies the font to be used in the header (or footer, + resp.) section specified by \c pos.. + The default is a 14pt Helvetica font. + + \note To learn about the different header (or footer, resp.) + sections please see information given at \c HdFtPos enum explanation. + + \param pos the section in which the font is to be used + \param font the font to use + \sa HdFtPos, setHeaderFooterText(), headerFooterText() + \sa headerFooterFont() + \sa setHeaderFooterFontUseRelSize, headerFooterFontUseRelSize + \sa setHeaderFooterFontRelSize, headerFooterFontRelSize + \sa setHeader1Font(), header1Font() + \sa setHeader2Font(), header2Font() + \sa setFooterFont(), footerFont() + \sa setHeader1Text(), header1Text() + \sa setHeader2Text(), header2Text() + \sa setFooterText(), footerText() + */ +void KDChartParams::setHeaderFooterFont( uint pos, const QFont& font, + bool fontUseRelSize, + int fontRelSize ) +{ + if ( HdFtPosEND >= pos ) { + _hdFtParams[ pos ]._font = font; + _hdFtParams[ pos ]._fontUseRelSize = fontUseRelSize; + _hdFtParams[ pos ]._fontRelSize = fontRelSize; + emit changed(); + } +} + + +/** + Returns the font used in the header (or footer, resp.) + section specified by \c pos. + + \note To learn about the different header (or footer, resp.) + sections please see information given at \c HdFtPos enum explanation. + + \param pos the section for which to return the font + \return the used font + \sa HdFtPos, setHeaderFooterText(), headerFooterText() + \sa setHeaderFooterFont() + \sa setHeaderFooterFontUseRelSize, headerFooterFontUseRelSize + \sa setHeaderFooterFontRelSize, headerFooterFontRelSize + \sa setHeader1Font(), header1Font() + \sa setHeader2Font(), header2Font() + \sa setFooterFont(), footerFont() + \sa setHeader1Text(), header1Text() + \sa setHeader2Text(), header2Text() + \sa setFooterText(), footerText() + */ +QFont KDChartParams::headerFooterFont( uint pos ) const +{ + if ( HdFtPosEND >= pos ) + return _hdFtParams[ pos ]._font; + else + return QApplication::font(); +} + + +/** + Returns is the font size used in the header (or footer, resp.) + section specified by \c pos will be calculated dynamically. + + \note To learn about the different header (or footer, resp.) + sections please see information given at \c HdFtPos enum explanation. + + \param pos the section for which to return the font calculation flag + \return the font calculation flag + \sa HdFtPos, setHeaderFooterText(), headerFooterText() + \sa setHeaderFooterFont() + \sa setHeaderFooterFontUseRelSize, headerFooterFontUseRelSize + \sa setHeaderFooterFontRelSize, headerFooterFontRelSize + \sa setHeader1Font(), header1Font() + \sa setHeader2Font(), header2Font() + \sa setFooterFont(), footerFont() + \sa setHeader1Text(), header1Text() + \sa setHeader2Text(), header2Text() + \sa setFooterText(), footerText() + */ +bool KDChartParams::headerFooterFontUseRelSize( uint pos ) const +{ + if ( HdFtPosEND >= pos ) + return _hdFtParams[ pos ]._fontUseRelSize; + else + return false; +} + + +/** + Returns the factor used for dynamical calculation of + the font size of the text in the header (or footer, resp.) + section specified by \c pos. + + \note To learn about the different header (or footer, resp.) + sections please see information given at \c HdFtPos enum explanation. + + \param pos the section for which to return the font size factor + \return the font size factor + \sa HdFtPos, setHeaderFooterText(), headerFooterText() + \sa setHeaderFooterFont() + \sa setHeaderFooterFontUseRelSize, headerFooterFontUseRelSize + \sa setHeaderFooterFontRelSize, headerFooterFontRelSize + \sa setHeader1Font(), header1Font() + \sa setHeader2Font(), header2Font() + \sa setFooterFont(), footerFont() + \sa setHeader1Text(), header1Text() + \sa setHeader2Text(), header2Text() + \sa setFooterText(), footerText() + */ +int KDChartParams::headerFooterFontRelSize( uint pos ) const +{ + if ( HdFtPosEND >= pos ) + return _hdFtParams[ pos ]._fontRelSize; + else + return 10; +} + + +/** + \fn void KDChartParams::setHeader1Text( const QString& text ) + + Specifies the text to be displayed as the first header line. The + default is not to display any header text. + + \note This function provided for convenience only.
+ To gain the full benefits of the header/footer management + please consider learning about the different header (or footer, + resp.) sections, see information given at \c HdFtPos enum + explanation.
+ The 'better' way to specify content and settings of headers or + footers is to call \c setHeaderFooterText ( or \c setHeaderFooterFont + , \c setHeaderFooterFontUseRelSize , \c setHeaderFooterFontRelSize , + resp.) while specifying the appropriate \c HdFtPos.
+ The canonical way to retrieve settings and content of headers or + footers is to call \c headerFooterText (or \c headerFooterFont , + \c headerFooterFontUseRelSize , \c headerFooterFontRelSize, resp.). + + \param text the text to display + \sa HdFtPos, setHeaderFooterText(), headerFooterText() + \sa header2Text(), setHeader1Text(), header1Text(), setFooterText(), + footerText() + */ + + +/** + \fn QString KDChartParams::header1Text() const + + Returns the text that is displayed as the first header line. + + \note This function provided for convenience only.
+ To gain the full benefits of the header/footer management + please consider learning about the different header (or footer, + resp.) sections, see information given at \c HdFtPos enum + explanation.
+ The 'better' way to specify content and settings of headers or + footers is to call \c setHeaderFooterText ( or \c setHeaderFooterFont + , \c setHeaderFooterFontUseRelSize , \c setHeaderFooterFontRelSize , + resp.) while specifying the appropriate \c HdFtPos.
+ The canonical way to retrieve settings and content of headers or + footers is to call \c headerFooterText (or \c headerFooterFont , + \c headerFooterFontUseRelSize , \c headerFooterFontRelSize, resp.). + + \return the displayed text + \sa HdFtPos, setHeaderFooterText(), headerFooterText() + \sa setHeader2Text(), setHeader1Text(), header1Text() + \sa setFooterText(), footerText() + */ + + +/** + \fn void KDChartParams::setHeader1Font( const QFont& font ) + + Specifies the font to be used for displaying the first header line. + The default is a 14pt Helvetica font. + + \note This function provided for convenience only.
+ To gain the full benefits of the header/footer management + please consider learning about the different header (or footer, + resp.) sections, see information given at \c HdFtPos enum + explanation.
+ The 'better' way to specify content and settings of headers or + footers is to call \c setHeaderFooterText ( or \c setHeaderFooterFont + , \c setHeaderFooterFontUseRelSize , \c setHeaderFooterFontRelSize , + resp.) while specifying the appropriate \c HdFtPos.
+ The canonical way to retrieve settings and content of headers or + footers is to call \c headerFooterText (or \c headerFooterFont , + \c headerFooterFontUseRelSize , \c headerFooterFontRelSize, resp.). + + \param font the font to use + \sa HdFtPos, setHeaderFooterFont(), headerFooterFont() + \sa setHeaderFooterFontUseRelSize(), headerFooterFontUseRelSize() + \sa setHeaderFooterFontRelSize(), headerFooterFontRelSize() + \sa header2Font(), setHeader2Text(), header2Text() + \sa setHeader1Font(), header1Font() + \sa setFooterFont(), footerFont() + */ + + +/** + \fn QFont KDChartParams::header1Font() const + + Returns the font used for displaying the second header line. + + \note This function provided for convenience only.
+ To gain the full benefits of the header/footer management + please consider learning about the different header (or footer, + resp.) sections, see information given at \c HdFtPos enum + explanation.
+ The 'better' way to specify content and settings of headers or + footers is to call \c setHeaderFooterText ( or \c setHeaderFooterFont + , \c setHeaderFooterFontUseRelSize , \c setHeaderFooterFontRelSize , + resp.) while specifying the appropriate \c HdFtPos.
+ The canonical way to retrieve settings and content of headers or + footers is to call \c headerFooterText (or \c headerFooterFont , + \c headerFooterFontUseRelSize , \c headerFooterFontRelSize, resp.). + + \return the used font + \sa HdFtPos, setHeaderFooterFont(), headerFooterFont() + \sa setHeaderFooterFontUseRelSize(), headerFooterFontUseRelSize() + \sa setHeaderFooterFontRelSize(), headerFooterFontRelSize() + \sa setHeader2Font(), setHeader2Text(), header2Text(), + setHeader1Font(), header1Font(), setFooterFont(), footerFont() + */ + + +/** + \fn void KDChartParams::setHeader2Text( const QString& text ) + + Specifies the text to be displayed as the second header line. The + default is not to display any header text. + + \note This function provided for convenience only.
+ To gain the full benefits of the header/footer management + please consider learning about the different header (or footer, + resp.) sections, see information given at \c HdFtPos enum + explanation.
+ The 'better' way to specify content and settings of headers or + footers is to call \c setHeaderFooterText ( or \c setHeaderFooterFont + , \c setHeaderFooterFontUseRelSize , \c setHeaderFooterFontRelSize , + resp.) while specifying the appropriate \c HdFtPos.
+ The canonical way to retrieve settings and content of headers or + footers is to call \c headerFooterText (or \c headerFooterFont , + \c headerFooterFontUseRelSize , \c headerFooterFontRelSize, resp.). + + \param text the text to display + \sa HdFtPos, setHeaderFooterText(), headerFooterText() + \sa header2Text(), setHeader1Text(), header1Text(), setFooterText(), + footerText() + */ + + +/** + \fn QString KDChartParams::header2Text() const + + Returns the text that is displayed as the second header line. + + \note This function provided for convenience only.
+ To gain the full benefits of the header/footer management + please consider learning about the different header (or footer, + resp.) sections, see information given at \c HdFtPos enum + explanation.
+ The 'better' way to specify content and settings of headers or + footers is to call \c setHeaderFooterText ( or \c setHeaderFooterFont + , \c setHeaderFooterFontUseRelSize , \c setHeaderFooterFontRelSize , + resp.) while specifying the appropriate \c HdFtPos.
+ The canonical way to retrieve settings and content of headers or + footers is to call \c headerFooterText (or \c headerFooterFont , + \c headerFooterFontUseRelSize , \c headerFooterFontRelSize, resp.). + + \return the displayed text + \sa HdFtPos, setHeaderFooterText(), headerFooterText() + \sa setHeader2Text(), setHeader1Text(), header1Text(), setFooterText(), + footerText() + */ + + +/** + \fn void KDChartParams::setHeader2Font( const QFont& font ) + + Specifies the font to be used for displaying the second header line. The + default is a 12pt Helvetica font. + + \note This function provided for convenience only.
+ To gain the full benefits of the header/footer management + please consider learning about the different header (or footer, + resp.) sections, see information given at \c HdFtPos enum + explanation.
+ The 'better' way to specify content and settings of headers or + footers is to call \c setHeaderFooterText ( or \c setHeaderFooterFont + , \c setHeaderFooterFontUseRelSize , \c setHeaderFooterFontRelSize , + resp.) while specifying the appropriate \c HdFtPos.
+ The canonical way to retrieve settings and content of headers or + footers is to call \c headerFooterText (or \c headerFooterFont , + \c headerFooterFontUseRelSize , \c headerFooterFontRelSize, resp.). + + \param font the font to use + \sa HdFtPos, setHeaderFooterFont(), headerFooterFont() + \sa setHeaderFooterFontUseRelSize(), headerFooterFontUseRelSize() + \sa setHeaderFooterFontRelSize(), headerFooterFontRelSize() + \sa header2Font(), setHeader2Text(), header2Text(), setHeader1Font(), header1Font(), + setFooterFont(), footerFont() + */ + + + +/** + \fn QFont KDChartParams::header2Font() const + + Returns the font used for displaying the second header line. + + \note This function provided for convenience only.
+ To gain the full benefits of the header/footer management + please consider learning about the different header (or footer, + resp.) sections, see information given at \c HdFtPos enum + explanation.
+ The 'better' way to specify content and settings of headers or + footers is to call \c setHeaderFooterText ( or \c setHeaderFooterFont + , \c setHeaderFooterFontUseRelSize , \c setHeaderFooterFontRelSize , + resp.) while specifying the appropriate \c HdFtPos.
+ The canonical way to retrieve settings and content of headers or + footers is to call \c headerFooterText (or \c headerFooterFont , + \c headerFooterFontUseRelSize , \c headerFooterFontRelSize, resp.). + + \return the used font + \sa HdFtPos, setHeaderFooterFont(), headerFooterFont() + \sa setHeaderFooterFontUseRelSize(), headerFooterFontUseRelSize() + \sa setHeaderFooterFontRelSize(), headerFooterFontRelSize() + \sa setHeader2Font(), setHeader2Text(), header2Text(), + setHeader1Font(), header1Font(), setFooterFont(), footerFont() + */ + + +/** + \fn void KDChartParams::setFooterText( const QString& text ) + + Specifies the text to be displayed as the footer line. The + default is not to display any footer text. + + \note This function provided for convenience only.
+ To gain the full benefits of the header/footer management + please consider learning about the different header (or footer, + resp.) sections, see information given at \c HdFtPos enum + explanation.
+ The 'better' way to specify content and settings of headers or + footers is to call \c setHeaderFooterText ( or \c setHeaderFooterFont + , \c setHeaderFooterFontUseRelSize , \c setHeaderFooterFontRelSize , + resp.) while specifying the appropriate \c HdFtPos.
+ The canonical way to retrieve settings and content of headers or + footers is to call \c headerFooterText (or \c headerFooterFont , + \c headerFooterFontUseRelSize , \c headerFooterFontRelSize, resp.). + + \param text the text to display + \sa HdFtPos, setHeaderFooterText(), headerFooterText() + \sa footerText(), setHeader1Text(), header1Text(), setHeader2Text(), + header2Text() + */ + + +/** + \fn QString KDChartParams::footerText() const + + Returns the text that is displayed as the footer line. + + \note This function provided for convenience only.
+ To gain the full benefits of the header/footer management + please consider learning about the different header (or footer, + resp.) sections, see information given at \c HdFtPos enum + explanation.
+ The 'better' way to specify content and settings of headers or + footers is to call \c setHeaderFooterText ( or \c setHeaderFooterFont + , \c setHeaderFooterFontUseRelSize , \c setHeaderFooterFontRelSize , + resp.) while specifying the appropriate \c HdFtPos.
+ The canonical way to retrieve settings and content of headers or + footers is to call \c headerFooterText (or \c headerFooterFont , + \c headerFooterFontUseRelSize , \c headerFooterFontRelSize, resp.). + + \return the displayed text + \sa HdFtPos, setHeaderFooterText(), headerFooterText() + \sa setFooterText(), setHeader1Text(), header1Text(), setHeader2Text(), + header2Text() + */ + + +/** + \fn void KDChartParams::setFooterFont( const QFont& font ) + + Specifies the font to be used for displaying the footer line. The + default is a 12pt Helvetica font. + + \note This function provided for convenience only.
+ To gain the full benefits of the header/footer management + please consider learning about the different header (or footer, + resp.) sections, see information given at \c HdFtPos enum + explanation.
+ The 'better' way to specify content and settings of headers or + footers is to call \c setHeaderFooterText ( or \c setHeaderFooterFont + , \c setHeaderFooterFontUseRelSize , \c setHeaderFooterFontRelSize , + resp.) while specifying the appropriate \c HdFtPos.
+ The canonical way to retrieve settings and content of headers or + footers is to call \c headerFooterText (or \c headerFooterFont , + \c headerFooterFontUseRelSize , \c headerFooterFontRelSize, resp.). + + \param font the font to use + \sa HdFtPos, setHeaderFooterFont(), headerFooterFont() + \sa setHeaderFooterFontUseRelSize(), headerFooterFontUseRelSize() + \sa setHeaderFooterFontRelSize(), headerFooterFontRelSize() + \sa footerFont(), setFooterText(), footerText(), setHeader1Font(), header1Font(), + setHeader2Font(), header2Font() + */ + + +/** + \fn QFont KDChartParams::footerFont() const + + Returns the font used for displaying the footer line. + + \note This function provided for convenience only.
+ To gain the full benefits of the header/footer management + please consider learning about the different header (or footer, + resp.) sections, see information given at \c HdFtPos enum + explanation.
+ The 'better' way to specify content and settings of headers or + footers is to call \c setHeaderFooterText ( or \c setHeaderFooterFont + , \c setHeaderFooterFontUseRelSize , \c setHeaderFooterFontRelSize , + resp.) while specifying the appropriate \c HdFtPos.
+ The canonical way to retrieve settings and content of headers or + footers is to call \c headerFooterText (or \c headerFooterFont , + \c headerFooterFontUseRelSize , \c headerFooterFontRelSize, resp.). + + \return the used font + \sa HdFtPos, setHeaderFooterFont(), headerFooterFont() + \sa setHeaderFooterFontUseRelSize(), headerFooterFontUseRelSize() + \sa setHeaderFooterFontRelSize(), headerFooterFontRelSize() + \sa setFooterFont(), setFooterText(), footerText(), + setHeader1Font(), header1Font(), setHeader2Font(), header2Font() + */ + + +//@} +// END HEADERFOOTER + + + +// PRIVATE VARIABLES +/** + \var int KDChartParams::_globalLeadingLeft; + Stores the distance between the chart and the left border of the painter area. + */ + +/** + \var int KDChartParams::_globalLeadingTop; + + Stores the distance between the chart and the upper border of the painter area. + */ + + +/** + \var int KDChartParams::_globalLeadingRight; + + Stores the distance between the chart and the left border of the painter area. + */ + + +/** + \var int KDChartParams::_globalLeadingBottom; + + Stores the distance between the chart and the right border of the painter area. + */ + +/** + \var ChartType KDChartParams::_chartType; + + Stores the chart type. + */ + +/** + \var ChartType KDChartParams::_additionalChartType; + + Stores the additional chart type. + */ + +/** + \var int KDChartParams::_numValues; + + Stores how many of the values should be shown. -1 means all + available values. + */ + +/** + \var QFont KDChartParams::_defaultFont; + + Stores our default font used for many different purposes. + */ + +/** + \var KDChartParams::AreaMap + + The type used for storing the frame settings for all of the chart areas. + */ + +/** + \var AreaMap KDChartParams::_areaMap; + Stores the frame settings for all of the chart areas. + */ + +/** + \var CustomBoxMap KDChartParams::_customBoxDict; + + Stores the settings for all of the custom boxes. + */ + + +/** + \var QRect KDChartParams::_noRect; + + Stores an empty rectangle. + */ + +/** + \var KDFrame KDChartParams::_noFrame; + + Stores the default frame settings: no border, no corners, no background. + */ + +/** + \var KDChartFrameSettings KDChartParams::_noFrameSettings; + + Stores the default area settings: no frame, no inner gap, no outer gap. + */ + + +/** + \class KDChartParams::ModeAndChart + + Stores the SourceMode and the chart(s) for one dataset. + */ + + +/** + \var ModeAndChartMap KDChartParams::_dataSourceModeAndChart; + + Stores the SourceMode and the chart(s) for the datasets. + */ + +/** + \var typedef KDChartParams::ModeAndChartMap + + The type used for storing the source mode and charts of the datasets + */ + + +/** + \var bool KDChartParams::_setChartSourceModeWasUsed; + + Stores whether setChartSourceMode() was called or not + */ + +/** + \var QMap < uint, QColor > KDChartParams::_dataColors; + + Stores the colors for the datasets. + */ + +/** + \var uint KDChartParams::_maxDatasetSourceMode; + + Stores the highest dataset number for which a SourceMode has been + defined. Note that if you define a value for a dataset but not for a + dataset with a lower number (and there is neither a default value), the + source mode for that dataset with the lower number will be undefined. + */ + + +/** + \var KDChartPropertySetList KDChartParams::_propertySetList; + + Stores all property-sets that were defined. + Each of these sets may be assigned to an individual cell. + */ + + +/** + \var double KDChartParams::_shadowBrightnessFactor; + + Stores a factor to be used to adjust the + built-in brightness of shadow colors in + 3-dimensional drawings like e.g. 3D bar charts. + */ + + +/** + \var Qt::BrushStyle KDChartParams::_shadowPattern; + + Stores a fill style to be used for filling shadow area in + 3-dimensional drawings like e.g. 3D bar charts. + */ + +/** + \var bool KDChartParams::_threeDShadowColors; + + Stores whether shadowed colors are used for 3D effects. Only used + for 3D effects in charts that support these. + */ + + +/** + \var uint KDChartParams::_maxDatasetColor; + + Stores the highest dataset number for which a color has been + defined. Note that if you define a value for a dataset but not for a + dataset with a lower number (and there is neither a default value), the + color for that dataset with the lower number will be undefined. + */ + +/** + \var QMap < uint, QColor > KDChartParams::_dataColorsShadow1; + + Stores the shadow colors that are somewhat darker than the colors in + _dataColors. + */ + +/** + \var QMap < uint, QColor > KDChartParams::_dataColorsShadow2; + + Stores the shadow colors that are even more darker than the colors in + _dataColorsShadow1; + */ + +/** + \var QColor KDChartParams::_outlineDataColor; + + Stores the color to be used for outlines of data displays. + */ + +/** + \var uint KDChartParams::_outlineDataLineWidth; + + Stores the line width to be used for outlines of data displays. + */ + +/** + \var PenStyle KDChartParams::_outlineDataLineStyle; + + Stores the line style to be used for outlines of data displays. + */ + + + +/** + \struct PrintValueDataSettings KDChartParams.h + + Stores if and how a chart will print the data values near their + respective entries. + */ + + +/** + \var PrintDataValuesSettings KDChartParams::_printDataValuesSettings; + + Stores if and how the FIRST chart will print the data values + near their respective entries. + */ + +/** + \var PrintDataValuesSettings KDChartParams::_printDataValuesSettings2; + + Stores if and how the SECOND chart will print the data values + near their respective entries, in case two charts are to be + drawn sharing the same data area. + */ + +/** + \var bool KDChartParams::_allowOverlappingDataValueTexts; + + Stores whether a data value may be drawn near it's respective entry + even if it's region intersects with another data value text's region. + + By default this is FALSE to prevent ugly mutual overwriting of data + value texts and to speed up drawing of cahrts containing thousands + of data points. + */ + + +/** + \var BarChartSubType KDChartParams::_barChartSubType; + + Stores the bar chart subtype. Only used when chartType() == + Bar + */ + +/** + \var bool KDChartParams::_threeDBars; + + Stores whether the engine should draw the bars in 3D. Only + used if chartType() == Bar. + */ + +/** + \var int KDChartParams::_threeDBarAngle; + + Stores the angle used for 3D display. Only used if + threeDBars == true. + */ + +/** + \var double KDChartParams::_threeDBarDepth; + + Stores the depth of the 3D Effect used for 3D bars + in relation to the bar width. + Only used if chartType() == Bar and threeDBars() == true. + */ + + +/** + \var double KDChartParams::_cosThreeDBarAngle; + + The cosine in rad of the angle for 3D display. Only used if + threeDBars == true. + */ + +/** + \var int KDChartParams::_datasetGap; + + Stores the number of pixels between two dataset values. + */ + +/** + \var bool KDChartParams::_datasetGapIsRelative; + + Stores if the value set by \c setDatasetGap + is a per mille value of the chart data area width. + */ + +/** + \var int KDChartParams::_valueBlockGap; + + Stores the number of pixels between each value block. + */ + +/** + \var bool KDChartParams::_valueBlockGapIsRelative; + + Stores if the value set by \c setValueBlockGap + is a per mille value of the chart data area width. + */ + +/// LINES/AREAS-specific +/** + \var LineChartSubType KDChartParams::_lineChartSubType; + + Stores the line chart subtype. Only used when chartType() == + Line + */ + +/** + \var bool KDChartParams::_threeDLines; + + Stores whether 3D lines should be drawn. + */ + + +/** + \var int KDChartParams::_threeDLineDepth; + + Stores the depth of 3D lines. + */ + + +// documentation of this member variable temporary disabled: +// Feature is currently not supported, will be implemented +// by future versions of KDChart +/* + \var int KDChartParams::_threeDLineXRotation; + + Stores the X rotation of 3D lines. + */ + + +// documentation of this member variable temporary disabled: +// Feature is currently not supported, will be implemented +// by future versions of KDChart +/* + \var int KDChartParams::_threeDLineYRotation; + + Stores the Y rotation of 3D lines. + */ + + +/** + \var bool KDChartParams::_lineMarker; + + Stores whether line markers should be drawn. Only used when + chartType() == Line. + */ + + +/** + \var LineMarkerStyleMap KDChartParams::_lineMarkerStyles; + + Stores the styles of the line makers + */ + +/** + \var uint KDChartParams::_maxDatasetLineMarkerStyle; + + Stores the highest dataset number for which a line marker has been + defined. Note that if you define a value for a dataset but not for a + dataset with a lower number (and there is neither a default value), the + line marker for that dataset with the lower number will be undefined. + */ + +/** + \var QSize KDChartParams::_lineMarkerSize; + + Stores the size of the line markers. + */ + + +/** + \var QColor KDChartParams::_lineColor; + + Stores the color of lines in line charts. + */ + +/** + \var int KDChartParams::_lineWidth; + + Stores the line width of lines in line charts. + */ + +/** + \var PenStyle KDChartParams::_lineStyle; + + Stores the line style of lines in line charts. + */ + +/** + \var AreaChartSubType KDChartParams::_areaChartSubType; + + Stores the area chart subtype. Only used when chartType() == + Area + */ + + +/** + \var AreaLocation KDChartParams::_areaLocation; + + Stores whether the area above or below the value points should + be filled. + */ + + +/// POLAR-specific +/** + \var PolarChartSubType KDChartParams::_polarChartSubType; + + Stores the polar chart subtype. Only used when chartType() == + Polar + */ + +/** + \var bool KDChartParams::_polarMarker; + + Stores whether polar markers should be drawn. Only used when + chartType() == Polar. + */ + +/** + \var PolarMarkerStyleMap KDChartParams::_polarMarkerStyles; + + Stores the styles of the markers in a polar char. + */ + +/** + \var uint KDChartParams::_maxDatasetPolarMarkerStyle; + + Stores the highest dataset number for which a polar marker has been + defined. Note that if you define a value for a dataset but not for a + dataset with a lower number (and there is neither a default value), the + polar marker for that dataset with the lower number will be undefined. + */ + +/** + \var QSize KDChartParams::_polarMarkerSize; + + Stores the size of the polar markers. + */ + + +/** + \var int KDChartParams::_polarLineWidth; + + Stores the line width of lines in polar charts. + */ + + +/** + \var int KDChartParams::_polarZeroDegreePos; + + Stores the zero degree position in polar charts. + */ + + +/** + \var bool KDChartParams::_polarRotateCircularLabels; + + Stores whether to rotate circular labels in polar charts. + */ + +/** + \struct KDChartParams::_polarDelimsAndLabelStruct KDChartParams.h + + Stores whether to show circular delimiters and/or labels + at a given position in polar charts. + */ + +/** + \var _polarDelimsAndLabelStruct KDChartParams::_polarDelimsAndLabels[ 1 + KDCHART_MAX_POLAR_DELIMS_AND_LABELS_POS ]; + + Stores where to show circular delimiters and labels in polar charts. + */ + + + +// PIES/RINGS +/** + \var bool KDChartParams::_explode; + + Stores whether pies or ring segments are drawn exploding. + */ + +/** + \var double KDChartParams::_explodeFactor; + + Stores the default explode factor of pie or ring segments. + */ + +/** + \var QMap KDChartParams::_explodeFactors; + + Stores the list of segment-specific explode factors of pie or + ring segments. + */ + +/** + \var QValueList KDChartParams::_explodeList; + + Stores the list of pies or ring segments to explode. + */ + +/** + \var bool KDChartParams::_threeDPies; + + Stores whether pies will have a 3D effect. + */ + +/** + \var int KDChartParams::_threeDPieHeight; + + Stores the height of the pie 3D effect. + */ + +/** + \var int KDChartParams::_pieStart; + + Stores the starting point of the pie circle. + */ + +/** + \var int KDChartParams::_ringStart; + + Stores the starting point of the ring circle. + */ + +/** + \var bool KDChartParams::_relativeRingThickness; + + Stores whether the ring thickness is relativ or constant. + */ + + +// HI-LO CHARTS + +/** + \var HiLoChartSubType KDChartParams::_hiLoChartSubType; + + Stores the HiLo subtype. + */ + +/** + \var bool KDChartParams::_hiLoChartPrintLowValues; + + Stores whether the low values + will be printed under their respective entries. + */ + + +/** + \var QFont KDChartParams::_hiLoChartLowValuesFont; + + Stores the font to be used for printing the low values. + */ + + +/** + \var bool KDChartParams::_hiLoChartLowValuesUseFontRelSize; + + Stores whether the font size to be used for printing the low + values is calculated dynamically. + */ + + +/** + \var int KDChartParams::_hiLoChartLowValuesFontRelSize; + + Stores the relative size (in per mille of the chart width) of + font size to be used for printing the low values. + */ + + +/** + \var QColor KDChartParams::_hiLoChartLowValuesColor; + + Stores the colour of the font size to be used for printing the + low values. + */ + +/** + \var bool KDChartParams::_hiLoChartPrintHighValues; + + Stores whether the high values will be printed under their + respective entries. + */ + + +/** + \var QFont KDChartParams::_hiLoChartHighValuesFont; + + Stores the font to be used for printing the high values. + */ + + +/** + \var bool KDChartParams::_hiLoChartHighValuesUseFontRelSize; + + Stores whether the font size to be used for printing the high + values is calculated dynamically. + */ + + +/** + \var int KDChartParams::_hiLoChartHighValuesFontRelSize; + + Stores the relative size (in per mille of the chart width) of + font size to be used for printing the high values. + */ + + +/** + \var QColor KDChartParams::_hiLoChartHighValuesColor; + + Stores the colour of the font size to be used for printing the + high values. + */ + +/** + \var bool KDChartParams::_hiLoChartPrintOpenValues; + + Stores whether the open values + will be printed under their respective entries. + */ + + +/** + \var QFont KDChartParams::_hiLoChartOpenValuesFont; + + Stores the font to be used for printing the open values. + */ + + +/** + \var bool KDChartParams::_hiLoChartOpenValuesUseFontRelSize; + + Stores whether the font size to be used for printing the open + values is calculated dynamically. + */ + + +/** + \var int KDChartParams::_hiLoChartOpenValuesFontRelSize; + + Stores the relative size (in per mille of the chart width) of + font size to be used for printing the open values. + */ + + +/** + \var QColor KDChartParams::_hiLoChartOpenValuesColor; + + Stores the colour of the font size to be used for printing the + open values. + */ + +/** + \var bool KDChartParams::_hiLoChartPrintCloseValues; + + Stores whether the close values will be printed under their + respective entries. + */ + + +/** + \var QFont KDChartParams::_hiLoChartCloseValuesFont; + + Stores the font to be used for printing the close values. + */ + + +/** + \var bool KDChartParams::_hiLoChartCloseValuesUseFontRelSize; + + Stores whether the font size to be used for printing the close + values is calculated dynamically. + */ + + +/** + \var int KDChartParams::_hiLoChartCloseValuesFontRelSize; + + Stores the relative size (in per mille of the chart width) of + font size to be used for printing the close values. + */ + + +/** + \var QColor KDChartParams::_hiLoChartCloseValuesColor; + + Stores the colour of the font size to be used for printing the + close values. + */ + + +/** + \var BWChartSubType KDChartParams::_BWChartSubType; + + Stores the Box And Whisker subtype. + */ + +/** + \struct BWChartStatistics KDChartParams.h + + Stores the statistical data for a box-and-whisker chart + */ + +/** + \var BWChartStatistics KDChartParams::_BWChartStatistics[ BWStatValOffEndValue ]; + + Stores whether and how the statistical data + will be printed near the drawing. + */ + +/** + \var double KDChartParams::_BWChartFenceUpperInner; + \var double KDChartParams::_BWChartFenceLowerInner; + \var double KDChartParams::_BWChartFenceUpperOuter; + \var double KDChartParams::_BWChartFenceLowerOuter; + + Stores the factors to be used to calculate the width of + the inner and outer fences. + */ + +/** + \var int KDChartParams::_BWChartOutValMarkerSize; + + Stores the size (or the negative size factor, resp.) of + the markers representing the outliers. + */ + + +/** + \var QBrush KDChartParams::_BWChartBrush; + + Stores the brush to be used. + */ + +/** + \var LegendPosition KDChartParams::_legendPosition; + + Stores the legend position. + */ + +/** + \var LegendSource KDChartParams::_legendSource; + + Stores the legend source. + */ + +/** + \var QMap < int, QString > KDChartParams::_legendText; + + Stores the manually set legend texts. + */ + + +/** + \var QColor KDChartParams::_legendTextColor; + + Stores the color for drawing the legend texts. + */ + +/** + \var QFont KDChartParams::_legendFont; + + Stores the font for drawing the legends. + */ + +/** + \var bool KDChartParams::_legendFontUseRelSize; + + Stores whether the size of the legend font is to be calculated + on a relative basis. + + \sa setLegendFontUseRelSize, setLegendFontRelSize + \sa setLegendFont + */ + +/** + \var int KDChartParams::_legendFontRelSize; + + Stores the per mille basis for calculating the relative + legend font size. + + \sa setLegendFontRelSize, setLegendFontUseRelSize + \sa setLegendFont + */ + + +/** + \var QString KDChartParams::_legendTitleText; + + Stores the legend title text. + */ + + +/** + \var QColor KDChartParams::_legendTitleTextColor; + + Stores the color for drawing the legend title. + */ + + +/** + \var QFont KDChartParams::_legendTitleFont; + + Stores the font for drawing the legend title. + */ + +/** + \var bool KDChartParams::_legendTitleFontUseRelSize; + + Stores whether the size of the legend title font is to be + calculated on a relative basis. + + \sa setLegendTitleFontUseRelSize, setLegendTitleFontRelSize + \sa setLegendTitleFont + */ + +/** + \var int KDChartParams::_legendTitleFontRelSize; + + Stores the per mille basis for calculating the relative + legend title font size. + + \sa setLegendTitleFontRelSize, setLegendTitleFontUseRelSize + \sa setLegendTitleFont + */ + + +/** + \var uint KDChartParams::_legendSpacing; + + Stores the number of pixels between the legend and the data display + */ + + +/** + \struct KDChartParams::AxisSettings KDChartParams.h + + Stores all the settings of all the axis \em plus one more + parameter set containing the build-in defauls axis settings. + */ + +/** + \var KDChartParams::_axisSettings + + Stores the settings for each of the possible thirteen axes + */ + + + +/** + \struct HdFtParams KDChartParams.h + + Stores all the settings of all the header sections + and all the footer sections. + */ + + + +/** + Retrieves the ID of the first KDChartCustomBox that is anchored at axis \c n. + + By default this box is used for the default axis title text: it is created + (or modified, resp.) by calling one of the axis title convenience functions + setAxisTitleColor or setAxisTitleFont or setAxisTitleFontUseRelSize or setAxisTitleFontRelSize. + + \note If you have specified another custom box manually that is anchored to this axis + before (or instead of, resp.) calling one of the convenience functions mentioned above + your custom box will become the default axis title text box: you then can access/modify + its properties using these convenience functions. + + \return TRUE if a KDChartCustomBox was found that is anchored to axis \c n. + \param n the axis number, this could be KDChartAxisParams::AxisPosLeft or KDChartAxisParams::AxisPosBottom... + \param boxID will obtain the respective KDChartCustomBox's ID if return value is TRUE, otherwise the parameter's value remains unchanged. + \sa setAxisTitle, setAxisTitleColor, setAxisTitleFont, setAxisTitleFontUseRelSize, setAxisTitleFontRelSize + */ +bool KDChartParams::findFirstAxisCustomBoxID( uint n, uint& boxID ) const +{ + QIntDictIterator it( _customBoxDict ); + for( ; it.current(); ++it ){ + if( (*it).anchorArea() == KDChartEnums::AreaAxisBASE + n ){ + boxID = it.currentKey(); + return true; + } + } + return false; +} + +void KDChartParams::insertDefaultAxisTitleBox( uint n, + bool setTitle, const QString& axisTitle, + bool setColor, const QColor& axisTitleColor, + bool setFont, const QFont& axisTitleFont, + bool setFontUseRelSize, bool axisTitleFontUseRelSize, + bool setFontRelSize, int axisTitleFontRelSize ) +{ + bool bVert = false; + bool bHorz = false; + bool b3rd = false; + switch( KDChartAxisParams::basicAxisPos( n ) ){ + case KDChartAxisParams::AxisPosLeft: + case KDChartAxisParams::AxisPosRight: + case KDChartAxisParams::AxisPosLeft2: + case KDChartAxisParams::AxisPosRight2: + bVert = true; + break; + case KDChartAxisParams::AxisPosTop: + case KDChartAxisParams::AxisPosBottom: + case KDChartAxisParams::AxisPosTop2: + case KDChartAxisParams::AxisPosBottom2: + bHorz = true; + break; + default: + b3rd = true; + break; + } + const QFont defaultFont( "helvetica", 6, QFont::Normal, false ); + + // SGI IRIX: Compiling error. + // QString titleString( setTitle ? axisTitle : "

" ); + QString titleString; + if( setTitle ) + titleString = axisTitle; + else + titleString = "
"; + + + const QString stripTitleString( titleString.simplifyWhiteSpace().upper() ); + if( setTitle ){ + if( !stripTitleString.startsWith("" ) ) + titleString.prepend("
"); + if( !stripTitleString.endsWith("" ) ) + titleString.append("
"); + } + + KDChartTextPiece textPiece( titleString, setFont ? axisTitleFont : defaultFont ); + int fixedFontSize = textPiece.font().pointSize(); + if( -1 == fixedFontSize ) + fixedFontSize = textPiece.font().pixelSize(); + if( -1 == fixedFontSize ) + fixedFontSize = 15; + int relFontSize = setFontRelSize ? -axisTitleFontRelSize : -18; + + KDChartCustomBox customBox( bVert ? -90 : 0, + textPiece, + setFontUseRelSize + ? ( axisTitleFontUseRelSize ? relFontSize : fixedFontSize ) + : relFontSize, + true, + 0, 0, + 0, 0, + setColor ? axisTitleColor : Qt::darkBlue, + Qt::NoBrush, + KDChartEnums::AreaAxisBASE + n, + bVert ? KDChartEnums::PosCenterLeft : KDChartEnums::PosBottomCenter, bVert ? (Qt::AlignTop + Qt::AlignHCenter) : (Qt::AlignBottom + Qt::AlignHCenter), + 0,0,0, + bVert ? (Qt::AlignBottom + Qt::AlignRight) : (Qt::AlignTop + Qt::AlignHCenter), + false, n ); + + customBox.setParentAxisArea( n ); + const uint id = insertCustomBox( customBox ); + /*debugging Title box*/ + /* + setSimpleFrame( + KDChartEnums::AreaCustomBoxesBASE + + id, + 0,0, 0,0, + true, + true, + KDFrame::FrameFlat, + 1, + 0, + Qt::red, + QBrush( QColor ( 255,248,222 ) ) ); + */ +} + +/** + Specifies the default axis title text. + + \note This is a convenience function accessing the first KDChartCustomBox that is anchored at axis \c n. + + \param axisTitle the axis title text + \sa setAxisTitleColor,setAxisTitleFont,setAxisTitleFontUseRelSize, setAxisTitleFontRelSize + \sa axisTitle, axisTitleColor, axisTitleFont, axisTitleFontUseRelSize, axisTitleFontRelSize + */ +void KDChartParams::setAxisTitle( uint n, const QString& axisTitle ) +{ + bool bDone = false; + uint boxID; + if( findFirstAxisCustomBoxID( n, boxID ) ){ + KDChartCustomBox* box = (KDChartCustomBox*)customBox( boxID ); + if( box ){ + QString title = axisTitle; + const QString stripTitleString( title.simplifyWhiteSpace().upper() ); + if( !stripTitleString.startsWith("" ) ) + title.prepend("
"); + if( !stripTitleString.endsWith("" ) ) + title.append("
"); + + KDChartTextPiece textPiece( 0, title, + box->content().font() ); + + box->setContent( textPiece ); + //qDebug ("old Axis Title updated"); + bDone = true; + } + } + if( !bDone ){ + insertDefaultAxisTitleBox( n, + true, axisTitle, + false, QColor(), + false, QFont(), + false, false, + false, 0 ); + //qDebug("new Axis Title Box inserted"); + } + emit changed(); +} +/** + Returns the default axis title text + + \return the axis title text. + \sa setAxisTitle + */ +QString KDChartParams::axisTitle( uint n ) const +{ + uint boxID; + if( findFirstAxisCustomBoxID( n, boxID ) ){ + const KDChartCustomBox* box = customBox( boxID ); + if( box ) + return box->content().text(); + } + return QString(); +} + +/** + Specifies the color of the default axis title text. + + \param axisTitleColor the color of the axis title text + \sa setAxisTitle, setAxisTitleFont,setAxisTitleFontUseRelSize, setAxisTitleFontRelSize + \sa axisTitle, axisTitleColor, axisTitleFont, axisTitleFontUseRelSize, axisTitleFontRelSize + */ +void KDChartParams::setAxisTitleColor( uint n, QColor axisTitleColor ) +{ + bool bDone = false; + uint boxID; + if( findFirstAxisCustomBoxID( n, boxID ) ){ + KDChartCustomBox* box = (KDChartCustomBox*)customBox( boxID ); + if( box ){ + box->setColor( axisTitleColor ); + bDone = true; + } + } + if( !bDone ) + insertDefaultAxisTitleBox( n, + false, QString(), + true, axisTitleColor, + false, QFont(), + false, false, + false, 0 ); + emit changed(); +} +/** + Returns the color of the default axis title text + + \return the color of the axis title text. + \sa setAxisTitleColor + */ +QColor KDChartParams::axisTitleColor( uint n ) const +{ + uint boxID; + if( findFirstAxisCustomBoxID( n, boxID ) ){ + const KDChartCustomBox* box = customBox( boxID ); + if( box ) + return box->color(); + } + return Qt::darkBlue; +} + +/** + Specifies the font and the size of the default axis title text. + + \param axisTitleFont the font of the axis title text + \param useFontSize flag indicating whether the font's size is to be used + \param axisTitleFontRelSize the size to be used if \c useFontSize is false, this is interpreted as per mil value of the printable area size + \sa setAxisTitle, setAxisTitleColor,setAxisTitleFontUseRelSize, setAxisTitleFontRelSize + \sa axisTitle, axisTitleColor, axisTitleFont, axisTitleFontUseRelSize, axisTitleFontRelSize + */ +void KDChartParams::setAxisTitleFont( uint n, + QFont axisTitleFont ) +{ + bool bDone = false; + uint boxID; + if( findFirstAxisCustomBoxID( n, boxID ) ){ + KDChartCustomBox* box = (KDChartCustomBox*)customBox( boxID ); + if( box ){ + KDChartTextPiece textPiece( 0, box->content().text(), + axisTitleFont ); + box->setContent( textPiece ); + bDone = true; + } + } + if( !bDone ) + insertDefaultAxisTitleBox( n, + false, QString(), + false, QColor(), + true, axisTitleFont, + false, false, + false, 0 ); + emit changed(); +} + +/** + Specifies the font and the size of the default axis title text. + \param axisTitleFont the font of the axis title text - by default the font will be relative + \param useFixedFontSize flag indicating whether the font's size is to be used as fixed or calculated as per mil value. + \param axisTitleFontRelSize the size to be used if \c useFixedFontSize is false, this is interpreted as per mil value of the printable area size + \sa setAxisTitle, setAxisTitleColor, setAxisTitleFont, setAxisTitleFontUseRelSize, setAxisTitleFontRelSize + \sa axisTitle, axisTitleColor, axisTitleFont, axisTitleFontUseRelSize, axisTitleFontRelSize + */ + +void KDChartParams::setAxisTitleFont( uint n, + QFont axisTitleFont, + bool useFixedFontSize ) +{ + + bool bDone = false; + uint boxID; + if( findFirstAxisCustomBoxID( n, boxID ) ){ + KDChartCustomBox* box = (KDChartCustomBox*)customBox( boxID ); + if( box ){ + KDChartTextPiece textPiece( 0, box->content().text(), + axisTitleFont ); + int fixedFontSize = textPiece.font().pointSize(); + setAxisTitleFontRelSize( n, fixedFontSize ); + box->setContent( textPiece ); + bDone = true; + } + } + if( !bDone ) + insertDefaultAxisTitleBox( n, + false, QString(), + false, QColor(), + true, axisTitleFont, + false, false, + false, 0 ); + + emit changed(); + + if ( useFixedFontSize ) + setAxisTitleFontUseRelSize( n, false); + +} + + +/** + Returns the font of the default axis title text. + + \return the axis title's font. + \sa setAxisTitleFont + */ +QFont KDChartParams::axisTitleFont( uint n ) const +{ + uint boxID; + if( findFirstAxisCustomBoxID( n, boxID ) ){ + const KDChartCustomBox* box = customBox( boxID ); + if( box ) + return box->content().font(); + } + return QFont( "helvetica", 6, QFont::Normal, false ); +} + +/** + Specifies whether the fixed size of the the default axis title text's font. + + \param axisTitleFontUseRelSize flag indicating whether the font's size is to be used or the size specified via setAxisTitleFontRelSize. + \sa setAxisTitle, setAxisTitleColor,setAxisTitleFont, setAxisTitleFontRelSize + \sa axisTitle, axisTitleColor, axisTitleFont, axisTitleFontUseRelSize, axisTitleFontRelSize + */ +void KDChartParams::setAxisTitleFontUseRelSize( uint n, + bool axisTitleFontUseRelSize ) +{ + bool bDone = false; + uint boxID; + if( findFirstAxisCustomBoxID( n, boxID ) ){ + KDChartCustomBox* box = (KDChartCustomBox*)customBox( boxID ); + if( box ){ + if ( !axisTitleFontUseRelSize ) { + if ( box->fontSize() < 0 ) + box->setFontSize( -(box->fontSize()), true ); + } else { + if( 0 <= box->fontSize() ) { + box->setFontSize( -(box->fontSize()), true ); + } else + box->setFontSize( box->fontSize(), true); + } + bDone = true; + } + } + if( !bDone ) + insertDefaultAxisTitleBox( n, + false, QString(), + false, QColor(), + false, QFont(), + true, axisTitleFontUseRelSize, + false, 0 ); + emit changed(); +} +/** + Returns whether the fix font size is used for the default axis title text. + + \return whether the fix axis title font size is used. + \sa setAxisTitleFontUseRelSize + */ +bool KDChartParams::axisTitleFontUseRelSize( uint n ) const +{ + uint boxID; + if( findFirstAxisCustomBoxID( n, boxID ) ){ + const KDChartCustomBox* box = customBox( boxID ); + if( box ) + return ( 0 > box->fontSize() ); + } + return true; +} + +/** + Specifies whether a relative size to be used for the default axis title text instead of the fixed size of the font. + + Calling this function implicitely sets this axis's \c axisTitleFontUseRelSize flag to TRUE. + + \param axisTitleFontRelSize the size to be used, this is interpreted as per mil value of the printable area size. + \sa setAxisTitle, setAxisTitleColor,setAxisTitleFont, setAxisTitleFontUseRelSize + \sa axisTitle, axisTitleColor, axisTitleFont, axisTitleFontUseRelSize, axisTitleFontRelSize + */ +void KDChartParams::setAxisTitleFontRelSize( uint n, + int axisTitleFontRelSize ) +{ + bool bDone = false; + uint boxID; + if( findFirstAxisCustomBoxID( n, boxID ) ){ + KDChartCustomBox* box = (KDChartCustomBox*)customBox( boxID ); + if( box ){ + box->setFontSize( -axisTitleFontRelSize, true ); + bDone = true; + } + } + if( !bDone ) + insertDefaultAxisTitleBox( n, + false, QString(), + false, QColor(), + false, QFont(), + true, true, + true, axisTitleFontRelSize ); + emit changed(); +} +/** + Returns the relative size of the default axis title text, should + be ignored if \c axisTitleFontUseRelSize returns false. + + \return the axis title's relative font size. + \sa setAxisTitleFontRelSize + */ +int KDChartParams::axisTitleFontRelSize( uint n ) const +{ + uint boxID; + if( findFirstAxisCustomBoxID( n, boxID ) ){ + const KDChartCustomBox* box = customBox( boxID ); + if( box ){ + int i = box->fontSize(); + return (0 > i) ? -i : i; + } + } + return 18; +} -- cgit v1.2.1