KDChartParams.cpp

/*
   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 <KDChartParams.h>
#include <KDChartAxisParams.h>
#include <KDChartEnums.h>
#include <KDFrame.h>
#include <KDChartCustomBox.h>
#include <KDChartTextPiece.h>
#include <KDXMLTools.h>
#ifndef KDCHART_MASTER_CVS
#include "KDChartParams.moc"
#endif
 
class KDChartData;
 
//#include <tqdom.h>
 
//TQColor  KDChartParams::_internalPointer_DataValueAutoColor = TQColor( 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 TQColor defaultColor;
const TQColor & KDChartParams_AutoColor = defaultColor;
*/
 
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 );
    setOptimizeOutputForScreen( false );
    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<unsigned int>( -1 ) );
 
    _defaultFont = TQFont( "helvetica", 8, TQFont::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( TQt::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( TQt::SolidLine );
 
    // END GENERAL
 
 
    setDataArea(  TQRect( TQPoint(0,0), TQSize(0,0)) );
    setLegendArea(TQRect( TQPoint(0,0), TQSize(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( TQt::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( TQSize( 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( TQSize( -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( TQt::white );
 
    // LEGEND
    // Distance between legend and data.
    setLegendSpacing( 20 );
    // Position of the legend
    setLegendPosition( LegendRight );
    // Orientation of the legend
    setLegendOrientation( TQt::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( TQt::black );
    // legend font size is calculated dynamically, but ignore the font size
    setLegendFont( TQFont( "helvetica", 10, TQFont::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( TQt::black );
    // legend title font size is calculated dynamically, but ignore
    // the font size
    setLegendTitleFont( TQFont( "helvetica", 12, TQFont::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()
    TQFont defaultHdFtFont( "helvetica", 14, TQFont::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, TQt::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, TQt::AlignLeft | TQt::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, TQt::AlignTop | TQt::AlignBottom );
    setProperties(KDCHART_PROPSET_VERT_LINE, *tempPropSetA);
    // END PROPERTY SETS
}
 
 
KDChartParams::~KDChartParams()
{
    KDChartAutoColor::freeInstance();
    delete tempPropSetA;
    delete tempPropSetB;
}
 
 
// GENERAL
 
 
int KDChartParams::registerProperties( KDChartPropertySet& rSet )
{
    _propertySetList.setAutoDelete( true );
    rSet.mOwnID = _propertySetList.count();
    _propertySetList.insert( rSet.mOwnID, rSet.clone() );
    return rSet.mOwnID;
}
 
void KDChartParams::setProperties( int id, KDChartPropertySet& rSet )
{
    _propertySetList.setAutoDelete( true );
    rSet.mOwnID = id;
    _propertySetList.replace( rSet.mOwnID, rSet.clone() );
}
 
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 );
}
 
 
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;
}
 
 
KDChartPropertySet* KDChartParams::properties( int id )
{
    return _propertySetList.find( id );
}
 
 
bool KDChartParams::calculateProperties( int startId, KDChartPropertySet& rSet ) const
{
    KDChartPropertySet& startSet = *tempPropSetA;
    startSet.quickReset("");
 
    rSet.deepCopy( &startSet ); // reset all properties of rSet to the default !!
 
//tqDebug("in KDChartParams::calculateProperties():");
//tqDebug("   startId: %i",startId);
//tqDebug("   startSet: %s",startSet.name().latin1());
 
    bool bOk = properties(startId, startSet);
    if( bOk ){
        int          lineWidth;
        TQColor       lineColor;
        TQt::PenStyle lineStyle;
        bool         showMarker;
        uint         markerAlign;
        TQSize        markerSize;
        TQColor       markerColor;
        int          markerStyle;
        uint         extraLinesAlign;
        bool         extraLinesInFront;
        int          extraLinesLength;
        int          extraLinesWidth;
        TQColor       extraLinesColor;
        TQt::PenStyle extraLinesStyle;
        uint         extraMarkersAlign;
        TQSize        extraMarkersSize;
        TQColor       extraMarkersColor;
        int          extraMarkersStyle;
        bool         showBar;
        TQColor       barColor;
        TQBrush       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;
}
 
 
void KDChartParams::setPrintDataValues( bool active,
        uint chart,
        int divPow10,
        int digitsBehindComma,
        TQFont* font,
        uint size,
        const TQColor* 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 = TQFont( "times", 1, TQFont::Bold );
                              settings->_dataValuesUseFontRelSize = true;
                              settings->_dataValuesFontRelSize = 16;
                              settings->_dataValuesAutoColor            = false;  //  !!!
                              settings->_dataValuesColor = TQColor( TQt::darkBlue );
                              settings->_dataValuesBrush = TQBrush( TQt::NoBrush );
                              // for values below zero:
                              settings->_dataValuesAnchorNegativePosition = KDChartEnums::PosBottomRight;
                              settings->_dataValuesAnchorNegativeAlign    = TQt::AlignBottom + TQt::AlignRight;
                              settings->_dataValuesAnchorNegativeDeltaX   =  20;
                              settings->_dataValuesAnchorNegativeDeltaY   =  55;
                              settings->_dataValuesNegativeRotation       = 300;
                              // for values greater/equal zero:
                              settings->_dataValuesAnchorPositivePosition = KDChartEnums::PosTopLeft;
                              settings->_dataValuesAnchorPositiveAlign    = TQt::AlignTop + TQt::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 = TQFont( "times", 1, TQFont::Normal );
                               settings->_dataValuesUseFontRelSize = true;
                               settings->_dataValuesFontRelSize = 16;
                               settings->_dataValuesAutoColor            = false;  //  !!!
                               settings->_dataValuesColor = TQColor( TQt::darkBlue );
                               settings->_dataValuesBrush = TQBrush( TQt::NoBrush );
                               // for values below zero:
                               settings->_dataValuesAnchorNegativePosition = KDChartEnums::PosBottomCenter;
                               settings->_dataValuesAnchorNegativeAlign    = TQt::AlignTop + TQt::AlignHCenter;
                               settings->_dataValuesAnchorNegativeDeltaX   =   0;
                               settings->_dataValuesAnchorNegativeDeltaY   =   0;
                               settings->_dataValuesNegativeRotation       =   0;
                               // for values greater/equal zero:
                               settings->_dataValuesAnchorPositivePosition = KDChartEnums::PosTopCenter;
                               settings->_dataValuesAnchorPositiveAlign    = TQt::AlignBottom + TQt::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 = TQFont( "times", 1, TQFont::Bold );
                               settings->_dataValuesUseFontRelSize = true;
                               settings->_dataValuesFontRelSize = 21;
                               settings->_dataValuesAutoColor              = true;  //  !!!
                               settings->_dataValuesColor = TQColor( TQt::black );
                               settings->_dataValuesBrush = TQBrush( TQt::white );
 
                               bool bShowOutside = areaChartSubType() == AreaNormal;
                               // for values below zero:
                               settings->_dataValuesAnchorNegativePosition = KDChartEnums::PosBottomCenter;
                               settings->_dataValuesAnchorNegativeAlign    = TQt::AlignHCenter
                                                            + (bShowOutside ? TQt::AlignTop : TQt::AlignBottom);
                               settings->_dataValuesAnchorNegativeDeltaX   =   0;
                               settings->_dataValuesAnchorNegativeDeltaY   = bShowOutside ? 20 : -35;
                               settings->_dataValuesNegativeRotation       =   0;
                               // for values greater/equal zero:
                               settings->_dataValuesAnchorPositivePosition = KDChartEnums::PosTopCenter;
                               settings->_dataValuesAnchorPositiveAlign    = TQt::AlignHCenter
                                                            + (bShowOutside ? TQt::AlignBottom : TQt::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 = TQFont( "times", 1, TQFont::Bold );
                              settings->_dataValuesUseFontRelSize = true;
                              settings->_dataValuesFontRelSize = 25;
                              settings->_dataValuesAutoColor            = true;  //  !!!
                              settings->_dataValuesColor = TQColor( TQt::black );
                              settings->_dataValuesBrush = TQBrush( TQt::NoBrush );
                              // for values below zero:
                              settings->_dataValuesAnchorNegativePosition = KDChartEnums::PosTopCenter;
                              settings->_dataValuesAnchorNegativeAlign    = TQt::AlignTop + TQt::AlignHCenter;
                              settings->_dataValuesAnchorNegativeDeltaX   =  0;
                              settings->_dataValuesAnchorNegativeDeltaY   = 50;
                              settings->_dataValuesNegativeRotation       = KDCHART_TANGENTIAL_ROTATION;
                              // for values greater/equal zero:
                              settings->_dataValuesAnchorPositivePosition = KDChartEnums::PosTopCenter;
                              settings->_dataValuesAnchorPositiveAlign    = TQt::AlignTop + TQt::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 = TQFont( "times", 1, TQFont::Bold );
                               settings->_dataValuesUseFontRelSize = true;
                               settings->_dataValuesFontRelSize = 25;
                               settings->_dataValuesAutoColor            = true;  //  !!!
                               settings->_dataValuesColor = TQColor( TQt::black );
                               settings->_dataValuesBrush = TQBrush( TQt::NoBrush );
                               // for values below zero:
                               settings->_dataValuesAnchorNegativePosition = KDChartEnums::PosCenter;
                               settings->_dataValuesAnchorNegativeAlign    = TQt::AlignCenter;
                               settings->_dataValuesAnchorNegativeDeltaX   = 0;
                               settings->_dataValuesAnchorNegativeDeltaY   = 10;
                               settings->_dataValuesNegativeRotation       = KDCHART_TANGENTIAL_ROTATION;
                               // for values greater/equal zero:
                               settings->_dataValuesAnchorPositivePosition = KDChartEnums::PosCenter;
                               settings->_dataValuesAnchorPositiveAlign    = TQt::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 = TQFont( "times", 1, TQFont::Bold );
                                settings->_dataValuesUseFontRelSize = true;
                                settings->_dataValuesFontRelSize = 26;
                                settings->_dataValuesAutoColor   = polarMarker();  //  !!!
                                settings->_dataValuesColor = TQColor( TQt::black );
                                settings->_dataValuesBrush = TQBrush( TQt::NoBrush );
 
                                // for values below zero:
                                settings->_dataValuesAnchorNegativePosition = KDChartEnums::PosCenter;
                                settings->_dataValuesAnchorNegativeAlign    = TQt::AlignCenter;
                                settings->_dataValuesAnchorNegativeDeltaX   = 0;
                                settings->_dataValuesAnchorNegativeDeltaY   = 0;
                                settings->_dataValuesNegativeRotation       = 0;
                                // for values greater/equal zero:
                                settings->_dataValuesAnchorNegativePosition = KDChartEnums::PosCenter;
                                settings->_dataValuesAnchorNegativeAlign    = TQt::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: {
                             tqDebug( "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 = TQFont( "times", 1, TQFont::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 = TQColor( TQt::black );
            }
            else {
                settings->_dataValuesAutoColor = false;
                if ( 0 == color )
                    settings->_dataValuesColor
                        = TQColor( i ? TQt::darkBlue : TQt::black );
                else
                    settings->_dataValuesColor = *color;
            }
            settings->_dataValuesBrush = TQBrush(TQt::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();
}
 
 
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 = TQMAX( _maxDatasetSourceMode, --i );
        _setChartSourceModeWasUsed = true;
    } else if ( UnknownMode == mode && dataset == KDCHART_ALL_DATASETS ) {
        _dataSourceModeAndChart.clear();
        _setChartSourceModeWasUsed = false;
    }
 
    emit changed();
}
 
 
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;
}
 
 
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;
}
 
 
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( TQMIN(dsA2, dsB2) + 1 == TQMAX(dsA1, dsB1) ){
                    dataset  = TQMIN(dsA1, dsB1);
                    dataset2 = TQMAX(dsA2, dsB2);
                    res = true;
                }else{
                    tqDebug("ERROR in KDChartParams::findDatasets(): Datasets found are *not* a contiguous series.");
                }
            }else{
                dataset  = foundA ? dsA1 : dsB1;
                dataset2 = foundA ? dsA2 : dsB2;
                res = true;
            }
        }
    }
    return res;
}
 
 
void KDChartParams::setDataColor( uint dataset, TQColor color )
{
    TQColor shadow1;
    TQColor shadow2;
    calculateShadowColors( color, shadow1, shadow2 );
    _dataColors[        dataset ] = color;
    _dataColorsShadow1[ dataset ] = shadow1;
    _dataColorsShadow2[ dataset ] = shadow2;
    _maxDatasetColor = TQMAX( _maxDatasetColor, dataset );
 
    emit changed();
}
 
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 );
}
 
void KDChartParams::setDataRainbowColors()
{
    setDataColor(  0, TQColor(255,  0,196) );
    setDataColor(  1, TQColor(255,  0, 96) );
    setDataColor(  2, TQColor(255, 128,64) );
    setDataColor(  3, TQt::yellow );
    setDataColor(  4, TQt::green );
    setDataColor(  5, TQt::cyan );
    setDataColor(  6, TQColor( 96, 96,255) );
    setDataColor(  7, TQColor(160,  0,255) );
    for( int i=8; i<16; ++i )
        setDataColor( i, dataColor(i-8).light() );
}
 
void KDChartParams::setDataSubduedColors( bool ordered )
{
static const int NUM_SUBDUEDCOLORS = 18;
static const TQColor SUBDUEDCOLORS[ NUM_SUBDUEDCOLORS ] = {
    TQColor( 0xe0,0x7f,0x70 ),
    TQColor( 0xe2,0xa5,0x6f ),
    TQColor( 0xe0,0xc9,0x70 ),
    TQColor( 0xd1,0xe0,0x70 ),
    TQColor( 0xac,0xe0,0x70 ),
    TQColor( 0x86,0xe0,0x70 ),
    TQColor( 0x70,0xe0,0x7f ),
    TQColor( 0x70,0xe0,0xa4 ),
    TQColor( 0x70,0xe0,0xc9 ),
    TQColor( 0x70,0xd1,0xe0 ),
    TQColor( 0x70,0xac,0xe0 ),
    TQColor( 0x70,0x86,0xe0 ),
    TQColor( 0x7f,0x70,0xe0 ),
    TQColor( 0xa4,0x70,0xe0 ),
    TQColor( 0xc9,0x70,0xe0 ),
    TQColor( 0xe0,0x70,0xd1 ),
    TQColor( 0xe0,0x70,0xac ),
    TQColor( 0xe0,0x70,0x86 ),
};
    if( ordered )
        for(int i=0; i<NUM_SUBDUEDCOLORS; ++i)
            setDataColor( i, SUBDUEDCOLORS[i] );
    else{
        setDataColor( 0, SUBDUEDCOLORS[ 0] );
        setDataColor( 1, SUBDUEDCOLORS[ 5] );
        setDataColor( 2, SUBDUEDCOLORS[10] );
        setDataColor( 3, SUBDUEDCOLORS[15] );
        setDataColor( 4, SUBDUEDCOLORS[ 2] );
        setDataColor( 5, SUBDUEDCOLORS[ 7] );
        setDataColor( 6, SUBDUEDCOLORS[12] );
        setDataColor( 7, SUBDUEDCOLORS[17] );
        setDataColor( 8, SUBDUEDCOLORS[ 4] );
        setDataColor( 9, SUBDUEDCOLORS[ 9] );
        setDataColor(10, SUBDUEDCOLORS[14] );
        setDataColor(11, SUBDUEDCOLORS[ 1] );
        setDataColor(12, SUBDUEDCOLORS[ 6] );
        setDataColor(13, SUBDUEDCOLORS[11] );
        setDataColor(14, SUBDUEDCOLORS[16] );
        setDataColor(15, SUBDUEDCOLORS[ 3] );
        setDataColor(16, SUBDUEDCOLORS[ 8] );
        setDataColor(17, SUBDUEDCOLORS[13] );
    }
}
 
 
void KDChartParams::calculateShadowColors( TQColor color,
                                           TQColor& shadow1,
                                           TQColor& shadow2 ) const
{
    if ( !color.isValid() ) { // no fill color
        shadow1 = TQColor();
        shadow2 = TQColor();
    } else {
        int hue, saturation, value;
        color.hsv( &hue, &saturation, &value );
        double v = value;
        v = v * 2.0 / 3.0 * shadowBrightnessFactor();
        if ( 255.0 < v )
            v = 255.0;
        else if ( 1.0 > 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 ) );
    }
}
 
 
TQColor KDChartParams::dataColor( uint dataset ) const
{
    uint index = dataset % (_maxDatasetColor+1);
    if( _dataColors.find( index ) != _dataColors.end() )
        return _dataColors[ index ];
    else
        return TQColor(); // documentation says undefined
}
 
 
TQString KDChartParams::dataRegionFrameAreaName( uint dataRow,
                             uint dataCol,
                             uint data3rd )
{
    return TQString( "%1/%2/%3/%4" )
            .arg( KDChartEnums::AreaChartDataRegion, 5 )
            .arg( dataRow, 5 )
            .arg( dataCol, 5 )
            .arg( data3rd, 5 );
}
 
 
void KDChartParams::recomputeShadowColors()
{
    // Simply reassign the available colors; this will trigger
    // recomputation of the shadow colors.
    for( TQMap<uint,TQColor>::Iterator it = _dataColors.begin();
            it != _dataColors.end(); ++it ) {
        setDataColor( it.key(), it.data() );
    }
}
 
 
 
 
TQColor KDChartParams::dataShadow1Color( uint dataset ) const
{
    uint index = dataset % _maxDatasetColor;
    if ( _threeDShadowColors )
        if( _dataColorsShadow1.find( index ) != _dataColorsShadow1.end() )
            return _dataColorsShadow1[ index ];
        else
            return TQColor(); // documentation says undefined
    else
        if( _dataColors.find( index ) != _dataColors.end() )
            return _dataColors[ index ];
        else
            return TQColor(); // documentation says undefined
}
 
 
TQColor KDChartParams::dataShadow2Color( uint dataset ) const
{
    uint index = dataset % _maxDatasetColor;
    if ( _threeDShadowColors )
        if( _dataColorsShadow2.find( index ) != _dataColorsShadow2.end() )
            return _dataColorsShadow2[ index ];
        else
            return TQColor(); // documentation says undefined
    else
        if( _dataColors.find( index ) != _dataColors.end() )
            return _dataColors[ index ];
        else
            return TQColor(); // documentation says undefined
}
 
 
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: {
                         tqDebug( "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,
                               TQFont( "helvetica", 1, TQFont::Bold ),
                               -30,
                               TQt::darkBlue );
            setAxisLabelsVisible( KDChartAxisParams::AxisPosCircular, true );
            setAxisLabelsFont( KDChartAxisParams::AxisPosCircular,
                               TQFont( "helvetica", 1, TQFont::Bold ),
                               -22,
                               TQt::darkBlue );
            setPolarRotateCircularLabels( false );
            break;
        default: {
                     tqDebug( "IMPLEMENTATION ERROR: type missing in KDChartParams::setDefaultAxesTypes()" );
                     Q_ASSERT( !this );
                 }
    }
 
    emit changed();
}
 
 
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: {
                     tqDebug( "IMPLEMENTATION ERROR: type missing in KDChartParams::activateDefaultAxes()" );
                     Q_ASSERT( !this );
                 }
    }
}
 
 
 
 
 
 
 
 
void KDChartParams::setGlobalLeading( int left, int top, int right, int bottom )
{
    _globalLeadingLeft   = left;
    _globalLeadingTop    = top;
    _globalLeadingRight  = right;
    _globalLeadingBottom = bottom;
    emit changed();
}
 
 
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 TQString 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;
}
 
const KDChartParams::KDChartFrameSettings* KDChartParams::frameSettings( uint area,
                                                                         bool& bFound,
                                                                         int* pIterIdx ) const
{
    if( pIterIdx )
        *pIterIdx = 0;
    const TQString key( TQString( "%1/-----/-----/-----" ).arg( area, 5 ) );
    KDChartFrameSettings* it = _areaDict.find( key );
    bFound = ( it != 0 );
    if( bFound )
        return it;
    else if( pIterIdx ){
        TQString keyStart( key.left(6) );
        TQDictIterator<KDChartFrameSettings> it2( _areaDict );
        for( ; it2.current(); ++it2 ){
            if( it2.currentKey().startsWith( keyStart ) ){
                bFound = true;
                return it2.current();
            }
            ++*pIterIdx;
        }
    }
    return &_noFrameSettings;
}
 
 
bool KDChartParams::removeFrame( uint area )
{
    return _areaDict.remove( TQString( "%1/-----/-----/-----" ).arg( area, 5 ) );
}
 
 
const KDChartParams::KDChartFrameSettings* KDChartParams::nextFrameSettings( bool& bFound,
                                                                             int* pIterIdx ) const
{
    bFound = false;
    if( pIterIdx ){
        int i=0;
        TQDictIterator<KDChartFrameSettings> it( _areaDict );
        for( ; it.current(); ++it ){
            if( *pIterIdx == i )
                break;
            ++i;
        }
        if( *pIterIdx == i ){
            TQString keyStart( it.currentKey().left(6) );
            ++it;
            for( ; it.current(); ++it ){
                ++*pIterIdx;
                if( it.currentKey().startsWith( keyStart ) ){
                    bFound = true;
                    return it.current();
                }
            }
        }
    }
    return &_noFrameSettings;
}
 
 
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;
}
 
 
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;
}
 
 
const KDChartCustomBox* KDChartParams::customBox( uint box ) const
{
    return _customBoxDict.find( box );
}
 
KDChartCustomBox* KDChartParams::customBoxRef( uint box )
{
    return _customBoxDict.find( box );
}
 
uint KDChartParams::maxCustomBoxIdx() const
{
    uint cnt( _customBoxDict.count() );
    if( cnt ) {
        int maxIndex = cnt-1;
        TQIntDictIterator<KDChartCustomBox> it( _customBoxDict );
        for( ; it.current(); ++it )
            if( it.currentKey() > maxIndex )
                maxIndex = it.currentKey();
        return maxIndex;
    }
    return 0;
}
 
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();
}
 
 
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();
}
 
 
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();
}
 
void KDChartParams::setDataValuesFont( TQFont* 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();
}
 
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();
}
 
void KDChartParams::setDataValuesColors( const TQColor* color,
                                         const TQBrush& 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();
}
 
 
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 TQColor* 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 = TQColor( TQt::black );
        }
        else {
            settings->_dataValuesAutoColor = false;
            if ( 0 == color )
                settings->_dataValuesColor
                    = TQColor( i ? TQt::darkBlue : TQt::black );
            else
                settings->_dataValuesColor = *color;
        }
        if ( 0 < chart )
            settings = &_printDataValuesSettings2;
    }
    emit changed();
}
 
 
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();
}
 
 
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 );
}
 
 
KDChartEnums::PositionFlag KDChartParams::dataValuesAnchorPosition( uint chart, bool negative ) const
{
    if ( negative )
        return chart ? _printDataValuesSettings2._dataValuesAnchorNegativePosition
            : _printDataValuesSettings._dataValuesAnchorNegativePosition;
    else
        return chart ? _printDataValuesSettings2._dataValuesAnchorPositivePosition
            : _printDataValuesSettings._dataValuesAnchorPositivePosition;
}
 
 
uint KDChartParams::dataValuesAnchorAlign( uint chart, bool negative ) const
{
    if ( negative )
        return chart ? _printDataValuesSettings2._dataValuesAnchorNegativeAlign
            : _printDataValuesSettings._dataValuesAnchorNegativeAlign;
    else
        return chart ? _printDataValuesSettings2._dataValuesAnchorPositiveAlign
            : _printDataValuesSettings._dataValuesAnchorPositiveAlign;
}
 
 
int KDChartParams::dataValuesAnchorDeltaX( uint chart, bool negative ) const
{
    if ( negative )
        return chart ? _printDataValuesSettings2._dataValuesAnchorNegativeDeltaX
            : _printDataValuesSettings._dataValuesAnchorNegativeDeltaX;
    else
        return chart ? _printDataValuesSettings2._dataValuesAnchorPositiveDeltaX
            : _printDataValuesSettings._dataValuesAnchorPositiveDeltaX;
}
 
 
int KDChartParams::dataValuesAnchorDeltaY( uint chart, bool negative ) const
{
    if ( negative )
        return chart ? _printDataValuesSettings2._dataValuesAnchorNegativeDeltaY
            : _printDataValuesSettings._dataValuesAnchorNegativeDeltaY;
    else
        return chart ? _printDataValuesSettings2._dataValuesAnchorPositiveDeltaY
            : _printDataValuesSettings._dataValuesAnchorPositiveDeltaY;
}
 
 
int KDChartParams::dataValuesRotation( uint chart, bool negative ) const
{
    if ( negative )
        return chart ? _printDataValuesSettings2._dataValuesNegativeRotation
            : _printDataValuesSettings._dataValuesNegativeRotation;
    else
        return chart ? _printDataValuesSettings2._dataValuesPositiveRotation
            : _printDataValuesSettings._dataValuesPositiveRotation;
}
 
 
// END GENERAL
 
// START BARCHART
 
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();
}
 
 
// END BARCHART
 
// START LINECHART
 
void KDChartParams::setLineMarkerStyle( uint dataset, LineMarkerStyle style )
{
    _lineMarkerStyles[ dataset ] = style;
    _maxDatasetLineMarkerStyle = TQMAX( dataset,
            _maxDatasetLineMarkerStyle );
    emit changed();
}
 
KDChartParams::LineMarkerStyle KDChartParams::lineMarkerStyle( uint dataset ) const
{
    if( _lineMarkerStyles.find( dataset ) != _lineMarkerStyles.end() )
        return _lineMarkerStyles[ dataset ];
    else
        return LineMarkerCircle; // default
}
 
 
 
 
void KDChartParams::setLineMarkerStyles( LineMarkerStyleMap map ) {
    _lineMarkerStyles = map;
    // update _maxDatasetLineMarkerStyle
    uint maxDataset = 0;
    for( LineMarkerStyleMap::ConstIterator it = _lineMarkerStyles.begin();
            it != _lineMarkerStyles.end(); ++it )
        maxDataset = TQMAX( maxDataset, it.key() );
    _maxDatasetLineMarkerStyle = maxDataset;
}
 
 
void KDChartParams::setLineStyle( TQt::PenStyle style, uint dataset )
{
    if( KDCHART_GLOBAL_LINE_STYLE == dataset )
        _lineStyle = style;
    else
        _datasetLineStyles[ dataset ] = style;
    emit changed();
}
 
TQt::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::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
 
   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 )
 
   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
 
   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.
   */
 
 
// END LINECHART
 
// START POLARCHART
 
 
void KDChartParams::setPolarMarkerStyle( uint dataset, PolarMarkerStyle style )
{
    _polarMarkerStyles[ dataset ] = style;
    _maxDatasetPolarMarkerStyle = TQMAX( dataset,
            _maxDatasetPolarMarkerStyle );
    emit changed();
}
 
KDChartParams::PolarMarkerStyle KDChartParams::polarMarkerStyle( uint dataset ) const
{
    if( _polarMarkerStyles.find( dataset ) != _polarMarkerStyles.end() )
        return _polarMarkerStyles[ dataset ];
    else
        return PolarMarkerCircle; // default
}
 
 
void KDChartParams::setPolarMarkerStyles( PolarMarkerStyleMap map ) {
    _polarMarkerStyles = map;
    // update _maxDatasetPolarMarkerStyle
    uint maxDataset = 0;
    for( PolarMarkerStyleMap::ConstIterator it = _polarMarkerStyles.begin();
            it != _polarMarkerStyles.end(); ++it )
        maxDataset = TQMAX( maxDataset, it.key() );
    _maxDatasetPolarMarkerStyle = maxDataset;
}
 
 
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;
    }
}
 
bool KDChartParams::polarDelimAtPos( KDChartEnums::PositionFlag pos ) const
{
    if( KDCHART_MAX_POLAR_DELIMS_AND_LABELS_POS >= pos )
        return _polarDelimsAndLabels[ pos ].showDelimiters;
    else
        return false;
}
 
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
 
// END RING/PIECHART
 
// START HILO CHART
 
void KDChartParams::setHiLoChartPrintLowValues( bool active, TQFont* font,
        int size, TQColor* color )
{
    _hiLoChartPrintLowValues = active;
    if ( font )
        _hiLoChartLowValuesFont = *font;
    else
        _hiLoChartLowValuesFont = _defaultFont;
    _hiLoChartLowValuesUseFontRelSize = ( 0 < size );
    _hiLoChartLowValuesFontRelSize = size;
    if ( 0 == color )
        _hiLoChartLowValuesColor = TQColor( 0, 0, 0 );
    else
        _hiLoChartLowValuesColor = *color;
    emit changed();
}
 
 
void KDChartParams::setHiLoChartPrintHighValues( bool active, TQFont* font,
        int size, TQColor* color )
{
    _hiLoChartPrintHighValues = active;
    if ( font )
        _hiLoChartHighValuesFont = *font;
    else
        _hiLoChartHighValuesFont = _defaultFont;
    _hiLoChartHighValuesUseFontRelSize = ( 0 < size );
    _hiLoChartHighValuesFontRelSize = size;
    if ( 0 == color )
        _hiLoChartHighValuesColor = TQColor( 0, 0, 0 );
    else
        _hiLoChartHighValuesColor = *color;
    emit changed();
}
 
 
void KDChartParams::setHiLoChartPrintOpenValues( bool active, TQFont* font,
        uint size, TQColor* color )
{
    _hiLoChartPrintOpenValues = active;
    if ( font )
        _hiLoChartOpenValuesFont = *font;
    else
        _hiLoChartOpenValuesFont = _defaultFont;
    _hiLoChartOpenValuesUseFontRelSize = ( 0 < size );
    _hiLoChartOpenValuesFontRelSize = size;
    if ( 0 == color )
        _hiLoChartOpenValuesColor = TQColor( 0, 0, 0 );
    else
        _hiLoChartOpenValuesColor = *color;
    emit changed();
}
 
 
void KDChartParams::setHiLoChartPrintCloseValues( bool active, TQFont* font,
        int size, TQColor* color )
{
    _hiLoChartPrintCloseValues = active;
    if ( font )
        _hiLoChartCloseValuesFont = *font;
    else
        _hiLoChartCloseValuesFont = _defaultFont;
    _hiLoChartCloseValuesUseFontRelSize = ( 0 < size );
    _hiLoChartCloseValuesFontRelSize = size;
    if ( 0 == color )
        _hiLoChartCloseValuesColor = TQColor( 0, 0, 0 );
    else
        _hiLoChartCloseValuesColor = *color;
    emit changed();
}
 
// END HILO CHART
 
// START BOX/WHISKER CHART
 
 
 
void KDChartParams::setBWChartFences( double upperInner, double lowerInner,
        double upperOuter, double lowerOuter )
{
    _BWChartFenceUpperInner = upperInner;
    _BWChartFenceLowerInner = lowerInner;
    _BWChartFenceUpperOuter = upperOuter;
    _BWChartFenceLowerOuter = lowerOuter;
}
void KDChartParams::bWChartFences( double& upperInner, double& lowerInner,
        double& upperOuter, double& lowerOuter ) const
{
    upperInner = _BWChartFenceUpperInner;
    lowerInner = _BWChartFenceLowerInner;
    upperOuter = _BWChartFenceUpperOuter;
    lowerOuter = _BWChartFenceLowerOuter;
}
 
 
void KDChartParams::setBWChartPrintStatistics( BWStatVal statValue,
        bool active,
        TQFont* font,
        int size,
        TQColor* color,
        TQBrush* 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 = TQColor( 0, 0, 0 );
        else
            _BWChartStatistics[ i ].color = *color;
        if ( 0 == brush )
            _BWChartStatistics[ i ].brush = TQBrush( TQt::white );
        else
            _BWChartStatistics[ i ].brush = *brush;
    }
    emit changed();
}
 
 
// END BOX/WHISKER CHART
 
// START LEGENDS
 
// END LEGENDS
 
// START AXES
 
void KDChartParams::setAxisShowGrid( uint n, bool axisShowGrid )
{
    if ( n < KDCHART_MAX_AXES ) {
        _axisSettings[ n ].params.setAxisShowGrid( axisShowGrid );
        emit changed();
    }
}
 
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;
}
 
void KDChartParams::setAxisDatasets( uint n, uint dataset,
        uint dataset2,
        uint chart )
{
    uint a1 = ( KDCHART_ALL_AXES == n )
        ? 0
        : TQMIN( n, KDCHART_MAX_AXES-1 );
    uint a2 = ( KDCHART_ALL_AXES == n )
        ? KDCHART_MAX_AXES-1
        : TQMIN( 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();
}
 
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;
}
 
 
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);
}
 
 
 
 
void KDChartParams::setAxisLabelsFont( uint n,
                                       TQFont axisLabelsFont,
                                       int axisLabelsFontSize,
                                       TQColor axisLabelsColor )
{
    if ( n < KDCHART_MAX_AXES ) {
        bool extraSize = (0 != axisLabelsFontSize);
        TQFont 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 );
    }
}
 
 
void KDChartParams::setAxisLabelStringParams( uint n,
        TQStringList*   axisLabelStringList,
        TQStringList*   axisShortLabelStringList,
        const TQString& valueStart,
        const TQString& valueEnd )
{
    if ( n < KDCHART_MAX_AXES ) {
        _axisSettings[ n ].params.setAxisLabelStringLists( axisLabelStringList,
                axisShortLabelStringList,
                valueStart,
                valueEnd );
        emit changed();
    }
}
 
 
void KDChartParams::setAxisParams( uint n,
        const KDChartAxisParams& axisParams )
{
    if ( n < KDCHART_MAX_AXES ) {
        _axisSettings[ n ].params = axisParams;
        emit changed();
    }
}
 
 
// END AXES
 
// START HEADERFOOTER
 
 
 
void KDChartParams::setHeaderFooterText( uint pos, const TQString& text )
{
    if ( HdFtPosEND >= pos ) {
        _hdFtParams[ pos ]._text = text;
        emit changed();
    }
}
 
 
TQString KDChartParams::headerFooterText( uint pos ) const
{
    if ( HdFtPosEND >= pos )
        return _hdFtParams[ pos ]._text;
    else
        return TQString();
}
 
 
 
const TQRect& KDChartParams::headerFooterRect( uint pos ) const
{
    if ( HdFtPosEND >= pos )
        return _hdFtParams[ pos ].rect();
    else
        return _noRect;
}
 
 
void KDChartParams::setHeaderFooterColor( uint pos, const TQColor color )
{
    if ( HdFtPosEND >= pos ) {
        _hdFtParams[ pos ]._color = color;
        emit changed();
    }
}
 
 
TQColor KDChartParams::headerFooterColor( uint pos ) const
{
    if ( HdFtPosEND >= pos )
        return _hdFtParams[ pos ]._color;
    else
        return TQColor( TQt::black );
}
 
 
void KDChartParams::setHeaderFooterFont( uint pos, const TQFont& font,
        bool fontUseRelSize,
        int fontRelSize )
{
    if ( HdFtPosEND >= pos ) {
        _hdFtParams[ pos ]._font = font;
        _hdFtParams[ pos ]._fontUseRelSize = fontUseRelSize;
        _hdFtParams[ pos ]._fontRelSize = fontRelSize;
        emit changed();
    }
}
 
 
TQFont KDChartParams::headerFooterFont( uint pos ) const
{
    if ( HdFtPosEND >= pos )
        return _hdFtParams[ pos ]._font;
    else
        return TQApplication::font();
}
 
 
bool KDChartParams::headerFooterFontUseRelSize( uint pos ) const
{
    if ( HdFtPosEND >= pos )
        return _hdFtParams[ pos ]._fontUseRelSize;
    else
        return false;
}
 
 
int KDChartParams::headerFooterFontRelSize( uint pos ) const
{
    if ( HdFtPosEND >= pos )
        return _hdFtParams[ pos ]._fontRelSize;
    else
        return 10;
}
 
 
// END HEADERFOOTER
 
 
 
// PRIVATE VARIABLES
 
// 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.
   */
 
 
 
// PIES/RINGS
// HI-LO CHARTS
 
bool KDChartParams::findFirstAxisCustomBoxID( uint n, uint& boxID ) const
{
    TQIntDictIterator<KDChartCustomBox> 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 TQString& axisTitle,
                                               bool setColor,          const TQColor&  axisTitleColor,
                                               bool setFont,           const TQFont&   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 TQFont defaultFont( "helvetica", 6, TQFont::Normal, false );
 
    // SGI IRIX: Compiling error.
    // TQString titleString( setTitle ? axisTitle : "<qt><center> </center></qt>" );
    TQString titleString;
    if( setTitle )
       titleString = axisTitle;
    else
       titleString = "<qt><center> </center></qt>";
 
 
    const TQString stripTitleString( titleString.simplifyWhiteSpace().upper() );
    if( setTitle ){
        if( !stripTitleString.startsWith("<QT>" ) )
            titleString.prepend("<qt><center>");
        if( !stripTitleString.endsWith("</QT>" ) )
            titleString.append("</center></qt>");
    }
 
    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 : TQt::darkBlue,
                                TQt::NoBrush,
                                KDChartEnums::AreaAxisBASE + n,
                                bVert ? KDChartEnums::PosCenterLeft        : KDChartEnums::PosBottomCenter,                                                         bVert ? (TQt::AlignTop + TQt::AlignHCenter)  : (TQt::AlignBottom + TQt::AlignHCenter),
                                0,0,0,
                                bVert ? (TQt::AlignBottom + TQt::AlignRight) : (TQt::AlignTop + TQt::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,
                TQt::red,
                TQBrush( TQColor ( 255,248,222 ) ) );
   */
}
 
void KDChartParams::setAxisTitle( uint n, const TQString& axisTitle )
{
    bool bDone = false;
    uint boxID;
    if( findFirstAxisCustomBoxID( n, boxID ) ){
        KDChartCustomBox* box = (KDChartCustomBox*)customBox( boxID );
        if( box ){
      TQString title = axisTitle;
      const TQString stripTitleString( title.simplifyWhiteSpace().upper() );
      if( !stripTitleString.startsWith("<QT>" ) )
        title.prepend("<qt><center>");
      if( !stripTitleString.endsWith("</QT>" ) )
        title.append("</center></qt>");
 
      KDChartTextPiece textPiece( 0, title,
                      box->content().font() );
 
      box->setContent( textPiece );
          //tqDebug ("old Axis Title updated");
      bDone = true;
        }
    }
    if( !bDone ){
        insertDefaultAxisTitleBox( n,
                                   true,  axisTitle,
                                   false, TQColor(),
                                   false, TQFont(),
                                   false, false,
                                   false, 0 );
        //tqDebug("new Axis Title Box inserted");
    }
    emit changed();
}
TQString KDChartParams::axisTitle( uint n ) const
{
    uint boxID;
    if( findFirstAxisCustomBoxID( n, boxID ) ){
        const KDChartCustomBox* box = customBox( boxID );
        if( box )
            return box->content().text();
    }
    return TQString();
}
 
void  KDChartParams::setAxisTitleColor( uint n, TQColor 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, TQString(),
                                   true,  axisTitleColor,
                                   false, TQFont(),
                                   false, false,
                                   false, 0 );
    emit changed();
}
TQColor KDChartParams::axisTitleColor( uint n ) const
{
    uint boxID;
    if( findFirstAxisCustomBoxID( n, boxID ) ){
        const KDChartCustomBox* box = customBox( boxID );
        if( box )
            return box->color();
    }
    return TQt::darkBlue;
}
 
void  KDChartParams::setAxisTitleFont( uint n,
                                       TQFont 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, TQString(),
                                   false, TQColor(),
                                   true,  axisTitleFont,
                                   false, false,
                                   false, 0 );
    emit changed();
}
 
void KDChartParams::setAxisTitleFont( uint n,
                      TQFont 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, TQString(),
                   false, TQColor(),
                   true,  axisTitleFont,
                   false, false,
                   false, 0 );
 
  emit changed();
 
  if ( useFixedFontSize )
    setAxisTitleFontUseRelSize( n, false);
 
}
 
 
TQFont KDChartParams::axisTitleFont( uint n ) const
{
    uint boxID;
    if( findFirstAxisCustomBoxID( n, boxID ) ){
        const KDChartCustomBox* box = customBox( boxID );
        if( box )
            return box->content().font();
    }
    return TQFont( "helvetica", 6, TQFont::Normal, false );
}
 
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, TQString(),
                                   false, TQColor(),
                                   false, TQFont(),
                                   true,  axisTitleFontUseRelSize,
                                   false, 0 );
    emit changed();
}
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;
}
 
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, TQString(),
                                   false, TQColor(),
                                   false, TQFont(),
                                   true,  true,
                                   true,  axisTitleFontRelSize );
    emit changed();
}
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;
}