kmymoney/libkdchart/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.
 **
 **********************************************************************/

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#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>

/**
  \class KDChartParams KDChartParams.h
  \brief Bundles the display parameters of a chart.

  Bundles all parameters of a chart including the type except the
  actual data displayed. Serializing an object of this type plus the
  data displayed is enough to be able to recreate the chart later.
  */



//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;
*/

/**
  Constructor. Defines default values.
  */
KDChartParams::KDChartParams()
{
    tempPropSetA = new KDChartPropertySet();
    tempPropSetB = new KDChartPropertySet();

    // GENERAL

    // Avoid Purify UMR
    _maxDatasetColor = 1;
    _maxDatasetSourceMode = 0;
    _setChartSourceModeWasUsed = false;

    _customBoxDictMayContainHoles = false;

    // Set the default font params flag for data value texts
    // but do *not* call setPrintDataValues() there since
    // this will be called internally by setChartType() below.
    setPrintDataValuesWithDefaultFontParams( KDCHART_ALL_CHARTS, false );
    _printDataValuesSettings._dataValuesShowInfinite  = true;
    _printDataValuesSettings2._dataValuesShowInfinite = true;

    setAllowOverlappingDataValueTexts( false );

    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
}


/**
  Destructor. Only defined to have it virtual.
  */
KDChartParams::~KDChartParams()
{
    KDChartAutoColor::freeInstance();
    delete tempPropSetA;
    delete tempPropSetB;
}


// GENERAL
/** @name General parameters.

  These methods set general parameters that apply to several or all chart types.
  */
//@{


/**
  Stores a new property set: data are stored by value so you may
  use your \c rSet instance for other purpose later...

  \returns The property set's ID to be used for later retrieving
  the property information by calling the properties() function
  or for assigning these properties to a data cell - either in the
  KDChartData constructor or by calling KDChartData::setPropertySet().

  \note The property set's ID may also be retrieved by calling
  <b>set.id()</b> after calling registerProperties( set )

  \note The predefined (build-in) property ids (like KDCHART_PROPSET_NORMAL_DATA
  and KDCHART_PROPSET_TRANSPARENT_DATA) must not be registered
  but should be used without further initialization.

  \sa KDCHART_PROPSET_NORMAL_DATA, KDCHART_PROPSET_TRANSPARENT_DATA
  \sa KDCHART_PROPSET_HORI_LINE, KDCHART_PROPSET_VERT_LINE
  \sa KDChartData::setPropertySet
  \sa removeProperties
  */
int KDChartParams::registerProperties( KDChartPropertySet& rSet )
{
    _propertySetList.setAutoDelete( true );
    rSet.mOwnID = _propertySetList.count();
    _propertySetList.insert( rSet.mOwnID, rSet.clone() );
    return rSet.mOwnID;
}

/**
  Overwrites a property set with a new property set.

  \note This function might also be used to initialy store
  a property set using a specific ID number, but note
  that another property set having the same number
  would be replaced by this property set automatically. Therefor
  in general it is better to use the registerProperties function
  to initially obtain a unique ID number for your new property set.

  \returns TRUE if the property set had been stored before,
  or FALSE if the set was now stored initially.

  \sa KDCHART_PROPSET_TRANSPARENT_DATA
  \sa KDCHART_PROPSET_HORI_LINE, KDCHART_PROPSET_VERT_LINE
  \sa KDChartData::setPropertySet
  \sa removeProperties
  */
void KDChartParams::setProperties( int id, KDChartPropertySet& rSet )
{
    _propertySetList.setAutoDelete( true );
    rSet.mOwnID = id;
    _propertySetList.replace( rSet.mOwnID, rSet.clone() );
}

/**
  Removes a property set from the registry
  that was registered via registerProperties().

  \note It is not possible to remove the build-in default property set:
  function calls using KDCHART_PROPSET_NORMAL_DATA as ID
  will be ignored.

  \returns TRUE if the property set was found and removed, or FALSE
  if the set was not found or KDCHART_PROPSET_NORMAL_DATA
  was specified as ID value.

  \sa registerProperties, setProperties
  */
bool KDChartParams::removeProperties( int id )
{
    _propertySetList.setAutoDelete( true );
    // Removing the default property set is not allowed!
    if( KDCHART_PROPSET_NORMAL_DATA == id )
        return false;
    return _propertySetList.remove( id );
}


/**
  Retrieves the values specified for a property set that
  was stored by registerProperties().

  Use this function to retrieve the exact specification
  of a property set.

  Don't use this function to retrieve the properties that are
  valid for a given data cell but use KDChartParams::calculateProperties()
  instead.

  \note This function does <b>not</b> return a pointer
  to the property set itself but a copy of the data
  stored therein. To change a stored property set
  you may use the setProperties() function.

  \returns TRUE if the property set was found, FALSE
  if it no property set was registred with this ID.

  \sa registerProperties, KDChartData::setPropertySet
  */
bool KDChartParams::properties( int id, KDChartPropertySet& rSet ) const
{
    const KDChartPropertySet* R = _propertySetList.find( id );
    const bool bFound = (0 != R);
    if( bFound )
        rSet.deepCopy( R );
    return bFound;
}


/**
  Retrieves the internal property set object that
  created when you called registerProperties().

  Use this function to access a property set for modifying it directly.

  Don't use this function to retrieve the properties that are
  valid for a given data cell but use KDChartParams::calculateProperties()
  instead.

  \note This function <b>does</b> return a pointer
  to the property set itself, so you can directly modify its contents.
  <b>However</b> you have to make sure NOT to delete this pointer,
  since KDChartParams is owning it, so it would try to free
  the pointer again later, most likely resulting in a program crash.
  To delete a stored property set you may use the removeProperties() function.

  \returns A pointer to the internally stored property set if the property set was found,
  Zero if no property set was registred with this ID.

  \sa registerProperties, removeProperties, KDChartData::setPropertySet
  */
KDChartPropertySet* KDChartParams::properties( int id )
{
    return _propertySetList.find( id );
}


/**
  Retrieves the values that correspond to a property set by
  reading this set's properties and obtaining other property
  set's values if necessary (according to ID numbers that might
  be stored in the property set).

  Use this function to retrieve the properties that are
  valid for a given data cell.

  Don't use this function to retrieve the exact specification
  of a property set but use KDChartParams::properties() instead.

  \returns TRUE if the property set was found, FALSE
  if it no property set was registred with this ID.

  \sa registerProperties, KDChartData::setPropertySet
  */
bool KDChartParams::calculateProperties( int startId, KDChartPropertySet& rSet ) const
{
    KDChartPropertySet& startSet = *tempPropSetA;
    startSet.quickReset("");

    rSet.deepCopy( &startSet ); // reset all properties of rSet to the default !!

//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;
}


/**
  \fn int KDChartParams::roundVal(double)

  Returns the parameter \c d rounded to the nearest integer.
  */



/**
  Specifies if and how a chart will print the data value texts near
  their respective entries.

  Data value texts will be printed immediately after drawing all of
  the chart data points (or bars, lines,...) but before drawing the
  legend and before drawing any custom boxes.  If more than one chart
  ist to be drawn (sharing the same data area) printing of the data
  text values will take place after drawing all of the last charts
  data points, this enables us to see the texts even if their
  respective data representations are covered by the second charts
  drawings. The same covering/colliding problem might occur with Area
  charts if one area is (partially) covering another area.  In such
  cases you might either want to specify an appropriate
  TextLayoutPolicy for getting a better looking result or specify an
  other text color for data value texts of the second chart since by
  default the first chart has black texts while the second chart
  shows its data value texts in dark blue color.

  \note Only used if chartType() is <b>neither HiLo nor
  BoxWhisker</b>. To specify printing of data values in a HiLo chart
  please use setHiLoChartPrintLowValues, setHiLoChartPrintHighValues,
  setHiLoChartPrintOpenValues, setHiLoChartPrintCloseValues. To
  specify printing of data values in a BoxWhisker chart please use
  setBWChartPrintStatistics.

  Calling <b>setPrintDataValues( false )</b> will <b>deactivate</b>
  printing of the values.

  Calling setPrintDataValuesWithDefaultFontParams( chart ) will
  <b>reset</b> the respective font size and colour and position
  parameters (but not the TQFont itself) and <b>activate</b> printing
  of the values for the \c chart speficied (or for all charts by
  using \c KDCHART_ALL_CHARTS, resp.).

  \param active specifies whether the value texts are to be printed or not.
  \param chart The number of the chart: 0 for the first chart, 1 for
  the second chart in case there are two charts to be drawn sharing the
  same data area.  Use the special value KDCHART_ALL_CHARTS
  to specify that your settings are to be taken for both charts.
  \param divPow10 The power of 10 which the data value is to be divided by.
  A value of 2 means divide by 100, a value of  -3 means multiply by 1000,
  and 0 (by definition) would result in multiplying by 1.
  \param digitsBehindComma The number of digits to show behind the comma,
  to have this calculated automatically just use the default value
  KDCHART_DATA_VALUE_AUTO_DIGITS.
  \param font a Pointer to the font to be used, if zero the default data value
  texts font will be taken (this is a Times font since small Times digits are
  clearer than small Helvetica digits).

  Changing of one or more of <b>the following parameters</b>
  automatically de-activates all future font parameter adjustments
  that would otherwise take place after each call of setChartType (or
  setAdditionalChartType, resp.).  To re-enable this usefull feature
  you may call setPrintDataValuesWithDefaultFontParams at any time
  afterwards.

  \param size (in per mille of the chart width) the dynamic size of
  the font to be used. If this parameter is zero the size of the
  \c font is used instead - regardless of the size of the chart!
  You may use setPrintDataValuesFontRelSize to change this parameter setting
  without affecting the other ones.
  \param color the color to be used when printing the values.
  To have the color calculated automatically - useful when printing
  inside the bars (or pie slices, areas, ... resp.) - please use
  \c KDCHART_DATA_VALUE_AUTO_COLOR instead of a TQColor*.
  You may use setPrintDataValuesColor to change this parameter setting
  without affecting the other ones.

  The following parameters apply to values less than zero only:

  \param negativePosition The anchor position which the text is to be
aligned to.
\param negativeAlign The way how the text is to be aligned to the anchor.
This must be a reasonable combination of TQt::AlignmentFlags.
\param negativeDeltaX The X distance between the <b>anchor
point</b> -- specified by \c negativePosition (or \c
        positivePosition, resp.) -- and the internal <b>alignment point</b>
of the text -- specified by \c negativeAlign (or \c positiveAlign,
        resp.). <b>Note: </b> For better compatibility to the dynamic font
size this parameter is interpreted as being a per-cent value of the
used font height.  If greater 0, the X position is increased, if
less than 0, it is reduced. Actual font size and thus also this
delta value are calculated dynamically before painting based on the
size of the chart and the specification made via parameter \c size.

\param negativeDeltaY The Y distance between the <b>anchor
point</b> -- specified by \c negativePosition (or \c
        positivePosition, resp.) -- and the internal <b>alignment point</b>
of the text -- specified by \c negativeAlign (or \c positiveAlign,
        resp.).  <b>Note: </b> For better compatibility to the dynamic font
size this parameter is interpreted as being a per-cent value of the
used font height.  If greater 0, the Y position is increased, if
less than 0, it is reduced. Actual font size and thus also this
delta value are calculated dynamically before painting based on the
size of the chart and the specification made via parameter \c size.
\param negativeRotation The amount of degrees (using a circle of
        360 degrees) taken to rotate the text. Positive values rotate
clockwise, negative values rotate counter-clockwise.  There are two
special values that you might find usefull for Pie charts or for
Ring charts: \c KDCHART_SAGGITAL_ROTATION and \c
KDCHART_TANGENTIAL_ROTATION both leading to individual
calculation of appropriate rotation for each data value.  Rotation
will be performed around the internal <b>alignment point</b> of the
text -- specified by \c negativeAlign (or \c positiveAlign, resp.).

The following parameters apply to values greater than zero or equal zero:

\param positivePosition The anchor position which the text is to be
aligned to.
\param positiveAlign The way how the text is to be aligned to the anchor.
This must be a reasonable combination of TQt::AlignmentFlags.
\param negativeDeltaX The X distance between the <b>anchor
point</b> -- specified by \c negativePosition (or \c
        positivePosition, resp.) -- and the internal <b>alignment point</b>
of the text -- specified by \c negativeAlign (or \c positiveAlign,
        resp.).  <b>Note: </b> For better compatibility to the dynamic font
size this parameter is interpreted as being a per-cent value of the
used font height.  If greater 0, the X position is increased, if
less than 0, it is reduced. Actual font size and thus also this
delta value are calculated dynamically before painting based on the
size of the chart and the specification made via parameter \c size.
\param positiveDeltaY The Y distance between the <b>anchor
point</b> -- specified by \c negativePosition (or \c
        positivePosition, resp.) -- and the internal <b>alignment point</b>
of the text -- specified by \c negativeAlign (or \c positiveAlign,
        resp.).  <b>Note: </b> For better compatibility to the dynamic font
size this parameter is interpreted as being a per-cent value of the
used font height.  If greater 0, the Y position is increased, if
less than 0, it is reduced. Actual font size and thus also this
delta value are calculated dynamically before painting based on the
size of the chart and the specification made via parameter \c size.
\param positiveRotation The amount of degrees (using a circle of
        360 degrees) taken to rotate the text. Positive values rotate
clockwise, negative values rotate counter-clockwise.  There are two
special values that you might find usefull for Pie charts or for
Ring charts: \c KDCHART_SAGGITAL_ROTATION and \c
KDCHART_TANGENTIAL_ROTATION both leading to individual
calculation of appropriate rotation for each data value.  Rotation
will be performed around the internal <b>alignment point</b> of the
text -- specified by \c negativeAlign (or \c positiveAlign, resp.).

\param layoutPolicy The way to handle too narrow space conflicts:
what to do if a data text covers a neighboring data text (or a
        neighboring data area, resp.).

\sa printDataValues
\sa setPrintDataValuesWithDefaultFontParams, printDataValuesWithDefaultFontParams
\sa setPrintDataValuesFontRelSize, setPrintDataValuesColor
\sa dataValuesDivPow10
\sa dataValuesDigitsBehindComma
\sa dataValuesFontUseRelSize
\sa dataValuesFontRelSize
\sa dataValuesFontColor
\sa dataValuesAnchorPosition
\sa dataValuesAnchorAlign
\sa dataValuesAnchorDeltaX
\sa dataValuesAnchorDeltaY
\sa dataValuesRotation
\sa dataValuesLayoutPolicy
*/
void KDChartParams::setPrintDataValues( bool active,
        uint chart,
        int divPow10,
        int digitsBehindComma,
        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();
}


/**
  \enum KDChartParams::SourceMode

  The chart source mode.
  Use \c setChartSourceMode to specify if and how any data
  should be taken into account for a given chart.

  \sa setChartSourceMode, chartSourceMode, setAdditionalChartType
  */


/**
  Specifies the chart source mode of one or more datasets.
  Use this to specify if and how any data should be taken
  into account for a given chart. You may call this function
  multiple times to specify how the different datasets are to
  be used. Number of datasets is only limited by the data that
  you actually provide to the chart widget. Usage of this method
  is mandatory when specifying combinations of more than one
  chart (e.g. via \c setAdditionalChartType() ).

  \note If specifying <b>more than one dataset</b> for the very
  same chart and the same source mode make sure they form
  a contiguous <b>series</b>.<br>
  It is not possible to use dataset 0..3 as DataEntry, dataset
  4 as AxisLabel and again dataset 5..6 as DataEntry for the
  very same chart!<br>
  Of course you could specify 0..3 as DataEntry for chart 0
  while 5..6 would contain the data entries for chart 1
  when specifying a widget showing two charts.

  <b>Also note:</b><br>
  Whenever you use \c setChartSourceMode() make sure not to
  forget any of the datasets which you want to define: not
  specifying a dataset would result in it being ignored.<br>
  So the rule is: either don't call setChartSourceMode() at all
  or call it for each dataset!

  To quickly clear all such settings just might want to call
  <b>setChartSourceMode( UnknownMode, KDCHART_ALL_DATASETS );</b>
  without specifying a dataset number and without specifying
  a chart number.<br>
  However this KDCHART_ALL_DATASETS may only be used to
  <b>clear</b> SourceMode settings - but not for defining the
  SourceMode for all datasets - the above mentioned combination
  with <b>UnknownMode</b> is the only way how to use
  <b>KDCHART_ALL_DATASETS</b> here!

  <b>Examples:</b>

  \verbatim
  setChartSourceMode( DataEntry, 2 );
  \endverbatim
  This would specify a simple chart obtaining its values from dataset 2.

  \verbatim
  setChartSourceMode( DataEntry, 0, 0, 0 );
  setChartSourceMode( DataEntry, 3, 3, 1 );
  \endverbatim
  This would specify a two chart widget - the 1st obtaining its values
  from dataset 0 and the 2nd taking the values from dataset 3.

  \verbatim
  setChartSourceMode( LegendText,       1,  1, 0 );
  setChartSourceMode( AxisLabel,        2,  2, 0 );
  setChartSourceMode( DataEntry,        3,  6, 0 );
  setChartSourceMode( ExtraLinesAnchor, 7,  7, 0 );
  setChartSourceMode( LegendText,       8,  8, 1 );
  setChartSourceMode( AxisLabel,        9,  9, 1 );
  setChartSourceMode( DataEntry,       10, 13, 1 );
  \endverbatim
  This would specify a two chart widget - the 1st obtaining its values
  from datasets 3..6 and the 2nd taking the values from datasets 10..13.
  Their respective legends and axes would take their values from
  datasets 1 and 2 (or 8 and 9, resp.).
  Additionally the 1st chart would use dataset 7 to determine the
  horizontal (or vertical, resp.) position of any extra lines
  that might be specified by KDChartPropertySet IDs assigned to
  the cells in dataset 7.

  \note If source mode is ExtraLinesAnchor all cells
  of the respective datset will be ignored when the normal
  cell representations (e.g. Bars or Lines) are drawn - these
  cells will <em>only</em> be used as anchor points for any
  extra lines that are specified with these cell's property sets.

  When specifying \c ExtraLinesAnchor for more than one dataset
  of the same chart make sure they form a contiguous row
  <b>together</b> with the \c DataEntry dataset(s): e.g
  you may use datasets 3..8 for DataEntry cells and datasets
  9..10 for ExtraLinesAnchor cells.
  All datasets with mode DataEntry or ExtraLinesAnchor are taken
  into account for calculation of the axes ranges and delimiters.

  <P>

  \param mode the way how to use information stored in this dataset.
  \param dataset the dataset number to be used (or ignored, resp.).
  Use \c KDCHART_ALL_DATASETS to indicate that information given
  applies to all of the datasets.
  \param dataset2 a second dataset number to be taken into account
  (or ignored, resp.). Use this one together with the \dataset
param to specify a range of datasets.
\param chart the chart taking into account this dataset.
Use this parameter only if more than one chart is to be displayed.
By using KDCHART_ALL_CHARTS here you may specify that the dataset
(or the range of datasets, resp.) is to be taken into account for
all of the charts displayed.

\sa SourceMode, chartSourceMode, findDataset
\sa maxDatasetSourceMode, setAdditionalChartType
*/
void KDChartParams::setChartSourceMode( SourceMode mode,
        uint dataset,
        uint dataset2,
        uint chart )
{
    if ( KDCHART_NO_DATASET != dataset
            && KDCHART_ALL_DATASETS != dataset
            && KDCHART_ALL_DATASETS != dataset2 ) {
        uint i;
        uint last = ( KDCHART_NO_DATASET == dataset2 ) ? dataset : dataset2;
        for ( i = dataset; i <= last; ++i )
            _dataSourceModeAndChart[ i ] = ModeAndChart( mode, chart );
        _maxDatasetSourceMode = TQMAX( _maxDatasetSourceMode, --i );
        _setChartSourceModeWasUsed = true;
    } else if ( UnknownMode == mode && dataset == KDCHART_ALL_DATASETS ) {
        _dataSourceModeAndChart.clear();
        _setChartSourceModeWasUsed = false;
    }

    emit changed();
}


/**
  Retrieves usage information of a given dataset or a range of
  datasets.

  \note If you specify a range of datasets and not all of them
  share the same SourceMode the return value will be \c UnknownMode
  whereas in case of the dataset(s) not being used it will be \c DontUse.
  Accordingly if you provide a chart pointer and not all the
  datasets share the same chart the chart pointer will receive
  the value KDCHART_UNKNOWN_CHART.<br>

  <b>Also note:</b>
  If \c setChartSourceMode() was not used at all
  chartSourceMode() will return <b>DataEntry</b> no matter what
  dataset number is specified.

  <p>

  \param dataset the dataset number to be looked at.
  Use \c KDCHART_ALL_DATASETS to find out if all of the datasets share
  the very same SourceMode.
  \param dataset2 a second dataset number.
  Use this one together with the \dataset param to look at a range of
  datasets and find out if all of them share the very same SourceMode.
  \param chart If this parameter points to an int the method will
  provide you with the chart number that this dataset (or this range
  of datasets, resp.) is taken into account for.

  \sa SourceMode, setChartSourceMode, setAdditionalChartType
  \sa maxDatasetSourceMode, findDataset
  */
KDChartParams::SourceMode KDChartParams::chartSourceMode( uint dataset,
        uint dataset2,
        uint* pChart ) const
{
    uint chart = KDCHART_UNKNOWN_CHART;
    SourceMode mode = UnknownMode;

    if ( _setChartSourceModeWasUsed ) {
        if (    dataset <= _maxDatasetSourceMode
             && (    KDCHART_NO_DATASET == dataset2
                  || dataset2 <= _maxDatasetSourceMode ) ) {

            uint a, b;
            if ( KDCHART_ALL_DATASETS == dataset ) {
                a = 0;
                b = UINT_MAX;
            } else {
                a = dataset;
                b = KDCHART_NO_DATASET == dataset2 ? a : dataset2;
            }

            bool bStart = true;
            ModeAndChartMap::ConstIterator it;
            for( it = _dataSourceModeAndChart.find( a );
                 ( it != _dataSourceModeAndChart.end() ) && ( it.key() <= b );
                 ++it ){
                if ( bStart ) {
                    mode = it.data().mode();
                    chart = it.data().chart();
                    bStart = false;
                } else {
                    if ( mode != it.data().mode() )
                        mode = UnknownMode;
                    if ( chart != it.data().chart() )
                        chart = KDCHART_UNKNOWN_CHART;
                }
            }
        }
    } else {
        mode = DataEntry;
        chart = 0;
    }
    if ( pChart )
        * pChart = chart;
    return mode;
}


/**
  Retrieves the dataset number or a range of datasets
  being used with a given SourceMode for a given chart
  or KDCHART_NO_DATASET if no dataset was specified for
  that mode and that chart.

  \note If \c setChartSourceMode() was not used at all
  findDataset() will return true and set the dataset
  to KDCHART_ALL_DATASETS when called for SourceMode
  <b>DataEntry</b>. All other SourceModes will return false then.

  \return True if at least one dataset was found.

  \param mode the SourceMode to search for.
  \param dataset the dataset number found (or the first
  dataset number in case a series of datasets was found, resp.)
  \param dataset2 the dataset number found (or the last
  dataset number in case a series of datasets was found, resp.)
  <b>Hint:</b> You may give the same variable both for
  dataset and for dataset2, e.g. this makes sense in case you
  are sure that findDataset will find only one dataset anyway.
  \param chart the chart number that the dataset (or this range
  of datasets, resp.) must have been defined for. If this is missing
  findDataset assumes you are looking for datasets of the first chart.

  \sa findDatasets, SourceMode, setChartSourceMode, chartSourceMode
  \sa maxDatasetSourceMode, setAdditionalChartType
  */
bool KDChartParams::findDataset( SourceMode mode,
        uint& dataset,
        uint& dataset2,
        uint chart ) const
{
    bool res = false;
    dataset  = KDCHART_NO_DATASET;
    dataset2 = KDCHART_NO_DATASET;
    if ( _setChartSourceModeWasUsed ) {
        bool bStart = true;
        ModeAndChartMap::ConstIterator it;
        for ( it = _dataSourceModeAndChart.begin();
                it != _dataSourceModeAndChart.end(); ++it ) {
            if (    ( it.data().mode() == mode )
                    && (    ( KDCHART_ALL_CHARTS == chart )
                        || ( it.data().chart()  == chart ) ) ) {
                if ( bStart ) {
                    dataset = it.key();
                    bStart = false;
                }
                dataset2 = it.key();
                res = true;
            } else if ( !bStart )
                return res;
        }
    } else if ( DataEntry == mode ) {
        dataset = KDCHART_ALL_DATASETS;
        dataset2 = KDCHART_ALL_DATASETS;
        res = true;
    }
    return res;
}


/**
  Retrieves the dataset number or a range of datasets
  being used with one of two given SourceModes
  for a given chart or KDCHART_NO_DATASET
  if no dataset was specified for that mode and that chart.

  If \c setChartSourceMode() was not used at all
  findDataset() will return true and set the dataset
  to KDCHART_ALL_DATASETS when either \c modeA or \c modeB
  is <b>DataEntry</b>. All other SourceModes will return
  false then.

  \note If the found datasets do <em>not</em> form a
  <b>contiguous series</b> the return value will be false
  and the value of \c dataset will be KDCHART_NO_DATASET
  and a comment will be written to stderr
  (if KDChart was compiled in debug mode).

  \return True if at least one dataset was found.

  \param modeA one of the SourceModes to search for.
  \param modeB the other one of the two SourceModes to search for.
  \param dataset the dataset number found (or the first
  dataset number in case a series of datasets was found, resp.)
  \param dataset2 the dataset number found (or the last
  dataset number in case a series of datasets was found, resp.)
  <b>Hint:</b> You may give the same variable both for
  dataset and for dataset2, e.g. this makes sense in case you
  are sure that findDataset will find only one dataset anyway.
  \param chart the chart number that the dataset (or this range
  of datasets, resp.) must have been defined for. If this is missing
  findDataset assumes you are looking for datasets of the first chart.

  \sa findDataset, SourceMode, setChartSourceMode, chartSourceMode
  \sa maxDatasetSourceMode, setAdditionalChartType
  */
bool KDChartParams::findDatasets( SourceMode modeA,
                                  SourceMode modeB,
                                  uint& dataset,
                                  uint& dataset2,
                                  uint chart ) const
{
    bool res = false;
    dataset  = KDCHART_NO_DATASET;
    dataset2 = KDCHART_NO_DATASET;
    uint dsA1, dsA2, dsB1, dsB2;
    bool foundA = findDataset( modeA, dsA1, dsA2, chart );
    bool foundB = findDataset( modeB, dsB1, dsB2, chart );
    if( foundA || foundB ){
        if( dsA1 == KDCHART_ALL_DATASETS || dsB1 == KDCHART_ALL_DATASETS ){
            dataset  = KDCHART_ALL_DATASETS;
            dataset2 = KDCHART_ALL_DATASETS;
            res = true;
        }else{
            if( foundA && foundB ){
                if( 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;
}


/**
  Specifies a color for a dataset. Note that if you define a color for a
  dataset but not for a dataset with a lower number (and there is neither
  a default value), the color for that dataset with the lower number will
  be undefined. If you do not want any color, pass an invalid color
  (i.e. a default-constructed TQColor object). This is only useful
  for chart types that have an outline (like bars or pies),
  because you would not see anything otherwise.<br>
  In charts that can only display one dataset (like pies), the specified
  colors are used for the different values instead.

  \param dataset the number of the dataset (or value for pies and similar
  charts) for which the color is specified
  \param color the color to use for this dataset/value
  \sa setDataDefaultColors, setDataRainbowColors, setDataSubduedColors
  \sa dataColor, maxDataColor
  */
void KDChartParams::setDataColor( uint dataset, 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();
}

/**
  Specifies KD Chart's default colors for the datasets 0..11.

  This method may be usefull to re-set the colors after changing the
  colors of the datasets.

  \sa setDataColor, setDataRainbowColors, setDataSubduedColors
  \sa dataColor, maxDataColor
  */
void KDChartParams::setDataDefaultColors()
{
    setDataColor(  0, red );
    setDataColor(  1, green );
    setDataColor(  2, blue );
    setDataColor(  3, cyan );
    setDataColor(  4, magenta );
    setDataColor(  5, yellow );
    setDataColor(  6, darkRed );
    setDataColor(  7, darkGreen );
    setDataColor(  8, darkBlue );
    setDataColor(  9, darkCyan );
    setDataColor( 10, darkMagenta );
    setDataColor( 11, darkYellow );
}

/**
  Specifies a set of eight rainbow-like colors for the datasets 0..7
  and sets the lighter versions of this colors to datasets 8..15.

  This is a convenience method setting colors that look best on
  a dark gray or black background.

  \sa setDataColor, setDataDefaultColors, setDataSubduedColors
  \sa dataColor, maxDataColor
  */
void KDChartParams::setDataRainbowColors()
{
    setDataColor(  0, 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() );
}

/**
  Specifies a set of eighteen subdued colors for the datasets 0..17.

  This is a convenience method setting colors that is ideal for
  area charts since the dark data value texts can be easily
  read when printed onto such background colors.

  \param ordered if true all eighteen colors will be set according
  to their appearance in the color circle, if false they will be
  arranged in a logical order making it very easy ti distinguish
  two neighboring colors. Set this parameter to true if you want
  your neighboring colors look quite similiar, the default is false.

  \sa setDataColor, setDataDefaultColors, setDataRainbowColors
  \sa dataColor, maxDataColor
  */
void KDChartParams::setDataSubduedColors( bool ordered )
{
static const int NUM_SUBDUEDCOLORS = 18;
static const 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 ) );
    }
}


/**
  Returns the color for a dataset. If no color has been defined for this
  dataset and none for a higher dataset either, the number will be mapped
  to the range of defined colors. If no color has been defined for this
  dataset, but at least one for a higher dataset, the return value of
  this method is undefined.

  \param dataset the number of the dataset for which to return the color
  \return the color for this dataset
  \sa setDataColor, maxDataColor
  */
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 );
}


/**
  Recomputes the shadow colors by iterating over all configured
  data colors and reassigning the data colors with exactly the
  same values which in turn triggers computation of the shadow
  colors. Expensive if many data colors are set, but performance
  is OK for typical cases.
  */
void KDChartParams::recomputeShadowColors()
{
    // Simply reassign the available colors; this will trigger
    // recomputation of the shadow colors.
    for( TQMap<uint,TQColor>::Iterator it = _dataColors.begin();
            it != _dataColors.end(); ++it ) {
        setDataColor( it.key(), it.data() );
    }
}




/**
  Returns the first shadow color for a dataset. This is the color that
  is used to draw the top bars with 3D effects. It is somewhat
  darker than the original data color.  If no color has been defined for this
  dataset and none for a higher dataset either, the number will be mapped
  to the range of defined colors. If no color has been defined for this
  dataset, but at least one for a higher dataset, the return value of
  this method is undefined.

  \param dataset the number of the dataset for which to return the color
  \return the color for this dataset
  \sa setDataColor, maxDataColor, dataShadow2Color
  */
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
}


/**
  Returns the second shadow color for a dataset. This is the color that
  is used to draw the sides of bars with 3D effects. It is
  darker than the original data color.  If no color has been defined for this
  dataset and none for a higher dataset either, the number will be mapped
  to the range of defined colors. If no color has been defined for this
  dataset, but at least one for a higher dataset, the return value of
  this method is undefined.

  \param dataset the number of the dataset for which to return the color
  \return the color for this dataset
  \sa setDataColor, maxDataColor, dataShadow1Color
  */
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
}


/**
  Set the default axis types for all the axes the user might activate for this chart:
  \li Pie charts by default have no axes at all
  \li Bar/Line/Area charts may have up to 8 axes (up to 2 at each side of the chart)
  \li charts representing 3-dimensional data may have up to 12 axes

  \note This function also specifies the default way how to calculate
  the axis labels: abscissa starts with zero and counts by 1, ordinate
  is calculating the labels automatically based upon the values found in
  the associated dataset(s).
  */
void KDChartParams::setDefaultAxesTypes()
{
    // reset types of all axes
    uint i = 0;
    for ( i = 0; i < KDCHART_MAX_AXES; ++i )
        setAxisType( i, KDChartAxisParams::AxisTypeUnknown );

    // Note that abscissa axes should start labeling at the very
    // first position and end at the last position when drawing
    // area charts.
    // Bar charts and line charts look better with their abscissa labels
    // in the respective middle positions below each bar (or point, resp.)
    for ( i = KDChartAxisParams::AxisPosSTART;
            i <= KDChartAxisParams::AxisPosEND; ++i )
        switch ( i ) {
            // abscissa axes:
            case KDChartAxisParams::AxisPosBottom:
            case KDChartAxisParams::AxisPosTop:
            case KDChartAxisParams::AxisPosBottom2:
            case KDChartAxisParams::AxisPosTop2:
                setAxisLabelsTouchEdges( i, Area == chartType() );
                break;
                // ordinate axes:
            case KDChartAxisParams::AxisPosLeft:
            case KDChartAxisParams::AxisPosRight:
            case KDChartAxisParams::AxisPosLeft2:
            case KDChartAxisParams::AxisPosRight2:
                setAxisLabelsTouchEdges( i, true ); //Polar != chartType() );
                break;
                // additional axes for charts representing 3-dimensional data:
            case KDChartAxisParams::AxisPosLowerRightEdge:
            case KDChartAxisParams::AxisPosLowerLeftEdge:
            case KDChartAxisParams::AxisPosLowerRightEdge2:
            case KDChartAxisParams::AxisPosLowerLeftEdge2:
                setAxisLabelsTouchEdges( i, false );
                break;
            default: {
                         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();
}


/**
  activate the default axis types for this chart:
  \li Pie charts by default have no axes at all
  \li Bar/Line/Area by default have 2 axes: the abscissa and the ordinate
  \li charts representing 3-dimensional data by default have 3 axes
  */
void KDChartParams::activateDefaultAxes()
{
    // deactivate all axes: specifying KDCHART_NO_DATASET will
    //                      also remove their visability flag
    for ( uint i = 0; i < KDCHART_MAX_AXES; ++i )
        setAxisDatasets( i, KDCHART_NO_DATASET );

    switch ( chartType() ) {
        case NoType:
            break;
        case Bar:
        case Line:
        case Area:
            setAxisVisible( KDChartAxisParams::AxisPosBottom, true );
            setAxisDatasets( KDChartAxisParams::AxisPosBottom, KDCHART_ALL_DATASETS );
            setAxisVisible( KDChartAxisParams::AxisPosLeft, true );
            setAxisDatasets( KDChartAxisParams::AxisPosLeft, KDCHART_ALL_DATASETS );
            /* test:
               setAxisVisible( KDChartAxisParams::AxisPosTop,    true );
               setAxisDatasets(KDChartAxisParams::AxisPosTop,    KDCHART_ALL_DATASETS );
               setAxisVisible( KDChartAxisParams::AxisPosRight,  true );
               setAxisDatasets(KDChartAxisParams::AxisPosRight,  KDCHART_ALL_DATASETS );

               setAxisVisible( KDChartAxisParams::AxisPosBottom2, true );
               setAxisDatasets(KDChartAxisParams::AxisPosBottom2, KDCHART_ALL_DATASETS );
               setAxisVisible( KDChartAxisParams::AxisPosLeft2,   true );
               setAxisDatasets(KDChartAxisParams::AxisPosLeft2,   KDCHART_ALL_DATASETS );

               setAxisVisible( KDChartAxisParams::AxisPosTop2,    true );
               setAxisDatasets(KDChartAxisParams::AxisPosTop2,    KDCHART_ALL_DATASETS );
               setAxisVisible( KDChartAxisParams::AxisPosRight2,  true );
               setAxisDatasets(KDChartAxisParams::AxisPosRight2,  KDCHART_ALL_DATASETS );
               */
            break;
            // Code for charts representing 3-dimensional data.

            /*

            //   ( not active since there are no such charts yet )

            case KDChartParams::BarMatrix:
            setAxisVisible( KDChartAxisParams::AxisPosBottom,         true );
            setAxisDatasets(KDChartAxisParams::AxisPosBottom, KDCHART_ALL_DATASETS );
            setAxisVisible( KDChartAxisParams::AxisPosLeft,           true );
            setAxisDatasets(KDChartAxisParams::AxisPosLeft,   KDCHART_ALL_DATASETS );
            setAxisVisible( KDChartAxisParams::AxisPosLowerRightEdge, true );
            setAxisDatasets(KDChartAxisParams::AxisPosLowerRightEdge,
            KDCHART_ALL_DATASETS);
            break;
            */
        case KDChartParams::Pie:
        case KDChartParams::Ring:
        case KDChartParams::Polar:
            // by default there are no axes defined for pie, ring, and polar charts
            break;
        default: {
                     tqDebug( "IMPLEMENTATION ERROR: type missing in KDChartParams::activateDefaultAxes()" );
                     Q_ASSERT( !this );
                 }
    }
}








/**
  \fn KDChartParams::setOptimizeOutputForScreen(bool)

  Specify whether drawing should be optimized for (low resolution)
  screen output or whether other routines should be used to obtain
  best quality when using a printer.

  \note The default of this flag is TRUE, so make sure to deactivate
  it before painting your KDChart onto a TQPrinter device!

  \note This setting is NOT stored together with the other parameters,
  it is recommended to set the flag each time when the drawing targed
  (printer or screen, resp) is changed.

  \sa optimizeOutputForScreen
  */


/**
  \fn bool KDChartParams::optimizeOutputForScreen() const
  Returns whether drawing is optimized for (low resolution)
  screen output (this is the default) or whether other routines
  are used to obtain best quality when using a printer.

  \sa setOptimizeOutputForScreen
  */


/**
  Specifies the distance between the chart and the left border of the
  painter area.  If \c leading is a negative value it is interpreted
  as per-mille value of the painter area, the true offset will then
  be calculated dynamically at drawing time.

  \sa setGlobalLeading, setGlobalLeadingTop, setGlobalLeadingRight,
  setGlobalLeadingBottom
  \sa globalLeadingLeft, globalLeadingTop, globalLeadingRight,
  globalLeadingBottom
  */
void KDChartParams::setGlobalLeading( int left, int top, int right, int bottom )
{
    _globalLeadingLeft   = left;
    _globalLeadingTop    = top;
    _globalLeadingRight  = right;
    _globalLeadingBottom = bottom;
    emit changed();
}


/**
  \fn void KDChartParams::setGlobalLeadingLeft( int )

  Specifies the distance between the chart and the left border of the
  painter area.  If \c leading is a negative value it is interpreted
  as per-mille value of the painter area, the true offset will then
  be calculated dynamically at drawing time.

  \sa setGlobalLeading, setGlobalLeadingTop, setGlobalLeadingRight,
  setGlobalLeadingBottom
  \sa globalLeadingLeft, globalLeadingTop, globalLeadingRight,
  globalLeadingBottom
  */


/**
  \fn void KDChartParams::setGlobalLeadingTop( int )

  Specifies the distance between the chart and the upper border of
  the painter area. If \c leading is a negative value it is
  interpreted as per-mille value of the painter area, the true offset
  will then be calculated dynamically at drawing time.

  \sa setGlobalLeading, setGlobalLeadingLeft, setGlobalLeadingRight,
  setGlobalLeadingBottom
  \sa globalLeadingLeft, globalLeadingTop, globalLeadingRight,
  globalLeadingBottom
  */


/**
  \fn void KDChartParams::setGlobalLeadingRight( int )

  Specifies the distance between the chart and the right border
  of the painter area.  If \c leading is a negative value it is
  interpreted as per-mille value of the painter area, the true
  offset will then be calculated dynamically at drawing time.

  \sa setGlobalLeading, setGlobalLeadingLeft, setGlobalLeadingTop,
  setGlobalLeadingBottom
  \sa globalLeadingLeft, globalLeadingTop, globalLeadingRight,
  globalLeadingBottom
  */


/**
  \fn void KDChartParams::setGlobalLeadingBottom( int )

  Specifies the distance between the chart and the lower border of
  the painter area.  If \c leading is a negative value it is
  interpreted as per-mille value of the painter area, the true offset
  will then be calculated dynamically at drawing time.

  \sa setGlobalLeading, setGlobalLeadingLeft, setGlobalLeadingTop,
  setGlobalLeadingRight
  \sa globalLeadingLeft, globalLeadingTop, globalLeadingRight,
  globalLeadingBottom
  */


/**
  \fn int KDChartParams::globalLeadingLeft() const

  Return the distance between the chart and the left border of the
  painter area.  If \c leading is a negative value it is interpreted
  as per-mille value of the painter area, the true offset will then
  be calculated dynamically at drawing time.

  \sa setGlobalLeading, setGlobalLeadingLeft, setGlobalLeadingTop,
  setGlobalLeadingRight, setGlobalLeadingBottom
  \sa globalLeadingTop, globalLeadingRight, globalLeadingBottom
  */


/**
  \fn KDChartParams::globalLeadingTop() const

  Return the distance between the chart and the upper border of the
  painter area.  If \c leading is a negative value it is interpreted
  as per-mille value of the painter area, the true offset will then
  be calculated dynamically at drawing time.

  \sa setGlobalLeading, setGlobalLeadingLeft, setGlobalLeadingTop,
  setGlobalLeadingRight, setGlobalLeadingBottom
  \sa globalLeadingLeft, globalLeadingRight, globalLeadingBottom
  */


/**
  \fn KDChartParams::globalLeadingRight() const

  Return the distance between the chart and the right border of the
  painter area.  If \c leading is a negative value it is interpreted
  as per-mille value of the painter area, the true offset will then
  be calculated dynamically at drawing time.

  \sa setGlobalLeading, setGlobalLeadingLeft, setGlobalLeadingTop,
  setGlobalLeadingRight, setGlobalLeadingBottom
  \sa globalLeadingLeft, globalLeadingTop, globalLeadingBottom
  */


/**
  \fn int KDChartParams::globalLeadingBottom() const

  Return the distance between the chart and the lower border of the
  painter area.  If \c leading is a negative value it is interpreted
  as per-mille value of the painter area, the true offset will then
  be calculated dynamically at drawing time.

  \sa setGlobalLeading, setGlobalLeadingLeft, setGlobalLeadingTop,
  setGlobalLeadingRight, setGlobalLeadingBottom
  \sa globalLeadingLeft, globalLeadingTop, globalLeadingRight
  */


/**
  \fn void KDChartParams::setFrame( uint, const KDFrame&, int, int,
  int, int, bool, bool )

  \ifnot v200
  \deprecated Feature scheduled for future release, at present not implemented.
  \else
  Specify the frame settings to be used for one of the chart areas.

  The names and the meaning of the areas are explained with the enum
  AreaName.  The KDFrame class is explained in detail here: KDFrame
  <b>Note however:</b> The \c innerRect settings of this KDFrame will
  be ignored since position and size of this frame will be calculated
  dynamically based upon the AreaName!

  \param area The area to be surrounded by a frame.
  \param outerGap The distance between the frame and the surrounding
  parts of the chart.
  \param innerGap The distance between the frame and the inner area.
  \param addFrameWidthToLayout Specifies whether the inner area will
  shrink the area AND its frame will occupy the same space of the
  chart as the area would occupy if no frame were drawn. If false,
  the frame is drawn around the area without taking care not to
  override other content of the chart.

  \note An easier way to specify a frame setting is selecting a pre-defined
  setting using the setSimpleFrame methode.

  \sa setSimpleFrame, frameSettings, removeFrame
  \endif
  */

/**
  \fn void KDChartParams::setSimpleFrame( uint, int, int, int, int,
  bool, bool, KDFrame::SimpleFrame, int, int, TQPen, TQBrush, const
  TQPixmap*, KDFrame::BackPixmapMode, int, KDFrame::CornerName )

  Select a pre-defined frame setting to be used for one of the chart areas.

  \param area The area to be surrounded by a frame.
  \param outerGap The distance between the frame and the surrounding
  parts of the chart.
  \param innerGap The distance between the frame and the inner area.
  \if v200
  \param addFrameWidthToLayout Specifies whether the inner area will
  shrink the area AND its frame will occupy the same space of the
  chart as the area would occupy if no frame were drawn. If false,
  the frame is drawn around the area without taking care not to
  override other content of the chart.

  The parameters specifying the pre-defined frame settings are
  defined here: KDFrame::setSimpleFrame.
  \sa setFrame, frameSettings
  \else
  \param addFrameWidthToLayout For internal use - must be \c true.
  \param addFrameHeightToLayout For internal use - must be \c true.
  \param simpleFrame For internal use - must be \c KDFrame::FrameFlat.
  \param lineWidth For internal use - must be \c 1.
  \param midLineWidth For internal use - must be \c 0.
  \param pen The pen to be used for drawing the four frame border lines.
  \param background The brush to be used for painting the frame background.
  \param backPixmap The picture to be displayed as background image
  of the frame.
  \param backPixmapMode The way how backPixmap is to be modified to
  fill the frame, these are possible:
  \li \c KDFrame::PixCentered Image will not be scaled nor stretched
  but shown in original size.
  \li \c KDFrame::PixScaled Image will be scaled until it's height or
  it's width match the frame's height (or width, resp.) - whichever
  comes first - but image proportions will be preserved.
  \li \c KDFrame::PixStretched Image will be stretched to have the
  same height and the same width as the frame - normally this results
  in changing the original image proportions.
  \param shadowWidth For internal use - do not set this parameter or
  set it to \c 0.
  \param sunPos For internal use - do not set this parameter or set
  it to \c KDFrame::CornerTopLeft.
  \endif

  \sa removeFrame
  */


/**
  \fn void KDChartParams::setDataRegionFrame( uint, uint, uint, int, int, int, int,
  bool, bool, KDFrame::SimpleFrame, int, int, TQPen, TQBrush, const
  TQPixmap*, KDFrame::BackPixmapMode, int, KDFrame::CornerName )

  Select a pre-defined frame setting to be used for one of the data representations
  (e.g. to have the frame surrounding one of the bars in a Bar chart).

  \note KDChart currently supports specifying data frames without background only,
        it is not possible to draw a special background behind a data representation.

  \param dataRow The table row of the cell to be surrounded by a frame.
  \param dataCol The table column of the cell.
  \param data3rd The third table coordinate of the cell (parameter not used, its value will be ignored, set to 0, reserved for future use).
  \param innerGap The distance between the frame and the inner area.
  \if v200
  \param addFrameWidthToLayout Specifies whether the inner area will
  shrink the area AND its frame will occupy the same space of the
  chart as the area would occupy if no frame were drawn. If false,
  the frame is drawn around the area without taking care not to
  override other content of the chart.

  The parameters specifying the pre-defined frame settings are
  defined here: KDFrame::setSimpleFrame.
  \sa setFrame, frameSettings
  \else
  \param addFrameWidthToLayout For internal use - must be \c true.
  \param addFrameHeightToLayout For internal use - must be \c true.
  \param simpleFrame For internal use - must be \c KDFrame::FrameFlat.
  \param lineWidth For internal use - must be \c 1.
  \param midLineWidth For internal use - must be \c 0.
  \param pen The pen to be used for drawing the four frame border lines.
  \param shadowWidth For internal use - do not set this parameter or
  set it to \c 0.
  \param sunPos For internal use - do not set this parameter or set
  it to \c KDFrame::CornerTopLeft.
  \endif
  */


/**
  \fn bool KDChartParams::moveDataRegionFrame( uint, uint, uint, uint, uint, uint )

  Move a frame that was previously specified using setDataRegionFrame
  to another location: moves the frame from cell[ oldDataRow, oldDataCol ]
  to cell[ newDataRow, newDataCol ] without changing looking of the frame,
  or just removes the frame entirely.

  \param oldDataRow The table row of the frame to be removed.
  \param oldDataCol The table column of the frame to be removed.
  \param oldData3rd The third table coordinate of the old cell (parameter not used, its value will be ignored, set to 0, reserved for future use).
  \param newDataRow The table row of the cell to be framed instead, or KDCHART_NO_DATASET if the frame is to be removed
  without framing another cell then.
  \param newDataCol The table column of the cell to be framed instead.
  \param newData3rd The third table coordinate of the new cell (parameter not used, its value will be ignored, set to 0, reserved for future use).

  \note Using KDCHART_NO_DATASET for the newDataRow parameter will not
  result in returning FALSE because it is an allowed action: the frame is just removed then.

  \return TRUE if the frame could be moved or was removed; FALSE if either there was no frame around the old cell or the target cell does not exist.
  */
bool KDChartParams::moveDataRegionFrame( uint oldDataRow,
                             uint oldDataCol,
                             uint, // important: we ignore the data3rd parameter for now!
                             uint newDataRow,
                             uint newDataCol,
                             uint// important: we ignore the data3rd parameter for now!
                             )
{
    const 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;
}

/**
  \var KDChartParams::CustomBoxDict

  The type that stores the custom boxes in a chart.
  */

/**
  Return the frame settings of one of the chart areas.

  \sa nextFrameSettings, setSimpleFrame, setFrame, removeFrame
  */
const KDChartParams::KDChartFrameSettings* KDChartParams::frameSettings( uint area,
                                                                         bool& bFound,
                                                                         int* pIterIdx ) const
{
    if( pIterIdx )
        *pIterIdx = 0;
    const 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;
}


/**
  Remove the last frame, that was specified for this chart area.
  If you have more than one frame attached to the same area,
  make sure to call this method repeatedly, if you want
  to remove all of them.

  \note This method can be used to remove frames, that were specified
  via setFrame (or via setSimpleFrame, resp.), but if can not be used
  to remove frames, that were specified using setDataRegionFrame.

  \sa nextFrameSettings, setSimpleFrame, setFrame
  */
bool KDChartParams::removeFrame( uint area )
{
    return _areaDict.remove( TQString( "%1/-----/-----/-----" ).arg( area, 5 ) );
}


/**
  Return the next frame settings specified for the same area type
  as the frame that was retrieved by previous calls of \c frameSettings()
  or \c nextFrameSettings().

  \sa setDataRegionFrame, frameSettings
  */
const KDChartParams::KDChartFrameSettings* KDChartParams::nextFrameSettings( bool& bFound,
                                                                             int* pIterIdx ) const
{
    bFound = false;
    if( pIterIdx ){
        int i=0;
        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;
}


/**
  Add a new custom box to the list of boxes.
  To remove this box from the list lateron just call removeCustomBox
  with the index that was returned by insertCustomBox.

  \sa removeCustomBox, removeAllCustomBoxes, customBox, maxCustomBoxIdx
  */
uint KDChartParams::insertCustomBox( const KDChartCustomBox & box )
{
    _customBoxDict.setAutoDelete( true );
    uint newIdx;
    if( _customBoxDictMayContainHoles ){
        _customBoxDictMayContainHoles = false;
        const uint maxIndex = maxCustomBoxIdx();
        newIdx = 1 + maxIndex;
        for( uint idx = 0; idx <= maxIndex; ++idx ) {
            if( ! _customBoxDict.find( idx ) ) {
                newIdx = idx;
                _customBoxDictMayContainHoles = true; // we found a hole, so there might be more of them
                break;
            }
        }
    }else{
        newIdx = _customBoxDict.count();
    }
    _customBoxDict.insert( newIdx, box.clone() );
    emit changed();
    return newIdx;
}


/**
  Remove a custom box from the list of boxes.
  Please fill in the index parameter with the value
  that was returned by insertCustomBox.

  \note This method also removes the last frame, that was attached to this
  box (if any), so the only reason for calling removeFrame() manually would
  be, that you have specified more than one frame for this box.


  \sa removeAllCustomBoxes, insertCustomBox, customBox, maxCustomBoxIdx
  */
bool KDChartParams::removeCustomBox( const uint & idx )
{
    const bool bFound = _customBoxDict.remove( idx );
    if( bFound ){
        // also remove any frame, that was attached to this box
        removeFrame( KDChartEnums::AreaCustomBoxesBASE + idx );
    }
    _customBoxDictMayContainHoles = true;
    emit changed();
    return bFound;
}


/**
  \fn void KDChartParams::removeAllCustomBoxes()
  Remove all custom boxes from the list of boxes.

  \sa removeCustomBox, insertCustomBox, customBox, maxCustomBoxIdx
  */


/**
  Retrieve a const pointer to a custom box from the list.
  You may fill in the index parameter with the value
  that was returned by insertCustomBox, or you may use a numerical value,
  e.g. when iterating from zero up to maxCustomBoxIdx().

  \return Zero if the custom box has been removed by calling removeCustomBox.

  \sa insertCustomBox customBoxRef, removeCustomBox, removeAllCustomBoxes, maxCustomBoxIdx
  */
const KDChartCustomBox* KDChartParams::customBox( uint box ) const
{
    return _customBoxDict.find( box );
}

/**
  Retrieve a non-const pointer to a  custom box from the list.
  You may fill in the index parameter with the value
  that was returned by insertCustomBox, or you may use a numerical value,
  e.g. when iterating from zero up to maxCustomBoxIdx().

  \note The reference returned by this method may be used to directly
  modify the properties of the respective box.

  \return Zero if the custom box has been removed by calling removeCustomBox.

  \sa insertCustomBox customBox, removeCustomBox, removeAllCustomBoxes, maxCustomBoxIdx
  */
KDChartCustomBox* KDChartParams::customBoxRef( uint box )
{
    return _customBoxDict.find( box );
}

/**
  Retrieve the biggest custom boxes ID used.

  \sa insertCustomBox, removeCustomBox, removeAllCustomBoxes, customBox
  */
uint KDChartParams::maxCustomBoxIdx() const
{
    uint cnt( _customBoxDict.count() );
    if( cnt ) {
        int maxIndex = cnt-1;
        TQIntDictIterator<KDChartCustomBox> it( _customBoxDict );
        for( ; it.current(); ++it )
            if( it.currentKey() > maxIndex )
                maxIndex = it.currentKey();
        return maxIndex;
    }
    return 0;
}

/**
  \enum KDChartParams::ChartType

  The chart type. Covers only built-in chart types.

  \sa setChartType, chartType
  \sa setAdditionalChartType, additionalChartType,
  \sa setChartSourceMode
  */


/**
  Specifies the chart type. The default is bar charts (Bar).

  \note Allways call this <b>before</b> specifying other
  axis properties and before calling \c setAdditionalChartType().<br>
  \c setChartType() deactivates the right axis and also sets the
  axisLabelsTouchEdges back to their default for all bottom and
  top axes.

  \note Calling setChartType() results in changing the default data value
  texts font settings (i.e. the font size, colour, position, but not the
  TQFont itself) <b>if</b> these parameters were not changed by
  setPrintDataValues().
  In order to re-activate this automatical adjustment of font settings
  even after you have changed them manually you may call
  setPrintDataValuesWithDefaultFontParams().
  \li When calling setPrintDataValuesWithDefaultFontParams()
  <b>before</b> calling setChartType() make sure you set the
  \c callSetPrintDataValues parameter to \c false.
  \li When calling setPrintDataValuesWithDefaultFontParams()
  <b>after</b> calling setChartType() you may set the \c
  callSetPrintDataValues parameter to \c true <b>or</b> you may call
  setPrintDataValues() yourself after calling
  setPrintDataValuesWithDefaultFontParams() to specify additional
  parameters.

  \param chartType the chart type to use
  \sa chartType, ChartType
  \sa setAdditionalChartType, additionalChartType,
  \sa setBarChartSubType, barChartSubType
  \sa setLineChartSubType, lineChartSubType
  \sa setPolarChartSubType, polarChartSubType
  \sa setChartSourceMode, chartSourceMode
  \sa setAxisLabelsTouchEdges
  */
void KDChartParams::setChartType( ChartType chartType )
{
    _chartType = chartType;

    // de-activate 2nd axis that might have been set automatically
    // by a previous call of \c setAdditionalChartType()
    setAxisVisible( KDChartAxisParams::AxisPosRight, false );

    // Make sure abscissa axes start their labeling at the very
    // first position and end at the last position when drawing
    // area charts.
    // Bar charts and line charts look better with their abscissa labels
    // in the respective middle positions below each bar (or point, resp.)
    bool bAbscissaAxisLabelsTouchEdges = ( Area == chartType );
    setAxisLabelsTouchEdges( KDChartAxisParams::AxisPosBottom,
            bAbscissaAxisLabelsTouchEdges );
    setAxisLabelsTouchEdges( KDChartAxisParams::AxisPosTop,
            bAbscissaAxisLabelsTouchEdges );
    setAxisLabelsTouchEdges( KDChartAxisParams::AxisPosBottom2,
            bAbscissaAxisLabelsTouchEdges );
    setAxisLabelsTouchEdges( KDChartAxisParams::AxisPosTop2,
            bAbscissaAxisLabelsTouchEdges );
    // activate default data value text settings for this chart type
    if (    printDataValues( 0 )
         && printDataValuesWithDefaultFontParams( 0 ) )
        setPrintDataValues( true, 0 );
    emit changed();
}


/**
  \fn KDChartParams::ChartType KDChartParams::chartType() const

  Returns the chart type configured in this params object.

  \return the chart type configured in this params object.
  \sa setChartType, ChartType
  \sa setAdditionalChartType, additionalChartType,
  \sa setBarChartSubType, barChartSubType
  \sa setLineChartSubType, lineChartSubType
  \sa setPolarChartSubType, polarChartSubType
  \sa setChartSourceMode, chartSourceMode
  */



/**
  Specifies the additional chart type.
  The default is no additional chart (NoType).
  The additional chart will have <b>no grid</b> so either make sure you
  specify the chart that should have a grid via \c setChartType() and
  the other one as additional chart or specify the grid manually if you
  need one for the additional chart too.

  The additional chart uses the same abscissa axis as the main chart,
  but cannot change the abscissa settings: the abscissa range and step width
  is determined according to the main chart's values.

  You may combine all different types of cartesian charts
  (== Bar, Line, HiLo, ..., but not Polar, Pie, ...)
  so e.g. the following combinations are possible:<br>

  \verbatim
  setChartType( KDChartParams::Bar );
  setAdditionalChartType( KDChartParams::Line );
  \endverbatim
  or
  \verbatim
  setChartType( KDChartParams::Line );
  setAdditionalChartType( KDChartParams::HiLo );
  \endverbatim
  or
  \verbatim
  setChartType( KDChartParams::Bar );
  setAdditionalChartType( KDChartParams::Bar );
  ...
  \endverbatim

  \note When defining multiple charts it is mandatory to
  call \c setChartSourceMode() for specifying the dataset(s)
  and their respective charts after calling \c setAdditionalChartType(),
  also it is recommended to call \c setAxisDatasets() for all
  axes to be used by the different datasets - otherwise the
  default setting will be used (all datasets except the last
  one match the left axis, the last dataset matches the right axis),
  so e.g. your code to have a bar chart for datasets 0..2 (using the
  left axis) and a line chart for datasets 3..4 (using the right axis)
  could look like this:

  \verbatim
  setChartType( KDChartParams::Bar );
  setAdditionalChartType( KDChartParams::Line );
  setChartSourceMode( KDChartParams::DataEntry,     0,2, 0 );
  setChartSourceMode( KDChartParams::DataEntry,     3,4, 1 );
  setAxisDatasets( KDChartAxisParams::AxisPosLeft,  0,2, 0 );
  setAxisDatasets( KDChartAxisParams::AxisPosRight, 3,4, 1 );
  \endverbatim

  \note In case you DON'T want to use the right axis but the left axis #2
  make sure to reset the dataset assignment that is automatically done for
  the right axis. Doing this will also clear the visibility flag of the
  right axis that is automatically set by setAdditionalChartType()
  implicitely assuming that the additional chart will use the right axis,
  so there is no need to explicitely call setAxisVisible( false ) for
  the right axis: specifying KDCHART_NO_DATASET is enough to disable it.
  e.g. in the example shown above you would replace the
  last line by these ones:

  \verbatim
  setAxisDatasets( KDChartAxisParams::AxisPosLeft2, 3,4, 1 );
  setAxisDatasets( KDChartAxisParams::AxisPosRight,
  KDCHART_NO_DATASET );
  \endverbatim

  Often your additional chart will look better when not overlapping with
  the first chart, specifying different y-positions for the charts
  is possible by \c KDChartAxisParams::setAxisUseAvailableSpace(),
  e.g. like this:

\verbatim
// specify which amount of the available space
// is to be used by the first y-axis:

KDChartAxisParams pa(
        _p->axisParams( KDChartAxisParams::AxisPosLeft ) );
pa.setAxisUseAvailableSpace( 0, -499 );
_p->setAxisParams( KDChartAxisParams::AxisPosLeft, pa );

// specify which amount of the available space
// is to be used by the second y-axis:

pa = _p->axisParams( KDChartAxisParams::AxisPosLeft2 );
pa.setAxisUseAvailableSpace( -750, -1000 );
_p->setAxisParams( KDChartAxisParams::AxisPosLeft2, pa );
\endverbatim

\param chartType the additional chart type to use

\sa additionalChartType, setChartSourceMode, setAxisDatasets
\sa <br>chartType, ChartType
\sa setBarChartSubType, barChartSubType
\sa setLineChartSubType, lineChartSubType
    */
void KDChartParams::setAdditionalChartType( ChartType chartType )
{
    _additionalChartType = chartType;
    if ( KDChartParams::NoType == chartType ) {
        setAxisDatasets( KDChartAxisParams::AxisPosRight,
                KDCHART_NO_DATASET );
    } else {
        setAxisDatasets( KDChartAxisParams::AxisPosRight,
                KDCHART_ALL_DATASETS,
                KDCHART_ALL_DATASETS,
                1 );
        if(   printDataValues( 1 )
             && printDataValuesWithDefaultFontParams( 1 ) )
            setPrintDataValues( true, 1 );
    }
    emit changed();
}


/**
  \fn void KDChartParams::ChartType KDChartParams::additionalChartType() const

  Returns the additional chart type configured in this params object.

  \return the additional chart type configured in this params object.
  \sa setAdditionalChartType, setChartSourceMode, chartSourceMode
  \sa <br>setChartType, ChartType
  \sa setBarChartSubType, barChartSubType
  \sa setLineChartSubType, lineChartSubType
  */



/**
  \fn bool KDChartParams::neverUsedSetChartSourceMode() const

  Retrieves whether setChartSourceMode() was called or not
  */




/**
  \fn uint KDChartParams::maxDatasetSourceMode() const

  Returns the number of the highest dataset for which a SourceMode has been
  defined.

  \return the number of the highest dataset for which a SourceMode has been
  defined.
  \sa setChartSourceMode, chartSourceMode, findDataset
  */

/**
  \fn void KDChartParams::setNumValues( uint )

  Specifies how many of the values should be shown. -1 means all
  available values.

  \param numValues the number of values to be shown
  \sa numValues
  */

/**
  \fn int KDChartParams::numValues() const

  Returns how many of the values should be shown. -1 means all
  available values.

  \return the number of values to be shown
  \sa setNumValues
  */


/**
  \fn void KDChartParams::setShadowBrightnessFactor( double factor )

  Specifies a factor to be used to adjust the
  built-in brightness of shadow colors in
  3-dimensional drawings like e.g. 3D Bar charts.

  \param factor a factor that is to be taken into account for internal
  calculation of shadow colors. By specifying values greater 1.0 you
  may lighten the shadows until the most intensive brightness is
  reached, while values smaller than 1.0 will darken the shadows until
  the respective colors are black.

  \sa shadowBrightnessFactor
  */


/**
  \fn double KDChartParams::shadowBrightnessFactor() const

  Returns a factor to be used to adjust the
  built-in brightness of shadow colors in
  3-dimensional drawings like e.g. 3D Bar charts.

  \return a factor that is to be taken into account for internal
  calculation of shadow colors.

  \sa setShadowBrightnessFactor
  */


/**
  \fn void KDChartParams::setShadowPattern( TQt::BrushStyle style )

  Specifies a filling style for filling the shadow areas in
  3-dimensional drawings like 3D bar charts. The default is to
  fill with a solid color, the color is determined with \a
  setThreeDShadowColors.

  \param style the fill style to use
  \sa shadowPattern(), setThreeDShadowColors(),
  threeDShadowColors()
  */


/**
  \fn TQt::BrushStyle KDChartParams::shadowPattern() const

  Returns the filling style used for filling the shadow areas in
  3-dimensional drawings like 3D bar charts. The default is to
  fill with a solid color, the fill color can be queried with \a
  threeDShadowColors().

  \return the fill style used
  \sa setShadowPattern(), setThreeDShadowColors(),
  threeDShadowColors()
  */

/**
  \fn void KDChartParams::setOutlineDataColor( TQColor color )

  Specifies a color for the outlines of data displays. The default is
  black.

  \note Use setOutlineDataLineStyle( TQt::NoPen ) to hide the line.

  \param color the color to use for the outlines
  \sa outlineDataColor, setOutlineDataLineStyle, setOutlineDataLineWidth
  */


/**
  \fn TQColor KDChartParams::outlineDataColor() const

  Returns the color for the outlines of data displays.

  \return the outline color
  \sa setOutlineDataColor
  */


/**
  \fn void KDChartParams::setOutlineDataLineWidth( uint width )

  Specifies the width of the outlines of data displays. The default is 1
  pixel.

  \note Use setOutlineDataLineStyle( TQt::NoPen ) to hide the line.

  \param width the line width to use for the outlines
  \sa outlineDataLineWidth, setOutlineDataLineStyle, setOutlineDataColor
  */


/**
  \fn uint KDChartParams::outlineDataLineWidth() const

  Returns the width of the outlines of data displays.

  \param style the line width that is used for outlines
  \sa setOutlineDataLineWidth
  */


/**
  \fn void KDChartParams::setOutlineDataLineStyle( PenStyle style )

  Specifies the line style of the outlines of data displays. The default
  is a solid line. Warning: On Windows 95/98, the style setting (other
  than NoPen and SolidLine) has no effect for lines with width greater
  than 1, due to a bug in the operating system.

  \param width the line style to use for the outlines
  \sa outlineDataLineStyle, setOutlineDataColor, setOutlineDataLineWidth
  */


/**
  \fn PenStyle KDChartParams::outlineDataLineStyle() const

  Returns the style of the outlines of data displays.

  \param style the line style that is used for outlines
  \sa setOutlineDataLineStyle
  */


/**
  \fn uint KDChartParams::maxDataColor() const

  Returns the number of the highest dataset for which a color has been
  defined.

  \return the number of the highest dataset for which a color has been
  defined.
  \sa setDataColor, dataColor
  */


/**
  \fn void KDChartParams::setThreeDShadowColors( bool shadow )

  Specifies whether the engine should draw the sides and tops of
  3D effects in shadowed versions of the data colors (the
  default) or in the data colors themselves. Only used with 3D
  effects in charts that support these.

  \param shadow true for shadowed colors, false for original colors
  \sa threeDShadowColors
  */


/**
  \fn bool KDChartParams::threeDShadowColors() const

  Returns whether the engine should draw the sides and tops of 3D effects in
  shadowed versions of the data colors or in the data colors
  themselves. Only used with 3D effects in charts that
  support these. The default is true.

  \return true if shadowed colors are used for 3D effects
  \sa setThreeDShadowColors
  */


/**
  \fn void KDChartParams::setAllowOverlappingDataValueTexts( bool allow )

  Specifies whether a data value text may be drawn even if it's
  region intersects with another data value text's region.

  By default this is FALSE to prevent ugly mutual overwriting of
  data value texts and to speed up drawing of cahrts containing
  thousands of data points.
  */


/**
  \fn bool KDChartParams::allowOverlappingDataValueTexts() const

  Returns whether a data value text may be drawn even if it's region
  intersects with another data value text's region.

  By default this is FALSE to prevent ugly mutual overwriting of data
  value texts and to speed up drawing of cahrts containing thousands
  of data points.
  */


/**
  Specifies how the data value text figures are modified before printing.

  This methode is provided for your convenience, to learn how to set the
  other text parameters please have a look at setPrintDataValues.

  \sa printDataValuesWithDefaultFontParams, setPrintDataValues
  \sa dataValuesColor
  \sa setPrintDataValuesFontRelSize setPrintDataValuesBackground
  */
void KDChartParams::setDataValuesCalc( int divPow10,
                                       int digitsBehindComma,
                                       uint chart )
{
    uint count = (KDCHART_ALL_CHARTS == chart) ? 2 : 1;
    PrintDataValuesSettings * settings =    (( 1 < count ) || ( 0 == chart ))
        ? &_printDataValuesSettings
        : &_printDataValuesSettings2;
    for ( uint i = 0; i < count; ++i ) {
        settings->_divPow10 = divPow10;
        settings->_digitsBehindComma = digitsBehindComma;
        if ( 0 < chart )
            settings = &_printDataValuesSettings2;
    }
    emit changed();
}

/**
  Specifies the font to be used for printing the data value texts.

  This methode is provided for your convenience, to learn how to set the
  other text parameters please have a look at setPrintDataValues.

  \sa printDataValuesWithDefaultFontParams, setPrintDataValues
  \sa dataValuesColor
  \sa setPrintDataValuesFontRelSize setPrintDataValuesBackground
  */
void KDChartParams::setDataValuesFont( 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();
}

/**
  Specifies the position and rotation of the data value texts to be printed.

  This methode is provided for your convenience, to learn how to set the
  other text parameters please have a look at setPrintDataValues.

  \sa printDataValuesWithDefaultFontParams, setPrintDataValues
  \sa dataValuesColor
  \sa setPrintDataValuesFontRelSize setPrintDataValuesBackground
  */
void KDChartParams::setDataValuesPlacing( KDChartEnums::PositionFlag position,
                                          uint align,
                                          int  deltaX,
                                          int  deltaY,
                                          int  rotation,
                                          bool specifyingPositiveValues,
                                          uint chart )
{
    uint count = (KDCHART_ALL_CHARTS == chart) ? 2 : 1;
    PrintDataValuesSettings * settings =    (( 1 < count ) || ( 0 == chart ))
        ? &_printDataValuesSettings
        : &_printDataValuesSettings2;
    for ( uint i = 0; i < count; ++i ) {
        if( specifyingPositiveValues ){
            // for values greater/equal zero:
            settings->_dataValuesAnchorPositivePosition = position;
            settings->_dataValuesAnchorPositiveAlign    = align;
            settings->_dataValuesAnchorPositiveDeltaX   = deltaX;
            settings->_dataValuesAnchorPositiveDeltaY   = deltaY;
            settings->_dataValuesPositiveRotation       = rotation;
        }else{
            // for values below zero:
            settings->_dataValuesAnchorNegativePosition = position;
            settings->_dataValuesAnchorNegativeAlign    = align;
            settings->_dataValuesAnchorNegativeDeltaX   = deltaX;
            settings->_dataValuesAnchorNegativeDeltaY   = deltaY;
            settings->_dataValuesNegativeRotation       = rotation;
        }
        if ( 0 < chart )
            settings = &_printDataValuesSettings2;
    }
    emit changed();
}

/**
  Specifies the text color and background brush to be used for
  printing the data value texts.

  To have the color calculated automatically - useful when printing
  inside the bars (or pie slices, areas, ... resp.) - please use
  \c KDCHART_DATA_VALUE_AUTO_COLOR instead of a TQColor*.

  Setting the background is normally not needed since reasonable
  settings are done by default: Area charts have a white background
  behind the data value texts while all other chart types use no
  special background (the value is TQt::NoBrush then).

  In case you want to use it to remove the extra background from
  your Area chart's data value texts you should consider changing
  the dataset colors as well: an idea might be trying the subdued
  colorset by calling \c setSubduedColors().

  \sa printDataValuesWithDefaultFontParams
  \sa setPrintDataValues
  \sa dataValuesColor
  \sa setPrintDataValuesFontRelSize
  */
void KDChartParams::setDataValuesColors( const 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();
}


/**
  Specifies whether data value texts should be printed even if the
  value is KDCHART_POS_INFINITE (or KDCHART_NEG_INFINITE).

  Printing of an infinite symbol (lemniskate) is done by default,
  ou may use this function to disable it.

  \sa printDataValuesWithDefaultFontParams
  \sa setPrintDataValues
  \sa dataValuesColor
  \sa setPrintDataValuesFontRelSize
  */
void KDChartParams::setDataValuesShowInfinite( bool dataValuesShowInfinite,
                                               uint chart)
{
    uint count = (KDCHART_ALL_CHARTS == chart) ? 2 : 1;
    PrintDataValuesSettings * settings =    (( 1 < count ) || ( 0 == chart ))
        ? &_printDataValuesSettings
        : &_printDataValuesSettings2;
    for ( uint i = 0; i < count; ++i ) {
        settings->_dataValuesShowInfinite = dataValuesShowInfinite;
        if ( 0 < chart )
            settings = &_printDataValuesSettings2;
    }
    emit changed();
}


/* function only there for backward compatibility */
void KDChartParams::setPrintDataValuesColor( uint chart, const 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();
}


/**
  Specifies the dynamic font size to be used for printing the data
  value texts.  To change settings for all charts specify \c
  KDCHART_ALL_CHARTS as \chart parameter.

  This methode is provided for your convenience, to learn how to set the
  other text parameters please have a look at setPrintDataValues.

  \sa printDataValuesWithDefaultFontParams, setPrintDataValues
  \sa setPrintdataValuesColor, dataValuesFontRelSize
  */
void KDChartParams::setPrintDataValuesFontRelSize( uint chart, uint size )
{
    uint count = (KDCHART_ALL_CHARTS == chart) ? 2 : 1;
    PrintDataValuesSettings * settings =    (( 1 < count ) || ( 0 == chart ))
        ? &_printDataValuesSettings
        : &_printDataValuesSettings2;
    uint theSize( UINT_MAX == size ? 16 : size );
    for ( uint i = 0; i < count; ++i ) {
        settings->_dataValuesUseFontRelSize = ( 0 < theSize );
        settings->_dataValuesFontRelSize = theSize;
        if ( 0 < chart )
            settings = &_printDataValuesSettings2;
    }
    emit changed();
}


/**
  Specifies that data value texts are to be printed with default font
  parameters.  Calling this methode results in resetting the
  respective font size and colour and position parameters but not the
  TQFont itself.  By setting \c callSetPrintDataValues to true you
  select general enabling of text printing, when doing so it is
  <b>not</b> neccessary to call setPrintDataValues() after calling
  setPrintDataValuesWithDefaultFontParams().

  \note If you want to call setChartType() after calling
  setPrintDataValuesWithDefaultFontParams() you should set the \c
  callSetPrintDataValues parameter to false to prevent
  setPrintDataValues() from being called twice since it is called
  internally each time you call setChartType() <b>if</b> the default
  font params are to be set.

  \sa printDataValuesWithDefaultFontParams, setPrintDataValues
  */
void KDChartParams::setPrintDataValuesWithDefaultFontParams( uint chart,
        bool callSetPrintDataValues )
{
    uint count = (KDCHART_ALL_CHARTS == chart) ? 2 : 1;
    PrintDataValuesSettings * settings =    (( 1 < count ) || ( 0 == chart ))
        ? &_printDataValuesSettings
        : &_printDataValuesSettings2;
    for ( uint i = 0; i < count; ++i ) {
        settings->_printDataValues      = true;
        settings->_useDefaultFontParams = true;
        if ( 0 < chart )
            settings = &_printDataValuesSettings2;
    }
    if ( callSetPrintDataValues )
        setPrintDataValues( true, chart );
}


/**
  \fn bool KDChartParams::printDataValuesWithDefaultFontParams( uint chart ) const

  Retrieves whether data value texts are to be printed with
  non-default font parameters or not - <b>when</b> text printing is
  active.

  \note You might also want to call printDataValues to see if text
  printing is active since this default flag remains set in
  background even when printing has been de-activated.

  \sa setPrintDataValuesWithDefaultFontParams, printDataValues
  */


/**
  \fn bool KDChartParams::printDataValues( uint chart ) const

  Returns whether the data values will be printed near their
  respective entries.

  \param chart The number of the chart: 0 for the first chart, 1 for
  the second chart in case there are two charts to be drawn sharing the
  same data area.

  \return whether the data values will be printed near their
  respective entries.

  \sa setPrintDataValues
  */


/**
  \fn TQFont KDChartParams::dataValuesFont( uint chart ) const

  Returns the font to be used for printing the data values

  \param chart The number of the chart: 0 for the first chart, 1 for
  the second chart in case there are two charts to be drawn sharing the
  same data area.

  \returns the font to be used for printing the data values

  \sa setPrintDataValues
  */


/**
  \fn bool KDChartParams::dataValuesUseFontRelSize( uint chart ) const

  Returns whether the font size to be used for printing the
  data values is calculated dynamically.

  \param chart The number of the chart: 0 for the first chart, 1 for
  the second chart in case there are two charts to be drawn sharing the
  same data area.

  \return whether the font size to be used for printing the
  data values is calculated dynamically.

  \sa setPrintDataValues, setPrintDataValuesFontRelSize
  */


/**
  \fn int KDChartParams::dataValuesFontRelSize( uint chart ) const

  Returns the relative size (in per mille of the chart width)
  of font size to be used for printing the
  data values.

  \param chart The number of the chart: 0 for the first chart, 1 for
  the second chart in case there are two charts to be drawn sharing the
  same data area.

  \return the relative size (in per mille of the chart width)
  of font size to be used for printing the
  data values.

  \sa setPrintDataValues, setPrintDataValuesFontRelSize
  */


/**
  \fn TQColor KDChartParams::dataValuesColor( uint chart ) const

  Returns the colour of the font to be used for printing the
  data values.

  \param chart The number of the chart: 0 for the first chart, 1 for
  the second chart in case there are two charts to be drawn sharing the
  same data area.

  \return the colour of the font to be used for printing the
  data values.

  \sa setPrintDataValues, setPrintDataValuesColor
  */


/**
  \fn bool KDChartParams::dataValuesAutoColor( uint chart ) const

  Returns whether the font to be used for printing the data values
  texts shall have automatically calculated colors fitting to their
  respectivs data representations.

  \param chart The number of the chart: 0 for the first chart, 1 for
  the second chart in case there are two charts to be drawn sharing the
  same data area.

  \return whether the font to be used for printing the data values texts
  shall have automatically calculated colors fitting to their respectivs data representations.

  \sa setPrintDataValues
  */


/**
  Returns the anchor position which the text is to be aligned to.

  \param chart The number of the chart: 0 for the first chart, 1 for
  the second chart in case there are two charts to be drawn sharing the
  same data area.

  \param negative If true the return value is only valid for data
  values less than zero, if false it applies to data values greater
  or equal to zero.

  \returns the anchor position which the text is to be aligned to in case of
  the value being less than zero.

  \sa setPrintDataValues
  */
KDChartEnums::PositionFlag KDChartParams::dataValuesAnchorPosition( uint chart, bool negative ) const
{
    if ( negative )
        return chart ? _printDataValuesSettings2._dataValuesAnchorNegativePosition
            : _printDataValuesSettings._dataValuesAnchorNegativePosition;
    else
        return chart ? _printDataValuesSettings2._dataValuesAnchorPositivePosition
            : _printDataValuesSettings._dataValuesAnchorPositivePosition;
}


/**
  Returns the way how the text is to be aligned to the anchor.

  This must be a reasonable combination of TQt::AlignmentFlags.

  \param chart The number of the chart: 0 for the first chart, 1 for
  the second chart in case there are two charts to be drawn sharing the
  same data area.

  \param negative If true the return value is only valid for data
  values less than zero, if false it applies to data values greater
  or equal to zero.

  \returns the way how the text is to be aligned to the anchor in case of
  the value being less than zero.

  \sa setPrintDataValues
  */
uint KDChartParams::dataValuesAnchorAlign( uint chart, bool negative ) const
{
    if ( negative )
        return chart ? _printDataValuesSettings2._dataValuesAnchorNegativeAlign
            : _printDataValuesSettings._dataValuesAnchorNegativeAlign;
    else
        return chart ? _printDataValuesSettings2._dataValuesAnchorPositiveAlign
            : _printDataValuesSettings._dataValuesAnchorPositiveAlign;
}


/**
  Returns the X distance between the text and its anchor.

  \note For better compatibility to the dynamic font size,
  this parameter is <b>always</b> interpreted as being a per-mille
  value of the logical width of the drawing area. If greater 0, the X
  position is increased, if less than 0, it is reduced, this is
  calculated dynamically before painting.

  \param chart The number of the chart: 0 for the first chart, 1 for
  the second chart in case there are two charts to be drawn sharing the
  same data area.

  \param negative If true the return value is only valid for data
  values less than zero, if false it applies to data values greater
  or equal to zero.

  \returns the X distance between the text and its anchor.

  \sa setPrintDataValues
  */
int KDChartParams::dataValuesAnchorDeltaX( uint chart, bool negative ) const
{
    if ( negative )
        return chart ? _printDataValuesSettings2._dataValuesAnchorNegativeDeltaX
            : _printDataValuesSettings._dataValuesAnchorNegativeDeltaX;
    else
        return chart ? _printDataValuesSettings2._dataValuesAnchorPositiveDeltaX
            : _printDataValuesSettings._dataValuesAnchorPositiveDeltaX;
}


/**
  Returns the Y distance between the text and its anchor.

  \note For better compatibility to the dynamic font size this
  parameter is <b>always</b> interpreted as being a per-mille value
  of the logical width of the drawing area. If greater 0, the Y
  position is increased, if less than 0, it is reduced, this is
  calculated dynamically before painting.

  \param chart The number of the chart: 0 for the first chart, 1 for
  the second chart in case there are two charts to be drawn sharing the
  same data area.

  \param negative If true the return value is only valid for data
  values less than zero, if false it applies to data values greater
  or equal to zero.

  \returns the Y distance between the text and its anchor.

  \sa setPrintDataValues
  */
int KDChartParams::dataValuesAnchorDeltaY( uint chart, bool negative ) const
{
    if ( negative )
        return chart ? _printDataValuesSettings2._dataValuesAnchorNegativeDeltaY
            : _printDataValuesSettings._dataValuesAnchorNegativeDeltaY;
    else
        return chart ? _printDataValuesSettings2._dataValuesAnchorPositiveDeltaY
            : _printDataValuesSettings._dataValuesAnchorPositiveDeltaY;
}


/**
  Returns the amount of degrees (using a circle of 360 degrees) taken to
  rotate the text. Positive values rotate clockwise, negative values rotate counter-clockwise.

  \param chart The number of the chart: 0 for the first chart, 1 for
  the second chart in case there are two charts to be drawn sharing the
  same data area.

  \param negative If true the return value is only valid for data
  values less than zero, if false it applies to data values greater
  or equal to zero.

  \returns the amount of degrees (using a circle of 360 degrees) taken to
  rotate the text.

  \sa setPrintDataValues
  */
int KDChartParams::dataValuesRotation( uint chart, bool negative ) const
{
    if ( negative )
        return chart ? _printDataValuesSettings2._dataValuesNegativeRotation
            : _printDataValuesSettings._dataValuesNegativeRotation;
    else
        return chart ? _printDataValuesSettings2._dataValuesPositiveRotation
            : _printDataValuesSettings._dataValuesPositiveRotation;
}


/**
  \fn KDChartEnums::TextLayoutPolicy KDChartParams::dataValuesLayoutPolicy( uint chart ) const

  Returns the way to handle too narrow space conflicts: what to do if
  a data text covers a neighboring data text (or a neighboring data
  area, resp.).

  \note A layout policy different from LayoutJustOverwrite from does
  not mean that this policy is followed in any case. Rather than
  giving up when the selected policy does not result in a good layout
  the program will automatically try the next policy: if
  LayoutPolicyRotate did not succeed LayoutPolicyShiftVertically will
  be tried, if this did not succeed either
  LayoutPolicyShiftHorizontally will be tried.

  \param chart The number of the chart: 0 for the first chart, 1 for
  the second chart in case there are two charts to be drawn sharing the
  same data area.

  \returns the way to handle too narrow space conflicts.

  \sa setPrintDataValues
  */

/**
  \fn void KDChartParams::changed()

  This signal is emitted when any of the chart parameters has changed.
  */

/**
  \var const uint KDCHART_MAX_AXES

  Charts have up to 12 axes:
  up to two axes on both sides for X, Y
  and Z (if data is 3-dimensional). This constant is located here and
  in KDChartAxisParams, because one KDChartAxisParams object
  describes only one axis.
  */

/**
  \var static const int KDCHART_PROPSET_NORMAL_DATA;

  Default (built-in) property ID, used for data cells
  without any special properties.

  Use this IDs <b>without</b> previously defining a respective
  set of properties via KDChartParams::registerProperties(...).

  \note While (in theory) it <b>is</b> possible to assign special
  property values to this build-in property set this normally might not
  a very good idea since these values would apply to every(!) data cell
  that has no other property set assigned.  Such general changes
  would rather be done calling KDChartParam's main functions, e.g. you
  would invoke KDChartParams::setLineMarker(true) instead of changing
  the normal-data property set.

  \sa KDCHART_PROPSET_TRANSPARENT_DATA
  \sa KDCHART_PROPSET_HORI_LINE, KDCHART_PROPSET_VERT_LINE
  \sa KDChartData::setPropertySet
  \sa KDChartParams::registerProperties, KDChartParams::setProperties, KDChartParams::properties
  */

/**
  \var static const int KDCHART_PROPSET_TRANSPARENT_DATA;

  Predefined (build-in) property ID. used to specify a cell that should be displayed
  using a null pen: neither the data representation nor
  the connecting line to the next point will be shown,
  but the line will be drawn using line style TQt::NoPen.

  Use this IDs <b>without</b> previously defining a respective
  set of properties via KDChartParams::registerProperties(...).

  \note: Assigning this property to a data cell will result in the
  cell being invisible: there will be no marker for this point and
  there will be a 'gap' in this dataset's line from the point to the next one.
  In case you want to change this default behavior,
  use KDChartParams::setProperties(),
  e.g. the following piece of code still has an invisible line while now
  enabeling showing of the marker - but only if it was set active by
  KDChartParams::setLineMarker(true).

  \verbatim
  KDChartPropertySet transpProps;
  bool bDummy;
  if( properties(KDCHART_PROPSET_TRANSPARENT_DATA,
  transpProps) ){
// build-in property was found, let's modify it a bit:
transpProps.setShowMarker(
KDCHART_PROPSET_NORMAL_DATA, bDummy );
setProperties(KDCHART_PROPSET_TRANSPARENT_DATA,
transpProps);
}else{
// Ooops? The build-in property was NOT found!
// OK, never mind, let's specify it from scratch:
transpProps.setName("transparent data");
transpProps.setLineStyle(KDChartPropertySet::OwnID, TQt::NoPen);
transpProps.setShowMarker(
KDCHART_PROPSET_NORMAL_DATA, bDummy);
setProperties(KDCHART_PROPSET_TRANSPARENT_DATA,
transpProps);
}
\endverbatim

\note The example above uses setProperties (in the last line) to
define a property set. This is the right way for build-in property sets,
but it is not recomended for your additional user-defined property sets:
these should be registered with the registerProperties function
to initially obtain a unique ID number for your new property set,
see the second example given with \c KDCHART_PROPSET_VERT_LINE.

\sa KDCHART_PROPSET_NORMAL_DATA
\sa KDCHART_PROPSET_HORI_LINE, KDCHART_PROPSET_VERT_LINE
\sa KDChartData::setPropertySet
\sa KDChartParams::registerProperties, KDChartParams::setProperties, KDChartParams::properties
*/

/**
  \var static const int KDCHART_PROPSET_HORI_LINE;

  Predefined (build-in) property ID. may be used to specify a special cell
  which is not part of the normal data but to be used for positioning
  a separate horizontal line.
  Data display will be surpressed for this point: neither the data
  representation nor the connecting line to the next point will
  be shown, actually the point will remain invisible but a horizontal
  line will be drawn instead: using line style TQt::DotLine and the
  respective dataset's line color.

  Use this IDs <b>without</b> previously defining a respective
  set of properties via KDChartParams::registerProperties(...).

  In case you want to change this default behavior,
  use KDChartParams::setProperties(),
  e.g. the following piece of code still has an invisible line and
  also does not show the point's marker while now showing two
  separate markers at the horizontal line's start and end.

  \verbatim
  KDChartPropertySet horiProps;
  if( properties(KDCHART_PROPSET_HORI_LINE,
  horiProps) ){
// build-in property was found, let's modify it a bit:
horiProps.setExtraMarkersAlign(
KDChartPropertySet::OwnID,
TQt::AlignLeft | TQt::AlignRight );
setProperties(KDCHART_PROPSET_HORI_LINE,
horiProps);
}else{
// Ooops? The build-in property was NOT found!
// OK, never mind, let's specify it from scratch:
horiProps.setName("horizontal line");
horiProps.setLineStyle(KDChartPropertySet::OwnID, TQt::NoPen);
horiProps.setShowMarker( KDChartPropertySet::OwnID, false );
horiProps.setExtraMarkersAlign(  KDChartPropertySet::OwnID,
TQt::AlignLeft | TQt::AlignRight );
horiProps.setExtraMarkersAlign(
KDChartPropertySet::OwnID,
TQt::AlignLeft | TQt::AlignRight );
setProperties(KDCHART_PROPSET_HORI_LINE,
horiProps);
}
\endverbatim

\note The example above uses setProperties (in the last line) to
define a property set. This is the right way for build-in property sets,
but it is not recomended for your additional user-defined property sets:
these should be registered with the registerProperties function
to initially obtain a unique ID number for your new property set,
see the second example given with \c KDCHART_PROPSET_VERT_LINE.

\sa KDCHART_PROPSET_NORMAL_DATA
\sa KDCHART_PROPSET_VERT_LINE
\sa KDChartData::setPropertySet
\sa KDChartParams::registerProperties, KDChartParams::setProperties, KDChartParams::properties
*/

/**
  \var static const int KDCHART_PROPSET_VERT_LINE;

  Predefined (build-in) property ID. may be used to specify a special cell
  which is not part of the normal data but to be used for positioning
  a separate vertical line.
  Data display will be surpressed for this point: neither the data
  representation nor the connecting line to the next point will
  be shown, actually the point will remain invisible but a vertical
  line will be drawn instead: using line style TQt::DotLine and the
  respective dataset's line color.

  Use this IDs <b>without</b> previously defining a respective
  set of properties via KDChartParams::registerProperties(...).

  In case you want to change this default behavior,
  use KDChartParams::setProperties(),
  e.g. the following piece of code still has an invisible line and
  also does not show the point's marker while now showing a
  separate marker at the top end of the vertical line which
  will <b>not</b> run across the complete data area but start
  on the respective point's Y position and go to the top edge
  of the chart's area.

  \verbatim
  KDChartPropertySet vertProps;
  if( properties(KDCHART_PROPSET_VERT_LINE,
  vertProps) ){
// build-in property was found, let's modify it a bit:
vertProps.setExtraMarkersAlign(
KDChartPropertySet::OwnID, TQt::AlignTop );
setProperties(KDCHART_PROPSET_VERT_LINE,
vertProps);
}else{
// Ooops? The build-in property was NOT found!
// OK, never mind, let's specify it from scratch:
vertProps.setName("vertical line");
vertProps.setLineStyle(KDChartPropertySet::OwnID, TQt::NoPen);
vertProps.setShowMarker( KDChartPropertySet::OwnID, false );
vertProps.setExtraMarkersAlign(  KDChartPropertySet::OwnID,
TQt::AlignTop );
vertProps.setExtraMarkersAlign(
KDChartPropertySet::OwnID,
TQt::AlignTop );
setProperties(KDCHART_PROPSET_VERT_LINE,
vertProps);
}
\endverbatim

\note The example above uses setProperties (in the last line) to
define a property set. This is the right way for build-in property sets,
but it is not recomended for your additional user-defined property sets:
these should be registered with the registerProperties function
to initially obtain a unique ID number for your new property set,
see the following example:

The code shown below demonstrates how to specify a <b>new</b>
property set which then can be used for adding a red vertical
line with marker to some of your normal data points:

\verbatim
// 1. specify and register the new property set
KDChartPropertySet dataWithTopLineProps;
dataWithTopLineProps.setName(
"normal data with red vertical line on top");
dataWithTopLineProps.setExtraLinesAlign(
KDChartPropertySet::OwnID,
TQt::AlignTop );
dataWithTopLineProps.setExtraLinesWidth(
KDChartPropertySet::OwnID,
-2 );
dataWithTopLineProps.setExtraLinesColor(
KDChartPropertySet::OwnID,
    TQt::red );
dataWithTopLineProps.setExtraLinesStyle(
        KDChartPropertySet::OwnID,
        TQt::SolidLine );
dataWithTopLineProps.setExtraMarkersAlign(
        KDChartPropertySet::OwnID,
        TQt::AlignTop );
dataWithTopLineProps.setExtraMarkersSize(
        KDChartPropertySet::OwnID,
        TQSize(-10, -10) );
dataWithTopLineProps.setExtraMarkersColor(
        KDChartPropertySet::OwnID,
        TQt::darkRed );
dataWithTopLineProps.setExtraMarkersStyle(
        KDChartPropertySet::OwnID,
        KDChartParams::LineMarkerCircle );
int idDataWithTopLineProps
= registerProperties( dataWithTopLineProps );
// 2. assign this property set
//    to some of your data cells
d = new KDChartTableData( 5, 10 );
// ...
d->cell( 0, 2 ).setPropertySet( idDataWithTopLineProps );
d->cell( 2, 5 ).setPropertySet( idDataWithTopLineProps );
\endverbatim

\sa KDCHART_PROPSET_NORMAL_DATA
\sa KDCHART_PROPSET_HORI_LINE
\sa KDChartData::setPropertySet
\sa KDChartParams::registerProperties, KDChartParams::setProperties, KDChartParams::properties
*/



//@}
// END GENERAL

// START BARCHART
/** @name Bar chart-specific methods.

  These methods query and set barchart-specific parameters.
  */
//@{

/**
  \enum KDChartParams::BarChartSubType

  The bar subtype. Only used when chartType() == Bar

  \sa setBarChartSubType, barChartSubType
  */


/**
  \fn void KDChartParams::setBarChartSubType( BarChartSubType barChartSubType )
  Specifies the bar chart subtype.

  This setting only has an effect in bar charts.

  \param barChartSubType the bar chart subtype
  \sa barChartSubType, BarChartSubType, setChartType, chartType
  */


/**
  \fn KDChartParams::BarChartSubType KDChartParams::barChartSubType() const

  Returns the bar chart subtype.

  This setting only has an effect in bar charts.

  \return the bar chart sub type
  \sa setBarChartSubType, BarChartSubType, setChartType, chartType
  */



/**
  \fn void KDChartParams::setThreeDBars( bool threeDBars )

  Specifies whether the engine should draw the bars in 3D.

  This setting only has an effect in bar charts.

  \param threeDBars true if bars should be drawn with a 3D effect
  \sa threeDBars, setThreeDBarAngle, threeDBarAngle
  */


/**
  \fn bool KDChartParams::threeDBars() const

  Returns whether the engine should draw any bars in 3D.

  This setting only has an effect in bar charts.

  \return true if bars should be draws with a 3D effect, false
  otherwise
  \sa setThreeDBars, threeDBarAngle, setThreeDBarAngle
  */

/**
  \fn void KDChartParams::setThreeDBarsShadowColors( bool shadow )
  \obsolete
  Specifies whether the engine should draw the sides and tops of 3D bars
  in shadowed versions of the data colors or in the data colors
  themselves. Only used if threeDBars() == true. The default is true.

  This setting only has an effect in bar charts.

  This method is obsolete; use setThreeDShadowColors instead

  \param shadow true for shadowed colors, false for original colors
  \sa setThreeDShadowColors
  */

/**
  \fn bool KDChartParams::threeDBarsShadowColors() const

  \obsolete
  Returns whether the engine should draw the sides and tops of 3D bars in
  shadowed versions of the data colors or in the data colors
  themselves. Only used if threeDBars() == true. The default is true.

  This setting only has an effect in bar charts.

  This method is obsolete; use threeDShadowColors instead

  \return true if bars use shadowed colors for 3D effects
  \sa setThreeDBarsShadowColors
  */


/**
  Specifies the angle used for 3D bars. Only used if threeDBars() == true.

  This setting only has an effect in bar charts.

  \param angle the angle in degrees. The default (and most useful
  value) is 45. Angle can be between 0 and 90, all other values
  are ignored. Values close to 0 or close to 90 may look
  strange, depending on the resolution of the output device.
  \sa setThreeDBars, threeDBars
  \sa threeDBarAngle, cosThreeDBarAngle
  \sa setThreeDBarDepth, threeDBarDepth
  */
void KDChartParams::setThreeDBarAngle( uint angle )
{
    if ( angle > 90 )  /* since angle is an uint, we do not need to
                          test for < 0 */
        return ;
    _threeDBarAngle = angle;

    // cache the cosine of this value
    _cosThreeDBarAngle = cos( static_cast < double > ( _threeDBarAngle ) * M_PI / 180.0 );
    emit changed();
}


/**
  \fn uint KDChartParams::threeDBarAngle() const

  Returns the angle in degrees used for 3D bars. Only used if threeDBars() == true.

  This setting only has an effect in bar charts.

  \return the angle in degrees used for 3D bars, always between 0 and 90.
  \sa setThreeDBars, threeDBars
  \sa setThreeDBarAngle, cosThreeDBarAngle
  \sa setThreeDBarDepth, threeDBarDepth
  */


/**
  \fn double KDChartParams::cosThreeDBarAngle() const

  Returns the cosine in rad of the angle used for 3D bars. Only used
  if threeDBars() == true.

  This setting only has an effect in bar charts.

  \return the cosine in rad of the angle used for 3D bars, always
  between 0 and 90.  \sa setThreeDBars, threeDBars \sa
  setThreeDBarAngle, threeDBarAngle \sa setThreeDBarDepth,
  threeDBarDepth
  */


/**
  \fn void KDChartParams::setThreeDBarDepth( double depth )

  Specifies the depth of the 3D Effect used for 3D bars.
  Only used if threeDBars() == true.

  This setting only has an effect in bar charts.

  \param depth the depth of the 3D Effect in relation to
  the bar width. The default (and most useful) value of
  1.0 may be used to specify bars with square basis.
  \sa threeDBarDepth
  \sa setThreeDBars,     threeDBars
  \sa setThreeDBarAngle, threeDBarAngle, cosThreeDBarAngle
  */


/**
  \fn double KDChartParams::threeDBarDepth() const

  Returns the depth of the 3D Effect used for 3D bars.
  Only used if threeDBars() == true.

  This setting only has an effect in bar charts.

  \return the depth of the 3D Effect in relation to the bar width.
  \sa setThreeDBarDepth
  \sa setThreeDBars,     threeDBars
  \sa setThreeDBarAngle, threeDBarAngle, cosThreeDBarAngle
  */


/**
  \fn void KDChartParams::setDatasetGap( int gap )

  Specifies the number of pixels between two dataset values.
  In addition you might want to use \c setOutlineDataLineStyle( TQt::NoPen ) to hide the line.

  Also the method \c setValueBlockGap might be usefull, please read the information given there ...

  This setting only has an effect in bar charts: if there is more than one dataset shown by your chart.

  \note Use negative values for overlaps, use \c
  setDatasetGapIsRelative to specify that the \c gap
  value is a per mille value of the chart data area width.

  The default is 6 per mille of the data area of the chart.

  \param gap the number of pixels between two dataset values.
  \sa setValueBlockGap
  \sa datasetGap
  \sa datasetGapIsRelative, setDatasetGapIsRelative
  \sa setOutlineDataLineStyle
  */


/**
  \fn int KDChartParams::datasetGap() const

  Returns the number of pixels between two dataset values.

  This setting only has an effect in bar charts.

  \note Negative values signify overlaps, use \c datasetGapIsRelative
  to find out if the \datasetGap value is a per mille value of the
  chart data area width.

  \return the number of pixels between two dataset values.
  \sa setDatasetGap
  \sa datasetGapIsRelative, setDatasetGapIsRelative
  */


/**
  \fn void KDChartParams::setDatasetGapIsRelative( bool gapIsRelative )

  Specifies if the value set by \c setDatasetGap is a
  per mille value of the chart data area width.

  This setting only has an effect in bar charts.

  \param gapIsRelative specifies if the value set by \c setDatasetGap
  is a per mille value of the chart data area width.
  \sa datasetGapIsRelative, datasetGap, setDatasetGap
  */


/**
  \fn bool KDChartParams::datasetGapIsRelative() const

  Returns if the value set by \c setDatasetGap
  is a per mille value of the chart data area width.

  This setting only has an effect in bar charts.

  \return if the value set by \c setDatasetGap
  is a per mille value of the chart data area width.
  \sa setDatasetGap, setDatasetGapIsRelative, datasetGap, setDatasetGap
  */


/**
  \fn void KDChartParams::setValueBlockGap( int gap )

  Specifies the number of pixels between each value block.
  If there is only one dataset shown this gap is appearing between each of the bars, otherwise it is appearing between each of the bar blocks.
  In addition you might want to use \c setOutlineDataLineStyle( TQt::NoPen ) to hide the line.

  Also the method \c setDatasetGap might be usefull, please read the information given there ...

  This setting only has an effect in bar charts.

  Use negative values for overlaps (which might look strange),
  use \c setValueBlockGapIsRelative to specify that the \c gap
  value is a per mille value of the chart data area width.

  The default is 15 per mille of the data area of the chart.

  \note Specifying a value block gap width AND a bar width
  may result in KD Chart not being able to display all bars
  if the data area is not wide enough. To make your
  application notice when this
  happens you should consider connecting the
  barsDisplayed() signal emitted by your KDChartWidget object
  to an appropriate slot function.  Additionally (or in case
  you are not using the KDChartWidget class, resp.)
  you may access the number of actually displayed/not displayed
  bars by the KDChartParams functions numBarsDisplayed
  and numBarsLeft, the return value of these functions
  are not not defined if they are called before drawing is done.

  \param gap the number of pixels between each value block.
  \sa setDatasetGap
  \sa setBarWidth, valueBlockGap
  \sa KDChartWidget::barsDisplayed, KDChart::barsDisplayed
  \sa numBarsDisplayed, numBarsLeft
  \sa valueBlockGapIsRelative, setValueBlockGapIsRelative
  \sa setOutlineDataLineStyle
  */


/**
  \fn int KDChartParams::valueBlockGap() const

  Returns the number of pixels between each value block.

  This setting only has an effect in bar charts.

  \note Negative values signify overlaps, use \c valueBlockGapIsRelative
  to find out if the \valueBlockGap value is a per mille value of the
  chart data area width.

  \return the number of pixels between each value block.
  \sa valueBlockGap
  \sa valueBlockGapIsRelative, setValueBlockGapIsRelative
  */


/**
  \fn void KDChartParams::setBarWidth( int width )

  Specifies the width of one bar: makes sure that all of
  the bars have exactly the same width.

  This setting only has an effect in bar charts.

  \note Use negative values for to specify that the \c width
  value is a per mille value of the chart data area width,
  use no value or the default KDCHART_AUTO_SIZE
  to (re)activate normal calculation mode making sure that all
  bars fit into the available space but might not look so nice
  if many bars are there.

  \note Specifying a bar width AND a value block gap width
  may result in KD Chart not being able to display all bars
  if the data area is not wide enough. To make your
  application notice when this
  happens you should consider connecting the
  barsDisplayed() signal emitted by your KDChartWidget object
  to an appropriate slot function.  Additionally (or in case
  you are not using the KDChartWidget class)
  you may access the number of actually displayed/not displayed
  bars by the KDChartParams functions numBarsDisplayed
  and numBarsLeft, the return value of these functions
  are not not defined if they are called before drawing is done.

  \param width the width of one bar.
  \sa KDChartWidget::barsDisplayed, KDChart::barsDisplayed
  \sa numBarsDisplayed, numBarsLeft
  \sa setValueBlockGap
  */

/**
  \fn int KDChartParams::barWidth() const

  Returns the width of one bar as set by setBarWidth
  or KDCHART_AUTO_SIZE if setBarWidth
  was never called.

  This setting only has an effect in bar charts.

  \note Negative values signify that the bar width is
  a per mille value of the chart data area width.

  \return the width of one bar as set by setBarWidth
  or KDCHART_AUTO_SIZE if setBarWidth
  was never called.
  \sa setBarWidth
  */

/**
  \fn int KDChartParams::numBarsDisplayed() const

  Returns the number of bars that were displayed last
  time your bar chart was drawn.

  This setting only has an effect in bar charts.

  This can be different from the number of bars you
  actually wanted to display: by specifying both
  the bar width and the value block gap width you
  may controll your chart very well but take the risk
  of not getting all bars drawn if there is not enough
  horizontal space to display them with the given width
  and gap width.

  To quickly determine if all bars were drawn just check
  if the numBarsLeft() function returns a zero value.

  \return the number of bars that were drawn.
  \sa KDChartWidget::barsDisplayed, KDChart::barsDisplayed
  \sa numBarsLeft
  \sa setBarWidth, setValueBlockGap
  */

/**
  \fn int KDChartParams::numBarsLeft() const

  Returns the number of bars that could NOT be painted
  last time your bar chart was drawn.

  This setting only has an effect in bar charts.

  If this value is greater than zero, the bar chart
  shows less bars than you
  actually wanted to display: by specifying both
  the bar width and the value block gap width you
  may controll your chart very well but take the risk
  of not getting all bars drawn if there is not enough
  horizontal space to display them with the given width
  and gap width.

  You may call the numBarsDisplayed() function to see
  how many bars were drawn.

  \return the number of bars that could not be drawn.
  \sa KDChartWidget::barsDisplayed, KDChart::barsDisplayed
  \sa numBarsDisplayed
  \sa setBarWidth, setValueBlockGap
  */

/**
  \fn void KDChartParams::setValueBlockGapIsRelative( bool gapIsRelative )

  Specifies if the value set by \c setValueBlockGap is a
  per mille value of the chart data area width.

  This setting only has an effect in bar charts.

  \param gapIsRelative specifies if the value set by \c setValueBlockGap
  is a per mille value of the chart data area width.
  \sa valueBlockGapIsRelative, valueBlockGap, setValueBlockGap
  */


/**
  \fn bool KDChartParams::valueBlockGapIsRelative() const

  Returns if the value set by \c setValueBlockGap
  is a per mille value of the chart data area width.

  This setting only has an effect in bar charts.

  \return if the value set by \c setValueBlockGap
  is a per mille value of the chart data area width.
  \sa setValueBlockGapIsRelative, setValueBlockGap, valueBlockGap
  \sa setValueBlockGap
  */


/**
   \fn void KDChartParams::setDrawSolidExcessArrows( bool solidArrows )

   Specifies whether arrows showing excess values in bar charts should
   be drawn solidly or split.

  This setting only has an effect in bar charts.

   If \a solidArrows is true, the bars with excess values (like
   infinity, or any other value that exceeds the y-axis labelling) will
   have an integrated arrow head. If \a solidArrows is false, they will
   still have an integrated arrow head at a lower position, but also
   two flat arrows on top of them to better indicate that there could
   be a large gap. It is recommended to set this value to false (this
   is also the default), as this makes the excess value situation much
   more obvious.

   This setting only has an effect in bar charts.

   \param solidArrows whether excess arrows shown be drawn solidly or
   split
   \sa drawSolidExcessArrows
*/


/**
   \fn bool KDChartParams::drawSolidExcessArrows() const

   Returns whether arrows showing excess values in bar charts should
   be drawn solidly or split.

   This setting only has an effect in bar charts.

   \return true if excess arrows are drawn solidly, false if they are
   split
   \sa setDrawSolidExcessArrows
*/


//@}
// END BARCHART

// START LINECHART
/** @name Line and area chart-specific methods.

  These methods query and set line and area chart-specific parameters.
  */
//@{

/**
  \enum KDChartParams::LineChartSubType

  The line subtype. Only used when chartType == Line

  \sa setLineChartSubType, lineChartSubType
  */


/**
  \fn void KDChartParams::setLineChartSubType( LineChartSubType lineChartSubType )

  Specifies the line chart subtype. Only used if chartType() ==
  Line. The default is LineNormal.

  \param lineChartSubType the line chart subtype
  \sa lineChartSubType, LineChartSubType, setChartType, chartType
  */


/**
  \fn KDChartParams::LineChartSubType KDChartParams::lineChartSubType() const

  Returns the line chart subtype. Only used if chartType() ==
  Line.

  \return the line chart sub type
  \sa setLineChartSubType, LineChartSubType, setChartType, chartType
  */



/**
  \fn void KDChartParams::setLineMarker( bool marker )

  Specifies whether there should be a marker at each data
  point. Only used if chartType() == Line and if threeDLines() ==
  false. The default is not to draw markers.

  \note Use the setLineMarkerStyle function to specify the shape
  of the markers, use the setLineWidth function to set the
  width of the lines connecting the markers (or to surpress
  drawing of such lines, resp.)

  \param marker true if markers should be drawn
  \sa setLineMarker, setLineMarkerSize
  \sa setLineMarkerStyle, setLineColor, setLineWidth, setLineStyle
  */


/**
  \fn bool KDChartParams::lineMarker() const

  Returns whether line markers should be drawn at each data
  point. Only used if chartType() == Line and if threeDLines() ==
  false.

  \return true if markers should be drawn.
  */


/**
  \enum KDChartParams::LineMarkerStyle

  The available line marker styles.
  */


/**
  Specifies the line marker to be used for a dataset. Only used if
  chartType() == Line and lineMarker() == true. If you specify a
  marker for a dataset, but not for a dataset with a lower
  value, then the marker for the dataset with the lower value
  will be undefined unless it was previously defined. The default
  is a circle for the first dataset, a square for the second, a
  diamond for the third and undefined for all subsequent
  datasets.

  \note Extra marker styles LineMarker1Pixel and LineMarker4Pixels
  are intended for drawing charts representing large numbers
  of data cells, when using these styles it might be a good
  idea to set the line width to zero. This would surpress
  drawing of the lines resulting in drawing the markers only.

  \param dataset the dataset for which to set the line marker
  \param style the style to set for the specified dataset
  \sa LineMarkerStyle, lineMarkerStyle, setLineMarkerSize
  \sa setLineColor, setLineWidth, setLineStyle
  */
void KDChartParams::setLineMarkerStyle( uint dataset, LineMarkerStyle style )
{
    _lineMarkerStyles[ dataset ] = style;
    _maxDatasetLineMarkerStyle = TQMAX( dataset,
            _maxDatasetLineMarkerStyle );
    emit changed();
}

/**
  Returns the marker to be used for a dataset. Only used if
  chartType() == Line and lineMarker() == true.

  \param dataset the dataset for which to return the line marker
  \return the line marker for the specified data set
  \sa LineMarkerStyle, setLineMarkerStyle
  */
KDChartParams::LineMarkerStyle KDChartParams::lineMarkerStyle( uint dataset ) const
{
    if( _lineMarkerStyles.find( dataset ) != _lineMarkerStyles.end() )
        return _lineMarkerStyles[ dataset ];
    else
        return LineMarkerCircle; // default
}




/**
  \var KDChartParams::LineMarkerStyleMap;

  The type of the storage structure for line marker styles. You
  should normally not need to use this.
  */


/**
  Sets a whole map of line marker styles. You can use this for
  assigning many line marker styles at the same time, but
  typically it is better to set them individually with \a
  setLineMarkerStyle().

  \param map the map of styles
  \sa lineMarkerStyles, setLineMarker, setLineMarkerStyle, setLineMarkerSize
  \sa setLineColor, setLineWidth, setLineStyle
  */
void KDChartParams::setLineMarkerStyles( LineMarkerStyleMap map ) {
    _lineMarkerStyles = map;
    // update _maxDatasetLineMarkerStyle
    uint maxDataset = 0;
    for( LineMarkerStyleMap::ConstIterator it = _lineMarkerStyles.begin();
            it != _lineMarkerStyles.end(); ++it )
        maxDataset = TQMAX( maxDataset, it.key() );
    _maxDatasetLineMarkerStyle = maxDataset;
}


/**
  \fn KDChartParams::LineMarkerStyleMap KDChartParams::lineMarkerStyles() const

  Returns the whole map of line marker styles. You will typically
  not need this. You can query individual line marker styles by
  calling \a lineMarkerStyle().

  \return the map of styles
  \sa lineMarkerStyle, setLineMarkerStyles
  */


/**
  \fn uint KDChartParams::maxDatasetLineMarkerStyle() const


  Returns the highest dataset for which a line marker style has been
  defined. Not all datasets with a lower number necessarily have
  a defined line marker.

  \return the highest dataset with a defined line marker
  \sa LineMarkerStyle, setLineMarkerStyle, lineMarkerStyle
  */


/**
  \fn void KDChartParams::setLineMarkerSize( TQSize size )

  Specifies the sizes of line markers. Only used if chartType() == Line
  and lineMarker() == true. The default is 6x6.

  Negative values of \c size.width() and/or \c size.height() will
  be  interpreted as per-mille value of the chart's drawing area,
  the true marker width (or height, resp.) will then be calculated
  dynamically depending on the actual chart size.

  \param size the size of the line marker in pixels
  \sa lineMarkerSize, setLineMarker, setLineMarkerStyle
  \sa setLineColor, setLineWidth, setLineStyle
  */


/**
  \fn TQSize KDChartParams::lineMarkerSize() const

  Returns the sizes of line markers. Only used if chartType() == Line and
  lineMarker() == true.

  \return the size of the line marker in pixels
  \sa setLineMarkerSize
  */


/**
  \fn void KDChartParams::setLineWidth( int width )

  Specifies the width for lines in line charts. Default is 1.
  Only used if threeDLines() == false.

  If \c width is negative it is interpreted as per-mille
  value of the chart's drawing area, the true line width
  will then be calculated dynamically depending on the
  actual chart size.

  \note Set the line width to zero to surpress drawing of the lines
  but do not forget to call setLineMarker( true ) and specify an
  appropriate marker style to have the data points drawn.

  \param width the new width
  \sa lineWidth, setLineColor, setLineStyle
  \sa setLineMarker, setLineMarkerSize, setLineMarkerStyle
  */


/**
  \fn int KDChartParams::lineWidth() const

  Returns the line width of the lines in line charts.

  \return the line width of lines in line charts
  \sa lineWidth
  */


/**
  \fn void KDChartParams::setLineColor( TQColor color = TQColor() )

  Specifies the color of the lines in line charts. By default
  line chart lines are drawn in the color specified by the
  respective setDataColor function, to reset your chart to
  this default just call setLineColor() without specifying a
  parameter.

  \note Setting the line color to a special value is usefull to
  visualize gaps in a normally very narrow series of data values.

  e.g. You might want to specify setLineMarkerStyle( i, LineMarker4Pixels )
  or even setLineMarkerStyle( i, LineMarker1Pixel ) and have your
  marker dots normally form a contiguous line without the need of
  any connecting lines except at the places where missing data
  values would interrupt the 'line'. Using setLineColor( TQt::darkGray)
  could make your chart more readable in such cases.

  \param color of the lines in line charts
  \sa lineColor, setLineWidth, setLineStyle
  \sa setLineMarker, setLineMarkerSize, setLineMarkerStyle
  */


/**
  \fn TQColor KDChartParams::lineColor() const

  Returns the color of the lines in line charts.

  \return the color of the lines in line charts
  \sa setLineColor
  */


/**
  Specifies a line style to be used for line charts.

  The dataset parameter is optional, by default saying
  KDCHART_GLOBAL_LINE_STYLE, you may use it to
  set a  dataset specific line style for one the lines.

  Global and dataset specific line styles may be used
  simultaneously: If no dataset specific style is
  defined the global style is used which by default
  is TQt::SolidLine.

  Warning: On Windows 95/98, the style setting (other
  than NoPen and SolidLine) has no effect for lines with width greater
  than 1, due to a bug in the operating system.

  \param style the line style of the line
  \param dataset the number of the dataset controlling the respective line
  \sa lineStyle, setLineWidth, setLineColor
  \sa setLineMarker, setLineMarkerSize, setLineMarkerStyle
  */
void KDChartParams::setLineStyle( TQt::PenStyle style, uint dataset )
{
    if( KDCHART_GLOBAL_LINE_STYLE == dataset )
        _lineStyle = style;
    else
        _datasetLineStyles[ dataset ] = style;
    emit changed();
}

/**
  Returns the line style of one of the lines in a line chart
  or the global line style if no style was specified for the
  dataset or if the optional dataset parameter has its default
  value KDCHART_GLOBAL_LINE_STYLE.

  Warning: On Windows 95/98, the style setting (other than NoPen and
  SolidLine) has no effect for lines with width greater than 1, due
  to a bug in the operating system.

  \param dataset the dataset for which to return the line style
  \return the line style for the specified data set
  \sa setLineStyle, setLineMarkerStyle
  */
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::setThreeDLines( bool threeD )

  Specifies whether lines should be drawn three-dimensionally or
  not. The default is to draw two-dimensionally. Only used if
  chartType() == Line.

  \param threeD if true, draw three-dimensionally, otherwise draw
  two-dimensionally.
  \sa threeDLines(), setThreeDLineDepth(), threeDLineDepth(),
//   setThreeDLineXRotation(), threeDLineXRotation(),
//   setThreeDLineYRotation(), threeDLineYRotation()
*/


/**
  \fn bool KDChartParams::threeDLines() const

  Returns whether lines are drawn three-dimensionally or not. The
  default is to draw two-dimensionally. Only used if chartType() ==
  Line.

  \return true if lines are drawn three-dimensionally, false
  otherwise.
  \sa setThreeDLines(), setThreeDLineDepth(), threeDLineDepth(),
//   setThreeDLineXRotation(), threeDLineXRotation(),
//   setThreeDLineYRotation(), threeDLineYRotation()
*/


/**
  \fn void KDChartParams::setThreeDLineDepth( int depth )

  Specifies the depth of 3D lines (the "width" in Z
  direction). Only used if chartType() == Line and threeDLines() ==
  true. The default is 20 pixels.

  \param depth the depth in pixels
  \sa setThreeDLines(), threeDLines(), threeDLineDepth()
  */


/**
  \fn int KDChartParams::threeDLineDepth() const

  Returns the depth of 3D lines (the "width" in Z direction). Only
  used if chartType() == Line and threeDLines() == true. The
  default is 20 pixels.

  \return the depth in pixels
  \sa setThreeDLines(), threeDLines(), setThreeDLineDepth()
  */


/**
  \fn void KDChartParams::setThreeDLineXRotation( int degrees )

  \deprecated Feature scheduled for future release, at present not implemented.
  */
/*
   \fn void KDChartParams::setThreeDLineXRotation( int degrees )

   Specifies the rotation around the X axis in degrees. The value
   may be between 0 and 90. Only used if chartType() == Line and
   threeDLines() == true. The default is 30 degrees. If 0 degrees is
   specified for both the X and the Y rotation, the lines will look
   like 2D lines.

   \param rotation the rotation in degrees. Must be between 0 and
   90.
   \sa setThreeDLines(), threeDLines(), threeDLineXRotation()
   */



/**
  \fn int KDChartParams::threeDLineXRotation() const

  \deprecated Feature scheduled for future release, at present not implemented.
  */
/*
   \fn int KDChartParams::threeDLineXRotation() const

   Returns the rotation around the X axis in degrees. The value may
   be between 0 and 90. Only used if chartType() == Line and
   threeDLines() == true. The default is 30 degrees.

   \return the rotation in degrees. Is always between 0 and 90.
   */


/**
  \fn void KDChartParams::setThreeDLineYRotation( int degrees )

  \deprecated Feature scheduled for future release, at present not implemented.
  */
/*
   \fn void KDChartParams::setThreeDLineYRotation( int degrees )

   Specifies the rotation around the Y axis in degrees. The value
   may be between 0 and 90. Only used if chartType() == Line and
   threeDLines() == true. The default is 30 degrees. If 0 degrees is
   specified for both the X and the Y rotation, the lines will look
   like 2D lines.

   \param rotation the rotation in degrees. Must be between 0 and
   90.
   \sa setThreeDLines(), threeDLines(), threeDLineYRotation()
   */

/**
  \fn int KDChartParams::threeDLineYRotation() const

  \deprecated Feature scheduled for future release, at present not implemented.
  */
/*
   \fn int KDChartParams::threeDLineYRotation() const

   Returns the rotation around the X axis in degrees. The value may
   be between 0 and 90. Only used if chartType() == Line and
   threeDLines() == true. The default is 30 degrees.

   \return the rotation in degrees. Is always between 0 and 90.
   */


/**
  \enum KDChartParams::AreaChartSubType

  The area subtype. Only used when chartType == Area

  \sa setAreaChartSubType, areaChartSubType
  */


/**
  \fn void KDChartParams::setAreaChartSubType( AreaChartSubType areaChartSubType )

  Specifies the area chart subtype. Only used if chartType() ==
  Area. The default is AreaNormal.

  \param areaChartSubType the area chart subtype
  \sa areaChartSubType, AreaChartSubType, setChartType, chartType
  */


/**
  \fn KDChartParams::AreaChartSubType KDChartParams::areaChartSubType() const


  Returns the area chart subtype. Only used if chartType() ==
  Area.

  \return the area chart sub type
  \sa setAreaChartSubType, AreaChartSubType, setChartType, chartType
  */


/**
  \enum KDChartParams::AreaLocation

  Specifies whether the area above the value points or below the
  value points should be filled. The default is to fill below the
  value points.

  \sa setAreaLocation(), areaLocation()
  */


/**
  \fn void KDChartParams::setAreaLocation( AreaLocation location )

  Specifies whether the area above or below the value points
  should be filled. The default is to fill below the value
  points.

  This setting is <em>not</em> used with percent areas
  (i.e. areaChartSubType() == AreaPercent), because these always
  cover the whole chart.

  \param location whether to fill above or below the value points
  \sa AreaLocation, areaLocation()
  */


/**
  \fn KDChartParams::AreaLocation KDChartParams::areaLocation() const

  Returns whether the area above or below the value points is
  filled.

  \return whether the area above or below the value points is
  filled.
  \sa AreaLocation, setAreaLocation()
  */


//@}
// END LINECHART

// START POLARCHART
/** @name Polar chart-specific methods.

  These methods query and set polar chart-specific parameters.
  */
//@{


/**
  \enum KDChartParams::PolarChartSubType

  The polar subtype. Only used when chartType == Polar

  \sa setPolarChartSubType, polarChartSubType
  */


/**
  \fn void KDChartParams::setPolarChartSubType( PolarChartSubType polarChartSubType )

  Specifies the polar chart subtype. Only used if chartType() ==
  Polar. The default is PolarNormal.

  \param polarChartSubType the polar chart subtype
  \sa polarChartSubType, PolarChartSubType, setChartType, chartType
  */


/**
  \fn KDChartParams::PolarChartSubType KDChartParams::polarChartSubType() const

  Returns the polar chart subtype. Only used if chartType() ==
  Polar.

  \return the polar chart sub type
  \sa setPolarChartSubType, PolarChartSubType, setChartType, chartType
  */


/**
  \fn void KDChartParams::setPolarMarker( bool marker )

  Specifies whether there should be a marker at each data
  point. Only used if chartType() == Polar. The default is not to
  draw markers.

  \param marker true if markers should be drawn
  */


/**
  \fn bool KDChartParams::polarMarker() const

  Returns whether polar markers should be drawn at each data
  point. Only used if chartType() == Polar.

  \return true if markers should be drawn.
  */


/**
  \enum KDChartParams::PolarMarkerStyle

  The available polar marker styles.
  */


/**
  Specifies the polar marker to be used for a dataset. Only used if
  chartType() == Polar and polarMarker() == true. If you specify a
  marker for a dataset, but not for a dataset with a lower
  value, then the marker for the dataset with the lower value
  will be undefined unless it was previously defined. The default
  is a circle for the first dataset, a square for the second, a
  diamond for the third and undefined for all subsequent
  datasets.

  \param dataset the dataset for which to set the polar marker
  \param style the style to set for the specified dataset
  \sa PolarMarkerStyle, polarMarkerStyle
  */
void KDChartParams::setPolarMarkerStyle( uint dataset, PolarMarkerStyle style )
{
    _polarMarkerStyles[ dataset ] = style;
    _maxDatasetPolarMarkerStyle = TQMAX( dataset,
            _maxDatasetPolarMarkerStyle );
    emit changed();
}

/**
  Returns the marker to be used for a dataset. Only used if
  chartType() == Polar and polarMarker() == true.

  \param dataset the dataset for which to return the polar marker
  \return the polar marker for the specified data set
  \sa PolarMarkerStyle, setPolarMarkerStyle
  */
KDChartParams::PolarMarkerStyle KDChartParams::polarMarkerStyle( uint dataset ) const
{
    if( _polarMarkerStyles.find( dataset ) != _polarMarkerStyles.end() )
        return _polarMarkerStyles[ dataset ];
    else
        return PolarMarkerCircle; // default
}


/**
  \var KDChartParams::PolarMarkerStyleMap

  The type of the storage structure for polar marker styles. You
  should normally not need to use this.
  */



/**
  Sets a whole map of polar marker styles. You can use this for
  assigning many polar marker styles at the same time, but
  typically it is better to set them individually with \a
  setPolarMarkerStyle().

  \param map the map of styles
  \sa polarMarkerStyles(), setPolarMarkerStyle()
  */
void KDChartParams::setPolarMarkerStyles( PolarMarkerStyleMap map ) {
    _polarMarkerStyles = map;
    // update _maxDatasetPolarMarkerStyle
    uint maxDataset = 0;
    for( PolarMarkerStyleMap::ConstIterator it = _polarMarkerStyles.begin();
            it != _polarMarkerStyles.end(); ++it )
        maxDataset = TQMAX( maxDataset, it.key() );
    _maxDatasetPolarMarkerStyle = maxDataset;
}


/**
  \fn KDChartParams::PolarMarkerStyleMap KDChartParams::polarMarkerStyles() const

  Returns the whole map of polar marker styles. You will usually
  not need this. You can query individual polar marker styles by
  calling \a polarMarkerStyle().

  \return the map of styles
  \sa polarMarkerStyle(), setPolarMarkerStyles()
  */


/**
  \fn uint KDChartParams::maxDatasetPolarMarkerStyle() const

  Returns the highest dataset for which a polar marker style has been
  defined. Not all datasets with a lower number necessarily have
  a defined polar marker.

  \return the highest dataset with a defined polar marker
  \sa PolarMarkerStyle, setPolarMarkerStyle, polarMarkerStyle
  */


/**
  \fn void KDChartParams::setPolarMarkerSize( TQSize )

  Specifies the sizes of polar markers. Only used if chartType() == Polar
  and polarMarker() == true. The default is -40 x -40.

  \param size the size of the polar marker in pixels, if negative this is a
  per mille value of the chart min. size (the chart width or height, depending
  what is smaller), if positive the value is taken as absolute number of pixels.

  \sa polarMarkerSize
  */


/**
  \fn TQSize KDChartParams::polarMarkerSize() const

  Returns the sizes of polar markers. Only used if chartType() ==
  Polar and polarMarker() == true.

  \return the size of the polar marker in pixels
  \sa setPolarMarkerSize
  */


/**
  \fn void KDChartParams::setPolarLineWidth( int width )

  Specifies the width for lines in polar charts. Default is -3.

  \param width the new width
  \sa polarLineWidth
  */


/**
  \fn int KDChartParams::polarLineWidth() const

  Returns the line width of the lines in polar charts.

  \return the line width of lines in polar charts
  \sa setPolarLineWidth
  */


/**
  \fn void KDChartParams::setPolarZeroDegreePos( int degrees )

  Specifies the zero degree position in polar charts.

  Use this function to have the zero degree point on a position
  different from the right side of the circle. Valid parameters
  are -359..359.

  \sa polarZeroDegreePos
  */


/**
  \fn int KDChartParams::polarZeroDegreePos() const

  Returns the zero degree position in polar charts.

  \sa setPolarZeroDegreePos
  */


/**
  \fn void KDChartParams::setPolarRotateCircularLabels( bool rotateCircularLabels )

  Specifies whether to rotate circular labels in polar charts.

  \sa polarRotateCircularLabels, setPolarDelimsAndLabelsAtPos
  */


/**
  \fn bool KDChartParams::polarRotateCircularLabels() const

  Returns whether circular labels will be rotated in polar charts.

  \sa setPolarRotateCircularLabels, polarDelimAtPos, polarLabelsAtPos
  */


/**
  Specifies whether to show circular delimiters and labels at a given
  position in polar charts.

  \note Value \c KDChartEnums::PosCenter will be ignored.

  \sa setPolarRotateCircularLabels, polarDelimAtPos, polarLabelsAtPos
  */
void KDChartParams::setPolarDelimsAndLabelsAtPos( KDChartEnums::PositionFlag pos,
        bool showDelimiters,
        bool showLabels )
{
    if( KDCHART_MAX_POLAR_DELIMS_AND_LABELS_POS >= pos ) {
        _polarDelimsAndLabels[ pos ].showDelimiters = showDelimiters;
        _polarDelimsAndLabels[ pos ].showLabels     = showLabels;
    }
}

/**
  Returns whether to show circular delimiters at a given
  position in polar charts.

  \sa polarRotateCircularLabels, setPolarDelimAndLabelsPos, polarLabelsAtPos
  */
bool KDChartParams::polarDelimAtPos( KDChartEnums::PositionFlag pos ) const
{
    if( KDCHART_MAX_POLAR_DELIMS_AND_LABELS_POS >= pos )
        return _polarDelimsAndLabels[ pos ].showDelimiters;
    else
        return false;
}

/**
  Returns whether to show circular labels at a given
  position in polar charts.

  \sa polarRotateCircularLabels, setPolarDelimAndLabelsPos, polarDelimAtPos
  */
bool KDChartParams::polarLabelsAtPos( KDChartEnums::PositionFlag pos ) const
{
    if( KDCHART_MAX_POLAR_DELIMS_AND_LABELS_POS >= pos )
        return _polarDelimsAndLabels[ pos ].showLabels;
    else
        return false;
}



//@}
// END LINECHART

// START RING/PIECHART
/** @name Ring and pie chart-specific methods.

  These methods query and set ring and pie chart-specific parameters.
  */
//@{

/**
  \fn void KDChartParams::setExplode( bool explode )

  Specifies whether the pie chart or ring chart should be
  exploding (all pies or ring segments are slightly displaced
  from the center) or not. The default is not to explode. Only
  used if chartType() == Pie or chartType() == Ring.

  Note that calling this method by passing true turns on
  exploding for all segments. You can turn exploding on and off
  for individual segments by calling setExplodeValues() and also
  change the explode factors by calling setExplodeFactor() or
  setExplodeFactors().

  Note that in ring charts, only the outermost ring is
  exploded. Also note that exploding rings are only useful if
  none of the values in the outermost dataset covers more than
  1/4 of the ring, otherwise the exploded ring will look funny.

  \param explode true if the pie or ring should be exploding,
  false otherwise
  \sa exploding(), setExplodeFactor(), explodeFactor(),
  setExplodeFactors(), explodeFactors(), setExplodeValues(),
  explodeValues()
  */


/**
  \fn bool KDChartParams::explode() const

  Returns whether the pie or ring chart should be exploding or not

  \return true if the pie should be exploding
  \sa setExplode, setExplodeFactor(), explodeFactor(),
  setExplodeFactors(), explodeFactors(), setExplodeValues(),
  explodeValues()
  */


/**
  \fn void KDChartParams::setExplodeValues( TQValueList<int> explodeList )

  Specifies which values to explode. Explosion of values only
  happens if setExplode( true ) has been called. Normally, all
  values are exploded (all values on the outer ring in the case of a
  ring chart). With this function, you have a finer control about
  the explosion. You can specify the values that should be exploded
  by their position. Passing an empty list here turns on explosion
  for all pies or ring segments (but only if explosion is turned on
  in general).

  To repeat: Setting anything here has no effect if setExplode( true )
  is not called. You can, however, set any values here even if explosion is
  not turned on; they will be saved in case explosion will be turned on in
  the future and then be valid automatically.

  The explode factor, i.e., the amount with which a segment is moved
  from the center can either be set for all segments with
  \a setExplodeFactor() or for individual segments with
  \a setExplodeFactors(). The default is 10%.

  \param explodeList the list of positions in the displayed dataset that
  should be drawn in an exploded position. Pass an empty list here to
  explode all values.
  \sa setExplode(), explode(), setExplodeFactor(), explodeFactor(),
  explodeValues(), setExplodeFactors(), explodeFactors()
  */


/**
  \fn TQValueList<int> KDChartParams::explodeValues() const

  Returns which values are exploded in a pie or ring chart. For a detailed
  explanation of this feature, please see \a setExplodeValues().

  \return the list of values that are exploded
  \sa setExplode(), explode(), setExplodeFactor(), explodeFactor(),
  setExplodeValues()
  */


/**
  \fn void KDChartParams::setExplodeFactors( TQMap<int,double> factors )

  Specifies the explode factors for each segment in percent,
  i.e. how much an exploded pie or ring segment is displaced from
  the center. The factor is given as a double value between 0 and 1;
  0.1 means 10%. Only used if chartType() == Pie or chartType() ==
  Ring and explode() == true.

  Segments that are not contained in the map specified here will
  have the default explode factor of 10%, if exploding is turned on
  for them at all. This also means that passing an empty list to
  this method does not turn off exploding in general; use \a
  setExplode( false ) for that.

Note: This method has no immediate effect if setExplode( true )
has not been called. It is, however, possible to preset explode
factors and then turn on exploding later.

Note: Besides giving a segment an explode factor and turning on
exploding in general, you also need to specify to explode a
certain segment by calling \a setExplodeValues(). This gives maximum
flexibility as it allows you to preset explode factors and then
explode or not not explode a segment at leisure - at the expense
of one more method call.

\param factors the list of explode factors
\sa setExplode(), explode(), setExplodeValues(), explodeValues(),
setExplodeFactor(), explodeFactor(), explodeFactors()
*/


/**
  \fn TQMap<int,double> KDChartParams::explodeFactors() const {

  Returns the list of explode factors. Each explode factor in the
  list corresponds to the segment at the same position.

  \return the list of explode factors
  \sa setExplode(), explode(), setExplodeValues(), explodeValues(),
  setExplodeFactor(), explodeFactor(), setExplodeFactors()
  */


/**
  \fn void KDChartParams::setExplodeFactor( double factor )

  Specifies the explode factor in percent, i.e. how much an
  exploded pie or ring segment is displaced from the center. The
  factor is given as a double value between 0 and 1; 0.1 means
  10% and is the default. Only used if
  chartType() == Pie or chartType() == Ring and explode() == true.

  Note that this method sets the explode factor for all segments
  that are exploded but for which no more specific explode factor
  has been set with \a setExplodeFactors(). Thus, to make the value
  specified here the default value, you can pass an empty list to
  \a setExplodeFactors() (which also is the default).

  \param factor the explode factor
  \sa setExplode(), explode(), explodeFactor(),
  setExplodeValues(), explodeValues(), setExplodeFactors(),
  explodeFactors()
  */


/**
  \fn double KDChartParams::explodeFactor() const

  Returns the default explode factor, i.e., the explode factor
  used for those segments which should be exploded but for which
  no more specific explode factor has been set. See \a
  setExplodeFactor() for an explanation of the value.

  \return the explode factor
  \sa setExplodeFactor(), setExplode(), explode()
  */


/**
  \fn void KDChartParams::setThreeDPies( bool threeDPies )

  Specifies whether the engine should draw the pies in 3D. Only
  used if chartType() == Pie.

  \param threeDPies true if pies should be drawn with a 3D effect
  \sa threeDPies(), setThreeDPieHeight(), threeDPieHeight()
  */


/**
  \fn bool KDChartParams::threeDPies() const

  Returns whether the engine should draw any pies in 3D. Only
  used if chartType() == Pie.

  \return true if pies should be drawn with a 3D effect, false
  otherwise
  \sa setThreeDPies(), threeDPieHeight(), setThreeDPieHeight()
  */


/**
  \fn void KDChartParams::setThreeDPieHeight( int pixels )

  Specifies the height of the 3D effect for pies in pixels. Only used if
  chartType() == Pie and threeDPies() == true. Negative values are
  interpreted relative to the height of the pie where -100 means
  that the 3D effect has the same height as the pie itself; values
  smaller than -25 are hardly useful. Positive values are
  interpreted as absolute sizes in pixels. The default is an
  absolute value of 20 pixels.

  \param height the height of the 3D effect in pixels
  \sa threeDHeight(), setThreeDPies(), threeDPies()
  */


/**
  \fn int KDChartParams::threeDPieHeight() const

  Returns the height of the 3D effect for pies in pixels. See \a
  setThreeDPieHeight for the interpretation of the value.

  \return the height of the 3D effect in pixels
  \sa setThreeDPieHeight(), setThreeDPies(), threeDPies()
  */


/**
  \fn void KDChartParams::setPieStart( int degrees )

  Specifies the starting point of the pie circle. The default is the 3 o'
  clock position which equals to 0. Positive values are angles in degrees
  counterclockwise, negative values are angles in degrees
  clockwise. All values will be normalized to [0;360[.

  \param degrees the starting point in degrees
  \sa pieStart()
  */


/**
  \fn int KDChartParams::pieStart() const

  Returns the starting point of the pie circle. See \a setPieStart() for
  the interpretation of these values. The return value is
  always in the interval [0;360[

  \return the starting point of the pie circle in degrees
  \sa setPieStart()
  */


/**
  \fn void KDChartParams::setRingStart( int degrees )

  Specifies the starting point of the ring circle. The default is the 3 o'
  clock position which equals to 0. Positive values are angles in degrees
  counterclockwise, negative values are angles in degrees
  clockwise. All values will be normalized to [0;360[.

  \param degrees the starting point in degrees
  \sa pieStart()
  */


/**
  \fn int KDChartParams::ringStart() const

  Returns the starting point of the ring circle. See \a
  setRingStart() for the interpretation of these values. The
  return value is always in the interval [0;360[

  \return the starting point of the ring circle in degrees
  \sa setRingStart()
  */


/**
  \fn void KDChartParams::setRelativeRingThickness( bool relativeThickness )

  Specifies whether the ring thickness should be relative to the sum of the
  values in the dataset that the ring represents. The default is to have all
  the rings with the same thickness which itself depends on the size of the
  chart and the number of rings.

  \param relativeThickness if true, ring thickness is relative, if false, it
  is constant.
  \sa relativeThickness()
  */


/**
  \fn bool KDChartParams::relativeRingThickness() const

  Returns whether the ring thickness is relative to the sum of values in the
  dataset that the ring represents, or whether the ring thickness should be
  constant.

  \return true if thickness is relative, false if it is constant
  \sa setRelativeRingThickness()
  */



//@}
// END RING/PIECHART

// START HILO CHART
/** @name Hi-lo chart-specific methods.

  These methods query and set hi-lo chart-specific parameters.
  */
//@{

/**
  \enum KDChartParams::HiLoChartSubType

  The HiLo subtype. Only used when chartType == HiLo

  \sa setHiLoChartSubType, hiLoChartSubType
  */

/**
  \fn void KDChartParams::setHiLoChartSubType( HiLoChartSubType hiLoChartSubType )

  Specifies the HiLo chart subtype. Only used if chartType() ==
  HiLo

  \param hiLoChartSubType the HiLo chart subtype
  \sa hiLoChartSubType, HiLoChartSubType, setChartType, chartType
  */


/**
  \fn KDChartParams::HiLoChartSubType KDChartParams::hiLoChartSubType() const

  Returns the HiLo chart subtype. Only used if chartType() ==
  HiLo.

  \return the HiLo chart sub type
  \sa setHiLoChartSubType, HiLoChartSubType, setChartType, chartType
  */


/**
  Specifies if and how a HiLo chart will print the Low
  values below their respective entries. Only used if chartType() == HiLo

  \note <b>setHiLoChartPrintLowValues( false )</b> will
  deactivate printing of Low values.

  \param active specifies whether the values are to be printed or not.
  \param font a Pointer to the font to be used.
  \param size (in per mille of the chart width) the dynamic size of
  the font to be used. If this parameter is zero the size of the
  \c font is used instead - regardless of the size of the chart!
  \param color the color to be used when printing the values.
  \sa setChartType, chartType
  \sa setHiLoChartSubType, hiLoChartSubType
  \sa setHiLoChartPrintHighValues
  \sa hiLoChartPrintLowValues, hiLoChartPrintLowValues
  \sa hiLoChartLowValuesFontColor, hiLoChartLowValuesFontColor
  \sa hiLoChartLowValuesFontUseRelSize, hiLoChartLowValuesFontUseRelSize
  \sa hiLoChartLowValuesFontRelSize, hiLoChartLowValuesFontRelSize
  \sa hiLoChartPrintHighValues, hiLoChartPrintHighValues
  \sa hiLoChartHighValuesFontColor, hiLoChartHighValuesFontColor
  \sa hiLoChartHighValuesFontUseRelSize, hiLoChartHighValuesFontUseRelSize
  \sa hiLoChartHighValuesFontRelSize, hiLoChartHighValuesFontRelSize
  */
void KDChartParams::setHiLoChartPrintLowValues( bool active, 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();
}


/**
  \fn bool KDChartParams::hiLoChartPrintLowValues() const

  Returns whether the low values
  will be printed under their respective entries.

  \return whether the low values
  will be printed under their respective entries.

  \sa setHiLoChartPrintLowValues, setHiLoChartPrintHighValues
  \sa setHiLoChartSubType, hiLoChartSubType
  \sa setChartType, chartType
  */


/**
  \fn TQFont KDChartParams::hiLoChartLowValuesFont() const

  Returns the font to be used for printing the
  low values

  \returns the font to be used for printing the
  low values

  \sa setHiLoChartPrintLowValues, setHiLoChartPrintHighValues
  \sa setHiLoChartSubType, hiLoChartSubType
  \sa setChartType, chartType
  */


/**
  \fn bool KDChartParams::hiLoChartLowValuesUseFontRelSize() const

  Returns whether the font size to be used for printing the
  low values is calculated dynamically.

  \return whether the font size to be used for printing the
  low values is calculated dynamically.

  \sa setHiLoChartPrintLowValues, setHiLoChartPrintHighValues
  \sa setHiLoChartSubType, hiLoChartSubType
  \sa setChartType, chartType
  */


/**
  \fn int KDChartParams::hiLoChartLowValuesFontRelSize() const

  Returns the relative size (in per mille of the chart width)
  of font size to be used for printing the
  low values.

  \return the relative size (in per mille of the chart width)
  of font size to be used for printing the
  low values.

  \sa setHiLoChartPrintLowValues, setHiLoChartPrintHighValues
  \sa setHiLoChartSubType, hiLoChartSubType
  \sa setChartType, chartType
  */


/**
  \fn TQColor KDChartParams::hiLoChartLowValuesColor() const

  Returns the colour of the font size to be used for printing the
  low values.

  \return the colour of the font size to be used for printing the
  low values.

  \sa setHiLoChartPrintLowValues, setHiLoChartPrintHighValues
  \sa setHiLoChartSubType, hiLoChartSubType
  \sa setChartType, chartType
  */


/**
  Specifies if and how a HiLo chart will print the High
  values below their respective entries.
  Only used if chartType() == HiLo

  \note <b>setHiLoChartPrintHighValues( false )</b> will
  deactivate printing of High values.

  \param active specifies whether the values are to be printed or not.
  \param font specifies a Pointer to the font to be used.
  \param size (in per mille of the chart width) specifies the
  dynamic size of the font to be used. If this parameter is zero
  the size of the
  \c font is used instead - regardless of the size of the chart!
  \param specifies the color the color to be used when printing
  the values.
  \sa setHiLoChartPrintLowValues
  \sa setHiLoChartSubType, hiLoChartSubType
  \sa setChartType, chartType
  \sa hiLoChartPrintHighValues, hiLoChartPrintHighValues
  \sa hiLoChartHighValuesFontColor, hiLoChartHighValuesFontColor
  \sa hiLoChartHighValuesFontUseRelSize, hiLoChartHighValuesFontUseRelSize
  \sa hiLoChartHighValuesFontRelSize, hiLoChartHighValuesFontRelSize
  \sa hiLoChartPrintLowValues, hiLoChartPrintLowValues
  \sa hiLoChartLowValuesFontColor, hiLoChartLowValuesFontColor
  \sa hiLoChartLowValuesFontUseRelSize, hiLoChartLowValuesFontUseRelSize
  \sa hiLoChartLowValuesFontRelSize, hiLoChartLowValuesFontRelSize
  */
void KDChartParams::setHiLoChartPrintHighValues( bool active, 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();
}


/**
  \fn bool KDChartParams::hiLoChartPrintHighValues() const

  Returns whether the high values
  will be printed under their respective entries.

  \return whether the high values
  will be printed under their respective entries.

  \sa setHiLoChartPrintHighValues, setHiLoChartPrintLowValues
  \sa setHiLoChartSubType, hiLoChartSubType
  \sa setChartType, chartType
  */


/**
  \fn TQFont KDChartParams::hiLoChartHighValuesFont() const

  Returns the font to be used for printing the
  high values.

  \returns the font to be used for printing the
  high values.

  \sa setHiLoChartPrintHighValues, setHiLoChartPrintLowValues
  \sa setHiLoChartSubType, hiLoChartSubType
  \sa setChartType, chartType
  */


/**
  \fn bool KDChartParams::hiLoChartHighValuesUseFontRelSize() const

  Returns whether the font size to be used for printing the
  high values is calculated dynamically.

  \return whether the font size to be used for printing the
  high values is calculated dynamically.

  \sa setHiLoChartPrintHighValues, setHiLoChartPrintLowValues
  \sa setHiLoChartSubType, hiLoChartSubType
  \sa setChartType, chartType
  */


/**
  \fn int KDChartParams::hiLoChartHighValuesFontRelSize() const

  Returns the relative size (in per mille of the chart width)
  of font size to be used for printing the
  high values.

  \return the relative size (in per mille of the chart width)
  of font size to be used for printing the
  high values.

  \sa setHiLoChartPrintHighValues, setHiLoChartPrintHighValues
  \sa setHiLoChartSubType, hiLoChartSubType
  \sa setChartType, chartType
  */


/**
  \fn TQColor KDChartParams::hiLoChartHighValuesColor() const

  Returns the colour of the font size to be used for printing the
  high values.

  \return the colour of the font size to be used for printing the
  high values.

  \sa setHiLoChartPrintHighValues, setHiLoChartPrintLowValues
  \sa setHiLoChartSubType, hiLoChartSubType
  \sa setChartType, chartType
  */


/**
  Specifies if and how a HiLo chart will print the Open values
  below their respective entries.
  Only used if chartType() == HiLo and if the HiLo chart sub type
  shows open values.

  \note <b>setHiLoChartPrintOpenValues( false )</b> will
  deactivate printing of Open values.

  \param active specifies whether the values are to be printed or not.
  \param font a Pointer to the font to be used.
  \param size (in per mille of the chart width) the dynamic size of
  the font to be used. If this parameter is zero the size of the
  \c font is used instead - regardless of the size of the chart!
  \param color the color to be used when printing the values.
  \sa setHiLoChartPrintCloseValues
  \sa setHiLoChartSubType, hiLoChartSubType
  \sa setChartType, chartType
  \sa hiLoChartPrintOpenValues, hiLoChartPrintOpenValues
  \sa hiLoChartOpenValuesFontColor, hiLoChartOpenValuesFontColor
  \sa hiLoChartOpenValuesFontUseRelSize, hiLoChartOpenValuesFontUseRelSize
  \sa hiLoChartOpenValuesFontRelSize, hiLoChartOpenValuesFontRelSize
  \sa hiLoChartPrintCloseValues, hiLoChartPrintCloseValues
  \sa hiLoChartCloseValuesFontColor, hiLoChartCloseValuesFontColor
  \sa hiLoChartCloseValuesFontUseRelSize, hiLoChartCloseValuesFontUseRelSize
  \sa hiLoChartCloseValuesFontRelSize, hiLoChartCloseValuesFontRelSize
  */
void KDChartParams::setHiLoChartPrintOpenValues( bool active, 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();
}


/**
  \fn bool KDChartParams::hiLoChartPrintOpenValues() const

  Returns whether the open values will be printed under their
  respective entries.

  \return whether the open values will be printed under their
  respective entries.

  \sa setHiLoChartPrintOpenValues, setHiLoChartPrintCloseValues
  \sa setHiLoChartSubType, hiLoChartSubType
  \sa setChartType, chartType
  */


/**
  \fn TQFont KDChartParams::hiLoChartOpenValuesFont() const

  Returns the font to be used for printing the
  open values.

  \returns the font to be used for printing the
  open values.

  \sa setHiLoChartPrintOpenValues, setHiLoChartPrintCloseValues
  \sa setHiLoChartSubType, hiLoChartSubType
  \sa setChartType, chartType
  */


/**
  \fn bool KDChartParams::hiLoChartOpenValuesUseFontRelSize() const

  Returns whether the font size to be used for printing the
  open values is calculated dynamically.

  \return whether the font size to be used for printing the
  open values is calculated dynamically.

  \sa setHiLoChartPrintOpenValues, setHiLoChartPrintCloseValues
  \sa setHiLoChartSubType, hiLoChartSubType
  \sa setChartType, chartType
  */


/**
  \fn int KDChartParams::hiLoChartOpenValuesFontRelSize() const

  Returns the relative size (in per mille of the chart width)
  of font size to be used for printing the open values.

  \return the relative size (in per mille of the chart width) of
  font size to be used for printing the open values.

  \sa setHiLoChartPrintOpenValues, setHiLoChartPrintCloseValues
  \sa setHiLoChartSubType, hiLoChartSubType
  \sa setChartType, chartType
  */


/**
  \fn TQColor KDChartParams::hiLoChartOpenValuesColor() const

  Returns the colour of the font size to be used for printing the
  open values.

  \return the colour of the font size to be used for printing the
  open values.

  \sa setHiLoChartPrintOpenValues, setHiLoChartPrintCloseValues
  \sa setHiLoChartSubType, hiLoChartSubType
  \sa setChartType, chartType
  */


/**
  Specifies if and how a HiLo chart will print the Close
  values next to their respective entries.
  Only used if chartType() == HiLo and the HiLo chart sub type
  contains Close values.

  \note <b>setHiLoChartPrintCloseValues( false )</b> will
  deactivate printing of Close values.

  \param active specifies whether the values are to be printed or not.
  \param font specifies a Pointer to the font to be used.
  \param size (in per mille of the chart width) specifies the dynamic size of
  the font to be used. If this parameter is zero the size of the
  \c font is used instead - regardless of the size of the chart!
  \param specifies the color the color to be used when printing the values.
  \sa setHiLoChartPrintOpenValues
  \sa setHiLoChartSubType, hiLoChartSubType
  \sa setChartType, chartType
  \sa hiLoChartPrintCloseValues, hiLoChartPrintCloseValues
  \sa hiLoChartCloseValuesFontColor, hiLoChartCloseValuesFontColor
  \sa hiLoChartCloseValuesFontUseRelSize, hiLoChartCloseValuesFontUseRelSize
  \sa hiLoChartCloseValuesFontRelSize, hiLoChartCloseValuesFontRelSize
  \sa hiLoChartPrintOpenValues, hiLoChartPrintOpenValues
  \sa hiLoChartOpenValuesFontColor, hiLoChartOpenValuesFontColor
  \sa hiLoChartOpenValuesFontUseRelSize, hiLoChartOpenValuesFontUseRelSize
  \sa hiLoChartOpenValuesFontRelSize, hiLoChartOpenValuesFontRelSize
  */
void KDChartParams::setHiLoChartPrintCloseValues( bool active, 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();
}

/**
  \fn bool KDChartParams::hiLoChartPrintCloseValues() const

  Returns whether the close values will be printed under their
  respective entries.

  \return whether the close values will be printed under their
  respective entries.

  \sa setHiLoChartPrintCloseValues, setHiLoChartPrintOpenValues
  \sa setHiLoChartSubType, hiLoChartSubType
  \sa setChartType, chartType
  */


/**
  \fn TQFont KDChartParams::hiLoChartCloseValuesFont() const

  Returns the font to be used for printing the close values.

  \returns the font to be used for printing the close values.

  \sa setHiLoChartPrintCloseValues, setHiLoChartPrintOpenValues
  \sa setHiLoChartSubType, hiLoChartSubType
  \sa setChartType, chartType
  */


/**
  \fn bool KDChartParams::hiLoChartCloseValuesUseFontRelSize() const

  Returns whether the font size to be used for printing the close
  values is calculated dynamically.

  \return whether the font size to be used for printing the close
  values is calculated dynamically.

  \sa setHiLoChartPrintCloseValues, setHiLoChartPrintOpenValues
  \sa setHiLoChartSubType, hiLoChartSubType
  \sa setChartType, chartType
  */


/**
  \fn int KDChartParams::hiLoChartCloseValuesFontRelSize() const
  Returns the relative size (in per mille of the chart width) of
  font size to be used for printing the close values.

  \return the relative size (in per mille of the chart width) of
  font size to be used for printing the close values.

  \sa setHiLoChartPrintCloseValues, setHiLoChartPrintOpenValues
  \sa setHiLoChartSubType, hiLoChartSubType
  \sa setChartType, chartType
  */


/**
  \fn TQColor KDChartParams::hiLoChartCloseValuesColor() const

  Returns the colour of the font size to be used for printing the
  close values.

  \return the colour of the font size to be used for printing the
  close values.

  \sa setHiLoChartPrintCloseValues, setHiLoChartPrintOpenValues
  \sa setHiLoChartSubType, hiLoChartSubType
  \sa setChartType, chartType
  */


/**
  \fn void KDChartParams::setHiLoChartPrintFirstValues( bool, TQFont*, uint, TQColor* )

  \obsolete

  This method is obsolete; use \a setHiLoChartPrintOpenValues().
  */


/**
  \fn bool KDChartParams::hiLoChartPrintFirstValues() const

  \obsolete

  This method is obsolete; use \a hiLoChartPrintOpenValues()
  instead.
  */


/**
  \fn TQFont KDChartParams::hiLoChartFirstValuesFont() const

  \obsolete

  This method is obsolete; use \a hiLoChartOpenValuesFont()
  instead.
  */


/**
  \fn bool KDChartParams::hiLoChartFirstValuesUseFontRelSize() const

  \obsolete

  This method is obsolete; use \a
  hiLoChartOpenValuesUseFontRelSize() instead.
  */


/**
  \fn int KDChartParams::hiLoChartFirstValuesFontRelSize() const

  \obsolete

  This method is obsolete; use \a
  hiLoChartOpenValuesFontRelSize() instead.
  */


/**
  \fn TQColor KDChartParams::hiLoChartFirstValuesColor() const

  \obsolete

  This method is obsolete; use \a hiLoChartOpenValuesColor()
  instead.
  */


/**
  \fn void KDChartParams::setHiLoChartPrintLastValues( bool, TQFont*, int, TQColor* )

  \obsolete

  This method is obsolete; use \a setHiLoChartPrintCloseValues()
  instead.
  */


/**
  \fn bool KDChartParams::hiLoChartPrintLastValues() const

  \obsolete

  This method is obsolete; use \a hiLoChartPrintCloseValues()
  instead.
  */


/**
  \fn TQFont KDChartParams::hiLoChartLastValuesFont() const

  \obsolete

  This method is obsolete; use \a hiLoChartCloseValuesFont()
  instead.
  */


/**
  \fn bool KDChartParams::hiLoChartLastValuesUseFontRelSize() const

  \obsolete

  This method is obsolete; use \a hiLoChartCloseValuesUseFontRelSize()
  instead.
  */


/**
  \fn int KDChartParams::hiLoChartLastValuesFontRelSize() const

  \obsolete

  This method is obsolete; use \a hiLoChartCloseValuesFontRelSize()
  instead.
  */


/**
  \fn TQColor KDChartParams::hiLoChartLastValuesColor() const

  \obsolete

  This method is obsolete; use \a hiLoChartCloseValuesColor()
  instead.
  */



//@}
// END HILO CHART

// START BOX/WHISKER CHART
/** @name Box-and-whisker chart-specific methods.

  These methods query and set box-and-whisker chart-specific parameters.
  */
//@{

/**
  \enum KDChartParams::BWChartSubType

  The BoxWhisker subtype. Only used when chartType == BoxWhisker

  \sa setBWChartSubType, bWChartSubType
  */


/**
  \enum KDChartParams::BWStatVal

  The different statistical values that can be printed into or
  asked from a Box and Whisker chart. Only used when chartType == BoxWhisker

  \sa setBWChartSubType, bWChartSubType
  */               // use the following syntax to avoid warnings:


/**
  \fn void KDChartParams::setBWChartSubType( BWChartSubType bWChartSubType )

  Specifies the BoxWhisker chart subtype. Only used if chartType() ==
  BoxWhisker

  \param bWChartSubType the BoxWhisker chart subtype
  \sa bWChartSubType, BWChartSubType, setChartType, chartType
  */


/**
  \fn KDChartParams::BWChartSubType KDChartParams::bWChartSubType() const

  Returns the BoxWhisker chart subtype. Only used if chartType() ==
  BoxWhisker.

  \return the BoxWhisker chart sub type
  \sa setBWChartSubType, BWChartSubType, setChartType, chartType
  */



/**
  Specifies the factors to be used to calculate the position of
  the inner (or outer, resp.) fences.

  Default values for both inner fences are 1.5 times the
  interquartile range from the corresponding quartile,
  for both outer fences default is 3.0 times the IQR.

  \sa bWChartFences
  \sa setBWChartOutValMarkerSize, setBWChartPrintStatistics
  \sa setBWChartSubType, bWChartSubType
  \sa setChartType, chartType
  */
void KDChartParams::setBWChartFences( double upperInner, double lowerInner,
        double upperOuter, double lowerOuter )
{
    _BWChartFenceUpperInner = upperInner;
    _BWChartFenceLowerInner = lowerInner;
    _BWChartFenceUpperOuter = upperOuter;
    _BWChartFenceLowerOuter = lowerOuter;
}
/**
  Retrievs the factors to be used to calculate the position of
  the inner (or outer, resp.) fences.

  \sa setBWChartFences
  \sa setBWChartOutValMarkerSize, setBWChartPrintStatistics
  \sa setBWChartSubType, bWChartSubType
  \sa setChartType, chartType
  */
void KDChartParams::bWChartFences( double& upperInner, double& lowerInner,
        double& upperOuter, double& lowerOuter ) const
{
    upperInner = _BWChartFenceUpperInner;
    lowerInner = _BWChartFenceLowerInner;
    upperOuter = _BWChartFenceUpperOuter;
    lowerOuter = _BWChartFenceLowerOuter;
}


/**
  \fn void KDChartParams::setBWChartBrush( const TQBrush& bWChartBrush )

  Specifies the brush to be used to fill the BoxWhisker charts.

  \param bWChartBrush the brush to be used
  \sa bWChartBrush, setChartType, chartType
  */


/**
  \fn TQBrush KDChartParams::bWChartBrush() const

  Returns the brush to be used to fill the BoxWhisker charts.

  \return the brush to be used
  \sa setBWChartBrush, setChartType, chartType
  */


/**
  \fn void KDChartParams::setBWChartOutValMarkerSize( int size )

  Specifies how big outlier markers (representing the values outside
  the inner fences) will be drawn.

  When specifying a value different from 0 the chart will show the outlier
  markers in the respective size, use zero to disable showing the outliers,
  use negative values to have the marker size calculated dynamically
  (in percent of the current boxes' width).  Thus marker sizes will be
  recalculated after modification of either the number of boxes
  or the size of the entire chart.

  \note Shapes of the outlier markers depend on their distance to the
  respective fence: circles are used to represent near outside values
  while asteriscs indicate far outside values (the ones outside the
  outer fence), you may use setBWChartFences() to specify the factor
  to be used to calculate the value of the inner and outer fence.

  \sa bWChartOutValMarkerSize
  \sa setBWChartFences, setBWChartPrintStatistics
  \sa setBWChartSubType, bWChartSubType
  \sa setChartType, chartType
  */


/**
  \fn int KDChartParams::bWChartOutValMarkerSize() const

  Returns how big outlier markers (representing the values outside
  the inner fences) will be drawn.

  \return how big outside value markers will be drawn, zero means
  they will be invisible, negative values indicate that the size
  is calculated dynamically based upon the current boxes' width.

  \sa setBWChartOutValMarkerSize
  \sa setBWChartFences, setBWChartPrintStatistics
  \sa setBWChartSubType, bWChartSubType
  \sa setChartType, chartType
  */


/**
  Specifies if and how a BoxWhisker chart will print the
  respective statistical values near to the drawing.
  Only used if chartType() == BoxWhisker

  \note <b>setBWChartPrintStatistics( BWStatVal, false )</b> will
  deactivate printing of the respective statistical values.

  \param statValue specifies the statistical value to be set, use
  BWStatValALL to define equal settings for all
  of the statistical values.
  \param active specifies whether the values are to be printed or not.
  \param font a Pointer to the font to be used.
  \param size (relative to the boxes' width) the dynamic size of
  the font to be used. If this parameter is zero the size of the
  \c font is used instead - regardless of the size of the chart
  and regardless of the number of boxes!
  \param color the color to be used when printing the values.
  \param brush the brush to be used to fill the text's area before printing
  \sa setChartType
  \sa setBWChartSubType
  \sa bWChartPrintStatistics
  \sa bWChartStatisticsColor,
  \sa bWChartStatisticsBrush,
  \sa bWChartStatisticsFontUseRelSize
  \sa bWChartStatisticsFontRelSize
  */
void KDChartParams::setBWChartPrintStatistics( BWStatVal statValue,
        bool active,
        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();
}


/**
  \fn bool KDChartParams::bWChartPrintStatistics( BWStatVal statValue ) const

  Returns whether the respective statistical values
  will be printed near to the drawing.

  \return whether the respective statistical values
  will be printed near to the drawing.

  \sa setBWChartPrintStatistics
  \sa setBWChartSubType, bWChartSubType
  \sa setChartType, chartType
  */


/**
  \fn TQFont KDChartParams::bWChartStatisticsFont( BWStatVal statValue ) const

  Returns the font to be used for printing the respective statistical values

  \returns the font to be used for printing the respective statistical values

  \sa setBWChartPrintStatistics
  \sa setBWChartSubType, bWChartSubType
  \sa setChartType, chartType
  */


/**
  \fn bool KDChartParams::bWChartStatisticsUseRelSize( BWStatVal statValue ) const

  Returns whether the font size to be used for printing the respective statistical values
  is calculated dynamically.

  \returns whether the font size to be used for printing the respective statistical values
  is calculated dynamically.

  \sa setBWChartPrintStatistics
  \sa setBWChartSubType, bWChartSubType
  \sa setChartType, chartType
  */


/**
  \fn int KDChartParams::bWChartStatisticsFontRelSize( BWStatVal statValue ) const

  Returns the relative size (in per mille of the chart width)
  of the font to be used for printing the respective statistical values.

  \returns the relative size (in per mille of the chart width)
  of the font to be used for printing the respective statistical values.

  \sa setBWChartPrintStatistics
  \sa setBWChartSubType, bWChartSubType
  \sa setChartType, chartType
  */


/**
  \fn TQColor KDChartParams::bWChartStatisticsColor( BWStatVal statValue ) const

  Returns the colour
  of the font to be used for printing the respective statistical values.

  \returns the colour
  of the font to be used for printing the respective statistical values.

  \sa setBWChartPrintStatistics
  \sa setBWChartSubType, bWChartSubType
  \sa setChartType, chartType
  */


/**
  \fn TQBrush KDChartParams::bWChartStatisticsBrush( BWStatVal statValue ) const

  Returns the brush used
  to fill the text's area before printing the respective statistical values.

  \returns the brush used
  to fill the text's area before printing the respective statistical values.

  \sa setBWChartPrintStatistics
  \sa setBWChartSubType, bWChartSubType
  \sa setChartType, chartType
  */


//@}
// END BOX/WHISKER CHART

// START LEGENDS
/** @name Legend methods.

  These methods query and set legend parameters.
  */
//@{

/**
  \enum KDChartParams::LegendPosition

  The possible positions for a legend. NoLegend turns legend display
  off.

  \sa setLegendPosition, legendPosition
  */


/**
  \fn void KDChartParams::setLegendPosition( LegendPosition position )

  Specifies where the legend should be shown. NoLegend turns legend
  display off. The default is LegendRight which positions the legend
  right to the data display.

  \param the position for the legend
  \sa LegendPosition, legendPosition, setLegendOrientation, setLegendShowLines
  */


/**
  \fn KDChartParams::LegendPosition KDChartParams::legendPosition() const

  Returns where the legend will be shown.

  \return where the legend will be shown
  \sa LegendPosition, setLegendPosition, setLegendShowLines
  */


/**
  \fn void KDChartParams::setLegendOrientation( TQt::Orientation orientation )

  Specifies how the legend should be printed. TQt::Vertical (the default)
  prints the legend entries below each other, TQt::Horizontal prints them
  aside each other.

  \note Horizontal orientation is only possible if the chart is NOT making
        room in horizontal direction, this means you may specify horizontal
        orientation if the legend position in one of the following values
        only: LegendTop, LegendBottom, LegendTopLeftTop, LegendTopRightTop,
        LegendBottomLeftBottom, LegendBottomRightBottom

  \param the orientation for the legend
  \sa legendOrientation, setLegendPosition, setLegendShowLines
  */


/**
  \fn TQt::Orientation KDChartParams::legendOrientation() const

  Returns how the legend will be printed.

  \return how the legend will be printed.
  \sa setLegendOrientation, setLegendPosition, setLegendShowLines
  */

/**
  \fn void KDChartParams::setLegendShowLines( bool legendShowLines )

  Specifies whether the legend shall show lines or just
  show the markers (or squares, resp.).

  \note By default no lines are drawn but just the markers are shown,
        for Line charts you might want to set this flag to true.

  \param flag whether lines are drawn or only the markers
  \sa legendShowLines, setLegendOrientation, setLegendPosition
  */


/**
  \fn bool KDChartParams::legendShowLines() const

  Returns whether the legend shows lines or just
  the markers (or squares, resp.).

  \return  whether the legend shows lines or just the markers (or squares, resp.).
  \sa setLegendShowLines, setLegendOrientation, setLegendPosition
  */



/**
  \enum KDChartParams::LegendSource

  The possible ways for getting the legend text. Available are:
  <ul>
  <li>Manual - Uses texts set with setLegendText(); if no text is set for
  a dataset, the legend text will be empty.
  <li>FirstColumn - Uses values from the first column, no matter what
  this contains.
  <li>Automatic - Tries first to use values from the first column; if
  this does not contain any string values, tries to use values set
  manually with setLegendText(). If there are no values set manually
  either, resolves to standard texts like Series 1, Series 2, .... This
  is the default.
  </ul>
  \sa setLegendSource, legendSource, setLegendText, legendText
  */


/**
  \fn void KDChartParams::setLegendSource( LegendSource source )

  Specifies where the legend text is coming from. See LegendSource for an
  explanation of the possible values.

  \param source the source of the legend texts
  \sa legendSource, LegendSource, setLegendText, legendText
  */


/**
  \fn LegendSource KDChartParams::legendSource() const

  Returns where the legend text is coming from. See LegendSource for an
  explanation of the possible return values.

  \return where the legend text is coming from
  \sa LegendSource, setLegendSource, setLegendText, legendText
  */



/**
  \fn void KDChartParams::setLegendText( uint dataset, const TQString& text )

  Manually specifies a legend text for a certain dataset. This is only
  used if legendSource() == Manual or if legendSource() == Automatic and
  it is not possible to retrieve values from the first column.

  \param dataset the dataset for which to set the legend text
  \param the legend text to be set for a given dataset
  \sa LegendSource, setLegendSource, legendSource, legendText
  */


/**
  \fn TQString KDChartParams::legendText( uint dataset ) const

  Returns the manually specified legend text for a given dataset.

  \return the manually specified legend text for the specified dataset
  \sa setLegendText, LegendSource, setLegendSource, legendSource
  */


/**
  \fn void KDChartParams::setLegendTextColor( const TQColor& color )

  Specifies the color to be used for the legend texts. The
  default is black.

  \param color the color to be used for the legend texts
  \sa legendTextColor(), setLegendTitleTextColor()
  */


/**
  \fn TQColor KDChartParams::legendTextColor() const

  Returns the color in which the legend texts are drawn. The
  default is black.

  \return the color in which the legend texts are drawn
  \sa setLegendTextColor(), legendTitleTextColor()
  */


/**
  \fn void KDChartParams::setLegendFont( const TQFont& font, bool useFontSize )

  Specifies the font in which the legend texts are drawn. The default is a
  10pt helvetica font.

  \note The font size will be ignored if \c useFontSize is false,
  in this case the font size will be calculated dynamically using
  the value stored by you calling setLegendFontRelSize().

  \param font the font to draw the legend texts in
  \sa setLegendFontUseRelSize, legendFont
  */


/**
  \fn TQFont KDChartParams::legendFont() const

  Returns the font in which the legend texts are drawn.

  \return the font in which the legend texts are drawn
  \sa setLegendFont, setLegendFontUseRelSize
  */


/**
  \fn void KDChartParams::setLegendFontUseRelSize( bool legendFontUseRelSize )

  Specifies whether the legend shall be drawn
  using relative font size.

  \param legendFontUseRelSize whether legend shall be drawn
  using relative font size.
  If true the absolute value of the value set by \c
  setLegendFontRelSize is per thousand
  of of the average value of the printable area height and width.
  This will make the legend look nice even if scaled to very
  different size.

  \sa setLegendFontRelSize, setAxisLabelsFont
  */


/**
  \fn bool KDChartParams::legendFontUseRelSize() const

  Returns whether the legend font size is used.

  \return whether the fix legend font size is used.
  \sa setLegendFontRelSize, setLegendFont
  */


/**
  \fn void KDChartParams::setLegendFontRelSize( int legendFontRelSize )

  Specifies the legend relative font size.

  \param legendFontRelSize the relative legend size.
  If this value unequals zero the absolute value is per thousand
  of of the average value of the printable area height and width.
  This will make the legend look nice even if scaled to very
  different size.

  \sa setLegendFontUseRelSize, setLegendFont
  */


/**
  \fn int KDChartParams::legendFontRelSize() const

  Returns the relative legend font size.

  \return the relative legend font size.
  \sa setLegendFontRelSize, setLegendFontUseRelSize
  */


/**
  \fn void KDChartParams::setLegendTitleText( const TQString& text )

  Specifies a text to be shown as the title of the legend. The
  default is "Legend" (possibly localized). To turn off the
  legend title completely, pass an empty string.

  \param text the text to use as the legend title
  \sa legendTitleText(), setLegendTitleFont(),
  setLegendTitleFontUseRelSize()
  */




/**
  \fn TQString KDChartParams::legendTitleText() const

  Returns the text that is shown as the title of the legend.

  \return the text that is used as the legend title
  \sa setLegendTitleText(), legendTitleFont(),
  legendTitleFontUseRelSize()
  */


/**
  \fn void KDChartParams::setLegendTitleTextColor( const TQColor& color )

  Specifies the color to be used for the legend title. The
  default is black. Note that this color is only the default when
  rich text is used; tags in the rich text might change the color.

  \param color the color to be used for the legend title
  \sa legendTitleTextColor(), setLegendTextColor()
  */


/**
  \fn TQColor KDChartParams::legendTitleTextColor() const

  Returns the color in which the legend title is drawn. The
  default is black.

  \return the color in which the legend title is drawn
  \sa setLegendTitleTextColor(), legendTextColor()
  */


/**
  \fn void KDChartParams::setLegendTitleFont( const TQFont& font, bool useFontSize )

  Specifies the font in which the legend title (if any) is drawn. The
  default is a 12pt helvetica font.

  \note The font size will be ignored if \c useFontSize is false,
  in this case the font size will be calculated dynamically using
  the value stored by you calling setLegendFontRelSize().

  \param font the font to draw the legend texts in
  \sa setLegendTitleFontUseRelSize, legendTitleFont
  */


/**
  \fn TQFont KDChartParams::legendTitleFont() const

  Returns the font in which the legend title (if any) is drawn.

  \return the font in which the legend texts are drawn
  \sa setLegendTitleFont, setLegendTitleFontUseRelSize
  */


/**
  \fn void KDChartParams::setLegendTitleFontUseRelSize( bool legendTitleFontUseRelSize )


  Specifies whether the legend title (if any) shall be drawn using
  relative font size.

  \param legendTitleFontUseRelSize whether the legend title shall
  be drawn using relative font size.
  If true the absolute value of the value set by \c
  setLegendTitleFontRelSize is per thousandth of the average
  value of the printable area height and width.
  This will make the legend title look nice even if scaled to a very
  different size.

  \sa setLegendTitleFontRelSize, setAxisLabelsFont
  */


/**
  \fn bool KDChartParams::legendTitleFontUseRelSize() const

  Returns whether the legend title font size is used.

  \return whether the fixed legend title font size is used.
  \sa setLegendTitleFontRelSize, setLegendTitleFont
  */


/**
  \fn void KDChartParams::setLegendTitleFontRelSize( int legendTitleFontRelSize )


  Specifies the legend title relative font size.

  \param legendTitleFontRelSize the relative legend size.
  If this value unequals zero the absolute value is per thousand
  of of the average value of the printable area height and width.
  This will make the legend title look nice even if scaled to a very
  different size.

  \sa setLegendTitleFontUseRelSize, setLegendTitleFont
  */


/**
  \fn int KDChartParams::legendTitleFontRelSize() const

  Returns the relative legend title font size.

  \return the relative legend title font size.
  \sa setLegendTitleFontRelSize, setLegendTitleFontUseRelSize
  */


/**
  \fn void KDChartParams::setLegendSpacing( uint space )

  Specifies how much space in pixels there should be between the legend
  and the data display. The default is 20 pixels.

  \param space the space in pixels between the legend and the data
  display
  \sa legendSpacing
  */


/**
  \fn uint KDChartParams::legendSpacing() const

  Returns how much space in pixels there is between the legend and the
  data display.

  \return the space in pixels between the legend and the data display
  \sa setLegendSpacing
  */

//@}
// END LEGENDS

// START AXES
/** @name Axis methods.

  These methods query and set axis parameters.
  */
//@{

/**
  \fn void KDChartParams::setAxisType( uint n, const KDChartAxisParams::AxisType axisType )

  Specifies the axis type.

  \param n the number of the axis settings to be modified
  \param axisType the type of the axis.
  \sa axisVisible
  */


/**
  \fn void KDChartParams::setAxisVisible( uint n, const bool axisVisible )

  Specifies if the axis will be drawn. The default is false.

  \param n the number of the axis settings to be modified
  \param axisVisible set true to make visible the respective axis.
  \sa axisVisible
  */


/**
  \fn bool KDChartParams::axisVisible( uint n ) const

  Returns if the axis will be drawn.

  \return if the axis is visible or not.
  \sa setAxisVisible
  */


/**
  Specifies whether a grid should be drawn at the chart data area.

  The grid will show a solid line for each delimiter.
  (or a line with a pattern defined by \c KDChartAxisParams::setAxisGridStyle(), resp.)

  \note If true and axisShowSubDelimiters is also true the grid
  will show a thin dotted line for each sub-delimiter.
  (or a line with a pattern defined by \c KDChartAxisParams::setAxisGridSubStyle(), resp.)

  \param n the number of the axis for which to specify whether a grid should be drawn.
  \param axisShowGrid if true a grid will be drawn on the chart data area.
  \sa axisShowGrid, setAxisGridStyle, setAxisGridSubStyle
  */
void KDChartParams::setAxisShowGrid( uint n, bool axisShowGrid )
{
    if ( n < KDCHART_MAX_AXES ) {
        _axisSettings[ n ].params.setAxisShowGrid( axisShowGrid );
        emit changed();
    }
}

/**
  Returns if any grid will be drawn at the data area.

  \return if any grid will be drawn at the data area.
  \sa KDChartAxisParams::setAxisShowGrid
  */
bool KDChartParams::showGrid() const
{
    for ( uint i = 0; i < KDCHART_MAX_AXES; ++i ) {
        if ( _axisSettings[ i ].params.axisVisible()
                && _axisSettings[ i ].params.axisShowGrid() )
            return true;
    }
    return false;
}

/**
  Specifies which data are to be represented by a given axis.<br>
  If you specify a valid dataset-number for parameter dataset
  you may use the same number or a greater number for
  parameter dataset2 to specify a range of contiguous series
  of datasets.<br>
  If you specify <b>KDCHART_ALL_DATASETS</b> for dataset
  the value of dataset2 does not matter.<br>
  By setting the \c chart parameter you may specify which chart is
  represented by the axis, you may use this when displaying
  more than one chart in the same widget.

  Calling setAxisDataset() with a dataset number will automatically set
  the visability flag of the respective axis (or axes, resp.) while calling
  it with KDCHART_NO_DATASET will clear the visibility flag so there is no
  need to explicitely call \c setAxisVisible() after calling setAxisDatasets().

  \note If you specify \c KDCHART_ALL_DATASETS the axis will
  represent all the datasets with SourceMode DataEntry
  (see \c setChartSourceMode for explanation) that have been
  specified for this chart.<br>

  \param n the number of the axis for which to specify the dataset(s)
  \param dataset the dataset represented by axis \c n

  \sa axisDatasets, chartAxes, setChartSourceMode, setAdditionalChartType
  */
void KDChartParams::setAxisDatasets( uint n, uint dataset,
        uint dataset2,
        uint chart )
{
    uint a1 = ( KDCHART_ALL_AXES == n )
        ? 0
        : 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();
}

/**
  Returns which data are to be represented by a given axis.
  ( see explanation given with \c setAxisDatasets() )

  \param n the axis for which to return the dataset number(s)
  \param dataset the starting number of the series of datasets represented by axis \c n or KDCHART_ALL_DATASETS
  \param dataset2 the end number of the series of datasets
  \param chart the chart represented by axis \c n
  \return true if a valid axis number was specified by parameter n
  \sa setAxisDataset, chartAxes
  */
bool KDChartParams::axisDatasets( uint n, uint& dataset,
        uint& dataset2, uint& chart ) const
{
    bool bOk = ( n < KDCHART_MAX_AXES );
    if ( bOk ) {
        dataset  = _axisSettings[ n ].dataset;
        dataset2 = _axisSettings[ n ].dataset2;
        chart    = _axisSettings[ n ].chart;
    }
    return bOk;
}


/**
  Returns which ORDINATE axis(axes) is(are) representing a given chart.
  This will look for the following axes: AxisPosLeft, AxisPosRight,
  AxisPosLeft2, AxisPosRight2.

  It is allowed to specify the same variable as axis1, axis2, axis3,
  axis4 - when doing this you will get the last axis number that was
  found for this chart.  In case you are sure there is only one axis
  per chart you may act that way.

  \param chart the chart for which to return the axis number(s)
  \param cnt the count of axis numbers returned
  \param axes on return, a vector with the numbers of the axes
  \return true if at least one axis is representing the chart \c chart
  \sa setAxisDataset, axisDataset
  */
bool KDChartParams::chartAxes( uint chart, uint& cnt, AxesArray& axes ) const
{
    cnt = 0;
    axes.resize( KDCHART_CNT_ORDINATES );
    for ( int i2 = 0; i2 < KDCHART_CNT_ORDINATES; ++i2 ) {
        axes[ i2 ] = KDCHART_NO_AXIS;
    }
    for ( uint i = 0; i < KDCHART_MAX_AXES; ++i ) {
        if (    chart == _axisSettings[ i ].chart
                && (    KDChartAxisParams::AxisPosLeft   == i
                    || KDChartAxisParams::AxisPosRight  == i
                    || KDChartAxisParams::AxisPosLeft2  == i
                    || KDChartAxisParams::AxisPosRight2 == i ) ) {
            for( int j = 0;  j < KDCHART_CNT_ORDINATES;  ++j ) {
                if( KDCHART_NO_AXIS == axes[ j ] || axes[ j ] == i ) {
                    if( KDCHART_NO_AXIS == axes[ j ] ) {
                        ++cnt;
                        axes[ j ] = i;
                    }
                    break;
                }
            }
        }
    }
    return (0 < cnt);
}




/**
  \fn TQRect KDChartParams::axisArea( const uint n ) const

  Returns the true axis area rectangle as it was was calculate
  by KD Chart.

  \param n the number of the axis

  \note This special function may be called *after* calling
  KDChart::setupGeometry().  Normally you don't need to call
  it at all, its only purpose is to provide you with a way to
  retrieve the true position and size of an axis area.

  \sa dataArea
  */

/**
  \fn TQRect KDChartParams::legendArea() const

  Returns the true legend area rectangle as it was was calculate
  by KD Chart.

  \note This special function may be called *after* calling
  KDChart::setupGeometry().  Normally you don't need to call
  it at all, its only purpose is to provide you with a way to
  retrieve the true position and size of an legend area.

  \sa dataArea
  */

/**
  \fn TQRect KDChartParams::dataArea() const

  Returns the true data area rectangle as it was was calculate
  by KD Chart.

  \note This special function may be called *after* calling
  KDChart::setupGeometry().  Normally you don't need to call
  it at all, its only purpose is to provide you with a way to
  retrieve the true position and size of the data area.

  \sa axisArea
  */


/**
  \fn void KDChartParams::setAxisArea( const uint n, const TQRect& areaRect )

  Specifies the true axis area rectangle.

  \note Do <b>not call</b> this function unless you are knowing
  exactly what you are doing. \c setAxisTrueAreaRect is normally
  reserved for internal usage by methods calculating the area
  size based upon \c axisAreaMin and \c axisAreaMax. Thus the
  signal \c changed() is not sended here.

  \sa axisAreaMax, axisAreaMin, setAxisAreaMode, setAxisAreaMin
  \sa setAxisArea
  */


/**
  \fn void KDChartParams::setAxisLabelsTouchEdges( uint n, bool axisLabelsTouchEdges )

  Specifies whether the axis labels start and end at the
  edges of the charts instead being positioned in the
  middle of the first data point (or the last one, resp.)

  \note If you decide to call setAxisLabelsTouchEdges() to
  override the default settings of abscissa axes
  (AxisPosBottom, AxisPosTop, AxisPosBottom2, AxisPosTop2)
  make sure to call it again each time you have called
  setChartType() since your settings will be overwritten
  when changing the chart type.

  \param axisLabelsTouchEdges if the axis labels start and end at
  the edges of the charts instead being positioned in the
  middle of the first data point (or the last one, resp.)

  \sa axisLabelsTouchEdges
  */


/**
  \fn void KDChartParams::setAxisLabelsVisible( uint n, bool axisLabelsVisible )

  Specifies whether the axis labels of an axis are to be shown.

  \param axisLabelsVisible if true the labels of this axis will be drawn.

  \sa setAxisLabelsFont
  */


/**
  Specifies the axis labels font for one axis.

  \note The font size will be ignored if \c axisLabelsFontSize is not zero,
  in this case the font size will be calculated dynamically using
  the value axisLabelsFontSize.

  \param axisLabelsFont the font to be used for the axis' labels.
  \param axisLabelsFontSize the (fixed or relative) axis font size.
  If this value is less than zero the absolute value is per thousand
  of the average value of the printable area height and width
  to be used. This will make the axis look the same even if scaled
  to very different size.
  \param axisLabelsColor the axis labels colour.

  \sa setAxisLabelsVisible
  \sa setAxisLabelsFontUseRelSize, setAxisLabelsFontRelSize
  \sa KDChartAxisParams::setAxisLabelsFontMinSize
  */
void KDChartParams::setAxisLabelsFont( uint n,
                                       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 );
    }
}


/**
  \fn void KDChartParams::setAxisLabelTextParams( uint n, bool axisSteadyValueCalc,
  KDChartData axisValueStart, KDChartData axisValueEnd,
  double axisValueDelta, int axisDigitsBehindComma,
  int axisMaxEmptyInnerSpan,
  KDChartAxisParams::LabelsFromDataRow takeLabelsFromDataRow,
  int labelTextsDataRow, TQStringList* axisLabelStringList,
  TQStringList* axisShortLabelsStringList )

  Specifies the label text parameters for one axis.

  \sa KDChartAxisParams::setAxisLabelTextParams
  */


/**
  Specifies a \c TQStringList which the axis label texts for one
  axis are to be taken from, the optional short-labels parameter
  (if not zero) may be used to specify an alternative list of
  strings that are to be displayed in case the axis area size
  is too small for showing the full-length names.

  \note Normally axis labeling starts with the list's first string
  and end with its last string, but by specifying a start and an
  end value as additional parameters you can make KDChart repeat
  the strings between these two values only, as shown here:

  \verbatim
  TQStringList abscissaNames;
  abscissaNames << "Sunday" << "Monday" << "Tuesday" << "Wednesday"
  << "Thursday" << "Friday" << "Saturday";
  TQStringList abscissaShortNames;
  abscissaShortNames << "Sun" << "Mon" << "Tue" << "Wed"
  << "Thu" << "Fri" << "Sat";

  setAxisLabelStringParams( KDChartAxisParams::AxisPosBottom,
  &names, &shortNames,
  "Monday", "Friday")
  \endverbatim


  \param n the ID of the axis
  \param TQStringList* axisLabelStringList points to the list of labels to be displayed
  \param  TQStringList* axisShortLabelStringList points to
  an alternative list of short names to be displayed if the long labels take too much place
  \param TQString valueStart ( default null ) the label to begin with
  \param TQString valueEnd ( default null ) the label to end with

  \sa KDChartAxisParams::setAxisLabelStringLists
  */
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();
    }
}


/**
  Specifies the parameters for one axis.

  \param axisParams the axis parameters to be used.
  \sa axisParams, AxisParams
  */
void KDChartParams::setAxisParams( uint n,
        const KDChartAxisParams& axisParams )
{
    if ( n < KDCHART_MAX_AXES ) {
        _axisSettings[ n ].params = axisParams;
        emit changed();
    }
}


/**
  \fn const KDChartAxisParams& KDChartParams::axisParams( uint n ) const

  Returns the parameters that are currently defined for axis n.

  \return all the parameters defined for axis n. If called with invalid
  value for \c n it returns the default axis parameters.
  \sa setAxisParams, AxisParams
  */


//@}
// END AXES

// START HEADERFOOTER

/** @name Header and footer methods.

  These methods query and set header and footer parameters.

  The names of the Header and Footer sections.

  You may use up to 9 header and/or up to 9 footer sections.

  \li Up to three <b>leading headers</b> ( \c HdFtPosHeader0 , \c
  HdFtPosHeader0L , \c HdFtPosHeader0R ) may be drawn at the very upper
  edge of the printable area. <br>
  You might want to use those sections to show some marginal information
  like department name, print date, page number... <br>
  <b>Note:</b> Those headers <b>share the same area</b> so make sure to
  specify propper horizontal alignment for each section when using more than
  one of them. By default \c HdFtPosHeader0 has centered alignement,
  \c HdFtPosHeader0L is aligned to the left and \c HdFtPosHeader0R to the
  right side. All of them are vertically aligned to the bottom, you may
  change this at your own risk: the resulting output might look strange. <br>
  <b>also note:</b> Alignment to bottom here means their baselines are
  horizontally adjusted to each other when more than one of them is used - it
  does <b>not</b> mean the <b>lowest pixel positions</b> of their output will
  be at the very same y coordinate since those might vary depending from the
  font size and or the font size you have specified for each of the sections.

  \li Up to three <b>main headers</b> ( \c HdFtPosHeader , \c
  HdFtPosHeaderL , \c HdFtPosHeaderR ) may be drawn under the
  leading header(s). <br>
  You could use this headers to show the main information such as project name,
  chart title or period of time (e.g. census year). <br>
  Like their counterparts they share the same part of the printable area so the
  restrictions regarding alignment mentioned above apply also to these three
  sections.

  \li Up to three <b>additional headers</b> ( \c HdFtPosHeader2 , \c
  HdFtPosHeader2L , \c HdFtPosHeader2R ) may be drawn under the main
  header(s). <br>
  This headers could show additional information such as project phase, chart
  sub-title or sub-period of time (e.g. census quarter-year). <br>
  Like their counterparts they share the same part of the printable area so the
  restrictions regarding alignment mentioned above apply also to these three
  sections.

  <p>

  \li Up to three <b>main footers</b> ( \c HdFtPosFooter , \c
  HdFtPosFooterL , \c HdFtPosFooterR ) may be drawn under the chart data
  area (or the legend that might be shown below that area, resp.). <br>
  You might want to use these footers instead of (or additional to) the
  main header(s) for showing the main information... <br>
  Like their header-counterparts they share the same part of the printable area
  so the restrictions regarding alignment mentioned above apply also to these
  three sections.

  \li Up to three <b>additional footers</b> ( \c HdFtPosFooter2 , \c
  HdFtPosFooter2L , \c HdFtPosHeader2R ) may be drawn under the main
  footer(s). <br>
  This footers could show additional information instead of (or additional to)
  the additional header(s). <br>
  Like their counterparts they share the same part of the printable area so the
  restrictions regarding alignment mentioned above apply also to these three
  sections.

  \li Up to three <b>trailing footers</b> ( \c HdFtPosFooter0 , \c
  HdFtPosFooter0L , \c HdFtPosFooter0R ) may be drawn at the very lower
  edge of the printable area: <b>under</b> the other footer sections <br>
  You might want to use those sections to show some marginal information
  instead of (or additional to) the leading header(s). <br>
  Like their counterparts they share the same part of the printable area so the
  restrictions regarding alignment mentioned above apply also to these three
  sections.

\note The names \c HdFtPosHeader or \c HdFtPosFooter are the basic names also returned by \c basicAxisPos.

<p>
<b>Usage:</b> Please see example code at \c setHeaderFooterText function explanation.

\sa setHeaderFooterText,           headerFooterText
\sa setHeaderFooterFont,           headerFooterFont
\sa setHeaderFooterFontUseRelSize, headerFooterFontUseRelSize
\sa setHeaderFooterFontRelSize,    headerFooterFontRelSize
*/
//@{


/**
  \enum KDChartParams::HdFtPos

  This enum lists the positions that headers and footers can take.
  */


/**
  \enum KDChartParams::HdFtPosSTART,

  start of all sections
  */

/**
  \enum KDChartParams::HdFtPosHeadersSTART

  start of header sections
  */

/**
  \enum KDChartParams::HdFtPosHeader0

  leading header (at the very top of the printable area)
  */

/**
  \enum KDChartParams::HdFtPosHeader0L

  another leading header, by default left-aligned
  */

/**
  \enum KDChartParams::HdFtPosHeader0R

  yet another leading header, by default right-aligned
  */

/**
  \enum KDChartParams::HdFtPosHeader

  main header (below the leading header)
  */

/**
  \enum KDChartParams::HdFtPosHeaderL

  another main header, by default left-aligned
  */

/**
  \enum KDChartParams::HdFtPosHeaderR

  yet another main header, by default right-aligned
  */

/**
  \enum KDChartParams::HdFtPosHeader2

  additional header (below the main header)
  */

/**
  \enum KDChartParams::HdFtPosHeader2L

  another additional header, by default left-aligned
  */

/**
  \enum KDChartParams::HdFtPosHeader2R

  yet another additional header, by default right-aligned
  */

/**
  \enum KDChartParams::HdFtPosHeadersEND

  end of header sections
  */

/**
  \enum KDChartParams::HdFtPosFootersSTART

  start of footer sections
  */


/**
  \enum KDChartParams::HdFtPosFooter

  main footer (below the data area or the bottom legend (if any), resp.)
  */

/**
  \enum KDChartParams::HdFtPosFooterL

  another main footer, by default left-aligned
  */

/**
  \enum KDChartParams::HdFtPosFooterR

  yet another main footer, by default right-aligned
  */


/**
  \enum KDChartParams::HdFtPosFooter2

  additional footer (below the main footer)
  */

/**
  \enum KDChartParams::HdFtPosFooter2L

  another additional footer, by default left-aligned
  */

/**
  \enum KDChartParams::HdFtPosFooter2R

  yet another additional footer, by default right-aligned
  */


/**
  \enum KDChartParams::HdFtPosFooter0

  trailing footer (below the additional footer)
  */

/**
  \enum KDChartParams::HdFtPosFooter0L

  another trailing footer, by default left-aligned
  */

/**
  \enum KDChartParams::HdFtPosFooter0R

  yet another trailing footer, by default right-aligned
  */

/**
  \enum KDChartParams::HdFtPosFootersEND

  end of footer sections
  */

/**
  \enum KDChartParams::HdFtPosEND

  end of all sections
  */


/**
  Specifies the text to be displayed in the header (or footer, resp.)
  section specified by \c pos.
  The default is not to display any header text nor footer text.

  \note To learn about the different header (or footer, resp.)
  sections please see information given at \c HdFtPos enum explanation.

  \param pos the section in which the text is to be shown
  \param text the text to be shown
  \sa HdFtPos, headerFooterText()
  \sa setHeaderFooterFont,           headerFooterFont
  \sa setHeaderFooterFontUseRelSize, headerFooterFontUseRelSize
  \sa setHeaderFooterFontRelSize,    headerFooterFontRelSize
  \sa setHeader1Text(), header1Text()
  \sa setHeader2Text(), header2Text()
  \sa setFooterText(),  footerText()
  */
void KDChartParams::setHeaderFooterText( uint pos, const TQString& text )
{
    if ( HdFtPosEND >= pos ) {
        _hdFtParams[ pos ]._text = text;
        emit changed();
    }
}


/**
  Returns the text that is displayed in the header (or footer, resp.)
  section specified by \c pos.

  \note To learn about the different header (or footer, resp.)
  sections please see information given at \c HdFtPos enum explanation.

  \param pos the section for which to return the text
  \return the displayed text
  \sa HdFtPos, setHeaderFooterText()
  \sa setHeaderFooterFont,           headerFooterFont
  \sa setHeaderFooterFontUseRelSize, headerFooterFontUseRelSize
  \sa setHeaderFooterFontRelSize,    headerFooterFontRelSize
  \sa setHeader1Text(), header1Text()
  \sa setHeader2Text(), header2Text()
  \sa setFooterText(),  footerText()
  */
TQString KDChartParams::headerFooterText( uint pos ) const
{
    if ( HdFtPosEND >= pos )
        return _hdFtParams[ pos ]._text;
    else
        return TQString();
}



/**
  \note This methode for internal use.
  Return the position and size of one header/footer area.
  <b>Will return valid data only if called after KDChartPainter::setupGeometry()!</b>
  */
const TQRect& KDChartParams::headerFooterRect( uint pos ) const
{
    if ( HdFtPosEND >= pos )
        return _hdFtParams[ pos ].rect();
    else
        return _noRect;
}


/**
  Specifies the colour to be used for the header text (or footer text, resp.)
  of the header/footer section specified by \c pos.
  The default colour is <b>TQColor( TQt::black )</b>.

  \note To learn about the different header (or footer, resp.)
  sections please see information given at \c HdFtPos enum explanation.

  \param pos the section for which the colour is to be changed
  \param color the text colour to be used
  \sa HdFtPos, headerFooterText()
  \sa setHeaderFooterFont,           headerFooterFont
  \sa setHeaderFooterFontUseRelSize, headerFooterFontUseRelSize
  \sa setHeaderFooterFontRelSize,    headerFooterFontRelSize
  \sa setHeader1Text(), header1Text()
  \sa setHeader2Text(), header2Text()
  \sa setFooterText(),  footerText()
  */
void KDChartParams::setHeaderFooterColor( uint pos, const TQColor color )
{
    if ( HdFtPosEND >= pos ) {
        _hdFtParams[ pos ]._color = color;
        emit changed();
    }
}


/**
  Returns the colour used for the header text (or footer text, resp.)
  of the header/footer section specified by \c pos.

  \note To learn about the different header (or footer, resp.)
  sections please see information given at \c HdFtPos enum explanation.

  \param pos the section for which to return the text colour
  \return the text colour
  \sa HdFtPos, setHeaderFooterText()
  \sa setHeaderFooterFont,           headerFooterFont
  \sa setHeaderFooterFontUseRelSize, headerFooterFontUseRelSize
  \sa setHeaderFooterFontRelSize,    headerFooterFontRelSize
  \sa setHeader1Text(), header1Text()
  \sa setHeader2Text(), header2Text()
  \sa setFooterText(),  footerText()
  */
TQColor KDChartParams::headerFooterColor( uint pos ) const
{
    if ( HdFtPosEND >= pos )
        return _hdFtParams[ pos ]._color;
    else
        return TQColor( TQt::black );
}


/**
  Specifies the font to be used in the header (or footer,
  resp.) section specified by \c pos..
  The default is a 14pt Helvetica font.

  \note To learn about the different header (or footer, resp.)
  sections please see information given at \c HdFtPos enum explanation.

  \param pos the section in which the font is to be used
  \param font the font to use
  \sa HdFtPos, setHeaderFooterText(), headerFooterText()
  \sa headerFooterFont()
  \sa setHeaderFooterFontUseRelSize, headerFooterFontUseRelSize
  \sa setHeaderFooterFontRelSize,    headerFooterFontRelSize
  \sa setHeader1Font(), header1Font()
  \sa setHeader2Font(), header2Font()
  \sa setFooterFont(),  footerFont()
  \sa setHeader1Text(), header1Text()
  \sa setHeader2Text(), header2Text()
  \sa setFooterText(),  footerText()
  */
void KDChartParams::setHeaderFooterFont( uint pos, const TQFont& font,
        bool fontUseRelSize,
        int fontRelSize )
{
    if ( HdFtPosEND >= pos ) {
        _hdFtParams[ pos ]._font = font;
        _hdFtParams[ pos ]._fontUseRelSize = fontUseRelSize;
        _hdFtParams[ pos ]._fontRelSize = fontRelSize;
        emit changed();
    }
}


/**
  Returns the font used in the header (or footer, resp.)
  section specified by \c pos.

  \note To learn about the different header (or footer, resp.)
  sections please see information given at \c HdFtPos enum explanation.

  \param pos the section for which to return the font
  \return the used font
  \sa HdFtPos, setHeaderFooterText(), headerFooterText()
  \sa setHeaderFooterFont()
  \sa setHeaderFooterFontUseRelSize, headerFooterFontUseRelSize
  \sa setHeaderFooterFontRelSize,    headerFooterFontRelSize
  \sa setHeader1Font(), header1Font()
  \sa setHeader2Font(), header2Font()
  \sa setFooterFont(),  footerFont()
  \sa setHeader1Text(), header1Text()
  \sa setHeader2Text(), header2Text()
  \sa setFooterText(),  footerText()
  */
TQFont KDChartParams::headerFooterFont( uint pos ) const
{
    if ( HdFtPosEND >= pos )
        return _hdFtParams[ pos ]._font;
    else
        return TQApplication::font();
}


/**
  Returns is the font size used in the header (or footer, resp.)
  section specified by \c pos will be calculated dynamically.

  \note To learn about the different header (or footer, resp.)
  sections please see information given at \c HdFtPos enum explanation.

  \param pos the section for which to return the font calculation flag
  \return the font calculation flag
  \sa HdFtPos, setHeaderFooterText(), headerFooterText()
  \sa setHeaderFooterFont()
  \sa setHeaderFooterFontUseRelSize, headerFooterFontUseRelSize
  \sa setHeaderFooterFontRelSize,    headerFooterFontRelSize
  \sa setHeader1Font(), header1Font()
  \sa setHeader2Font(), header2Font()
  \sa setFooterFont(),  footerFont()
  \sa setHeader1Text(), header1Text()
  \sa setHeader2Text(), header2Text()
  \sa setFooterText(),  footerText()
  */
bool KDChartParams::headerFooterFontUseRelSize( uint pos ) const
{
    if ( HdFtPosEND >= pos )
        return _hdFtParams[ pos ]._fontUseRelSize;
    else
        return false;
}


/**
  Returns the factor used for dynamical calculation of
  the font size of the text in the header (or footer, resp.)
  section specified by \c pos.

  \note To learn about the different header (or footer, resp.)
  sections please see information given at \c HdFtPos enum explanation.

  \param pos the section for which to return the font size factor
  \return the font size factor
  \sa HdFtPos, setHeaderFooterText(), headerFooterText()
  \sa setHeaderFooterFont()
  \sa setHeaderFooterFontUseRelSize, headerFooterFontUseRelSize
  \sa setHeaderFooterFontRelSize,    headerFooterFontRelSize
  \sa setHeader1Font(), header1Font()
  \sa setHeader2Font(), header2Font()
  \sa setFooterFont(),  footerFont()
  \sa setHeader1Text(), header1Text()
  \sa setHeader2Text(), header2Text()
  \sa setFooterText(),  footerText()
  */
int KDChartParams::headerFooterFontRelSize( uint pos ) const
{
    if ( HdFtPosEND >= pos )
        return _hdFtParams[ pos ]._fontRelSize;
    else
        return 10;
}


/**
  \fn void KDChartParams::setHeader1Text( const TQString& text )

  Specifies the text to be displayed as the first header line. The
  default is not to display any header text.

  \note This function provided for convenience only. <br>
  To gain the <b>full</b> benefits of the header/footer management
  please consider learning about the different header (or footer,
  resp.) sections, see information given at \c HdFtPos enum
  explanation. <br>
  The 'better' way to specify content and settings of headers or
  footers is to call \c setHeaderFooterText ( or \c setHeaderFooterFont
  , \c setHeaderFooterFontUseRelSize , \c setHeaderFooterFontRelSize ,
  resp.) while specifying the appropriate \c HdFtPos. <br>
  The canonical way to retrieve settings and content of headers or
  footers is to call \c headerFooterText (or \c headerFooterFont ,
  \c headerFooterFontUseRelSize , \c headerFooterFontRelSize, resp.).

  \param text the text to display
  \sa HdFtPos, setHeaderFooterText(), headerFooterText()
  \sa header2Text(), setHeader1Text(), header1Text(), setFooterText(),
  footerText()
  */


/**
  \fn TQString KDChartParams::header1Text() const

  Returns the text that is displayed as the first header line.

  \note This function provided for convenience only. <br>
  To gain the <b>full</b> benefits of the header/footer management
  please consider learning about the different header (or footer,
  resp.) sections, see information given at \c HdFtPos enum
  explanation. <br>
  The 'better' way to specify content and settings of headers or
  footers is to call \c setHeaderFooterText ( or \c setHeaderFooterFont
  , \c setHeaderFooterFontUseRelSize , \c setHeaderFooterFontRelSize ,
  resp.) while specifying the appropriate \c HdFtPos. <br>
  The canonical way to retrieve settings and content of headers or
  footers is to call \c headerFooterText (or \c headerFooterFont ,
  \c headerFooterFontUseRelSize , \c headerFooterFontRelSize, resp.).

  \return the displayed text
  \sa HdFtPos, setHeaderFooterText(), headerFooterText()
  \sa setHeader2Text(), setHeader1Text(), header1Text()
  \sa setFooterText(), footerText()
  */


/**
  \fn void KDChartParams::setHeader1Font( const TQFont& font )

  Specifies the font to be used for displaying the first header line.
  The default is a 14pt Helvetica font.

  \note This function provided for convenience only. <br>
  To gain the <b>full</b> benefits of the header/footer management
  please consider learning about the different header (or footer,
  resp.) sections, see information given at \c HdFtPos enum
  explanation. <br>
  The 'better' way to specify content and settings of headers or
  footers is to call \c setHeaderFooterText ( or \c setHeaderFooterFont
  , \c setHeaderFooterFontUseRelSize , \c setHeaderFooterFontRelSize ,
  resp.) while specifying the appropriate \c HdFtPos. <br>
  The canonical way to retrieve settings and content of headers or
  footers is to call \c headerFooterText (or \c headerFooterFont ,
  \c headerFooterFontUseRelSize , \c headerFooterFontRelSize, resp.).

  \param font the font to use
  \sa HdFtPos, setHeaderFooterFont(), headerFooterFont()
  \sa setHeaderFooterFontUseRelSize(), headerFooterFontUseRelSize()
  \sa setHeaderFooterFontRelSize(), headerFooterFontRelSize()
  \sa header2Font(), setHeader2Text(), header2Text()
  \sa setHeader1Font(), header1Font()
  \sa setFooterFont(), footerFont()
  */


/**
  \fn TQFont KDChartParams::header1Font() const

  Returns the font used for displaying the second header line.

  \note This function provided for convenience only. <br>
  To gain the <b>full</b> benefits of the header/footer management
  please consider learning about the different header (or footer,
  resp.) sections, see information given at \c HdFtPos enum
  explanation. <br>
  The 'better' way to specify content and settings of headers or
  footers is to call \c setHeaderFooterText ( or \c setHeaderFooterFont
  , \c setHeaderFooterFontUseRelSize , \c setHeaderFooterFontRelSize ,
  resp.) while specifying the appropriate \c HdFtPos. <br>
  The canonical way to retrieve settings and content of headers or
  footers is to call \c headerFooterText (or \c headerFooterFont ,
  \c headerFooterFontUseRelSize , \c headerFooterFontRelSize, resp.).

  \return the used font
  \sa HdFtPos, setHeaderFooterFont(), headerFooterFont()
  \sa setHeaderFooterFontUseRelSize(), headerFooterFontUseRelSize()
  \sa setHeaderFooterFontRelSize(), headerFooterFontRelSize()
  \sa setHeader2Font(), setHeader2Text(), header2Text(),
  setHeader1Font(), header1Font(), setFooterFont(), footerFont()
  */


/**
  \fn void KDChartParams::setHeader2Text( const TQString& text )

  Specifies the text to be displayed as the second header line. The
  default is not to display any header text.

  \note This function provided for convenience only. <br>
  To gain the <b>full</b> benefits of the header/footer management
  please consider learning about the different header (or footer,
  resp.) sections, see information given at \c HdFtPos enum
  explanation. <br>
  The 'better' way to specify content and settings of headers or
  footers is to call \c setHeaderFooterText ( or \c setHeaderFooterFont
  , \c setHeaderFooterFontUseRelSize , \c setHeaderFooterFontRelSize ,
  resp.) while specifying the appropriate \c HdFtPos. <br>
  The canonical way to retrieve settings and content of headers or
  footers is to call \c headerFooterText (or \c headerFooterFont ,
  \c headerFooterFontUseRelSize , \c headerFooterFontRelSize, resp.).

  \param text the text to display
  \sa HdFtPos, setHeaderFooterText(), headerFooterText()
  \sa header2Text(), setHeader1Text(), header1Text(), setFooterText(),
  footerText()
  */


/**
  \fn TQString KDChartParams::header2Text() const

  Returns the text that is displayed as the second header line.

  \note This function provided for convenience only. <br>
  To gain the <b>full</b> benefits of the header/footer management
  please consider learning about the different header (or footer,
  resp.) sections, see information given at \c HdFtPos enum
  explanation. <br>
  The 'better' way to specify content and settings of headers or
  footers is to call \c setHeaderFooterText ( or \c setHeaderFooterFont
  , \c setHeaderFooterFontUseRelSize , \c setHeaderFooterFontRelSize ,
  resp.) while specifying the appropriate \c HdFtPos. <br>
  The canonical way to retrieve settings and content of headers or
  footers is to call \c headerFooterText (or \c headerFooterFont ,
  \c headerFooterFontUseRelSize , \c headerFooterFontRelSize, resp.).

  \return the displayed text
  \sa HdFtPos, setHeaderFooterText(), headerFooterText()
  \sa setHeader2Text(), setHeader1Text(), header1Text(), setFooterText(),
  footerText()
  */


/**
  \fn void KDChartParams::setHeader2Font( const TQFont& font )

  Specifies the font to be used for displaying the second header line. The
  default is a 12pt Helvetica font.

  \note This function provided for convenience only. <br>
  To gain the <b>full</b> benefits of the header/footer management
  please consider learning about the different header (or footer,
  resp.) sections, see information given at \c HdFtPos enum
  explanation. <br>
  The 'better' way to specify content and settings of headers or
  footers is to call \c setHeaderFooterText ( or \c setHeaderFooterFont
  , \c setHeaderFooterFontUseRelSize , \c setHeaderFooterFontRelSize ,
  resp.) while specifying the appropriate \c HdFtPos. <br>
  The canonical way to retrieve settings and content of headers or
  footers is to call \c headerFooterText (or \c headerFooterFont ,
  \c headerFooterFontUseRelSize , \c headerFooterFontRelSize, resp.).

  \param font the font to use
  \sa HdFtPos, setHeaderFooterFont(), headerFooterFont()
  \sa setHeaderFooterFontUseRelSize(), headerFooterFontUseRelSize()
  \sa setHeaderFooterFontRelSize(), headerFooterFontRelSize()
  \sa header2Font(), setHeader2Text(), header2Text(), setHeader1Font(), header1Font(),
  setFooterFont(), footerFont()
  */



/**
  \fn TQFont KDChartParams::header2Font() const

  Returns the font used for displaying the second header line.

  \note This function provided for convenience only. <br>
  To gain the <b>full</b> benefits of the header/footer management
  please consider learning about the different header (or footer,
  resp.) sections, see information given at \c HdFtPos enum
  explanation. <br>
  The 'better' way to specify content and settings of headers or
  footers is to call \c setHeaderFooterText ( or \c setHeaderFooterFont
  , \c setHeaderFooterFontUseRelSize , \c setHeaderFooterFontRelSize ,
  resp.) while specifying the appropriate \c HdFtPos. <br>
  The canonical way to retrieve settings and content of headers or
  footers is to call \c headerFooterText (or \c headerFooterFont ,
  \c headerFooterFontUseRelSize , \c headerFooterFontRelSize, resp.).

  \return the used font
  \sa HdFtPos, setHeaderFooterFont(), headerFooterFont()
  \sa setHeaderFooterFontUseRelSize(), headerFooterFontUseRelSize()
  \sa setHeaderFooterFontRelSize(), headerFooterFontRelSize()
  \sa setHeader2Font(), setHeader2Text(), header2Text(),
  setHeader1Font(), header1Font(), setFooterFont(), footerFont()
  */


/**
  \fn void KDChartParams::setFooterText( const TQString& text )

  Specifies the text to be displayed as the footer line. The
  default is not to display any footer text.

  \note This function provided for convenience only. <br>
  To gain the <b>full</b> benefits of the header/footer management
  please consider learning about the different header (or footer,
  resp.) sections, see information given at \c HdFtPos enum
  explanation. <br>
  The 'better' way to specify content and settings of headers or
  footers is to call \c setHeaderFooterText ( or \c setHeaderFooterFont
  , \c setHeaderFooterFontUseRelSize , \c setHeaderFooterFontRelSize ,
  resp.) while specifying the appropriate \c HdFtPos. <br>
  The canonical way to retrieve settings and content of headers or
  footers is to call \c headerFooterText (or \c headerFooterFont ,
  \c headerFooterFontUseRelSize , \c headerFooterFontRelSize, resp.).

  \param text the text to display
  \sa HdFtPos, setHeaderFooterText(), headerFooterText()
  \sa footerText(), setHeader1Text(), header1Text(), setHeader2Text(),
  header2Text()
  */


/**
  \fn TQString KDChartParams::footerText() const

  Returns the text that is displayed as the footer line.

  \note This function provided for convenience only. <br>
  To gain the <b>full</b> benefits of the header/footer management
  please consider learning about the different header (or footer,
  resp.) sections, see information given at \c HdFtPos enum
  explanation. <br>
  The 'better' way to specify content and settings of headers or
  footers is to call \c setHeaderFooterText ( or \c setHeaderFooterFont
  , \c setHeaderFooterFontUseRelSize , \c setHeaderFooterFontRelSize ,
  resp.) while specifying the appropriate \c HdFtPos. <br>
  The canonical way to retrieve settings and content of headers or
  footers is to call \c headerFooterText (or \c headerFooterFont ,
  \c headerFooterFontUseRelSize , \c headerFooterFontRelSize, resp.).

  \return the displayed text
  \sa HdFtPos, setHeaderFooterText(), headerFooterText()
  \sa setFooterText(), setHeader1Text(), header1Text(), setHeader2Text(),
  header2Text()
  */


/**
  \fn void KDChartParams::setFooterFont( const TQFont& font )

  Specifies the font to be used for displaying the footer line. The
  default is a 12pt Helvetica font.

  \note This function provided for convenience only. <br>
  To gain the <b>full</b> benefits of the header/footer management
  please consider learning about the different header (or footer,
  resp.) sections, see information given at \c HdFtPos enum
  explanation. <br>
  The 'better' way to specify content and settings of headers or
  footers is to call \c setHeaderFooterText ( or \c setHeaderFooterFont
  , \c setHeaderFooterFontUseRelSize , \c setHeaderFooterFontRelSize ,
  resp.) while specifying the appropriate \c HdFtPos. <br>
  The canonical way to retrieve settings and content of headers or
  footers is to call \c headerFooterText (or \c headerFooterFont ,
  \c headerFooterFontUseRelSize , \c headerFooterFontRelSize, resp.).

  \param font the font to use
  \sa HdFtPos, setHeaderFooterFont(), headerFooterFont()
  \sa setHeaderFooterFontUseRelSize(), headerFooterFontUseRelSize()
  \sa setHeaderFooterFontRelSize(), headerFooterFontRelSize()
  \sa footerFont(), setFooterText(), footerText(), setHeader1Font(), header1Font(),
  setHeader2Font(), header2Font()
  */


/**
  \fn TQFont KDChartParams::footerFont() const

  Returns the font used for displaying the footer line.

  \note This function provided for convenience only. <br>
  To gain the <b>full</b> benefits of the header/footer management
  please consider learning about the different header (or footer,
  resp.) sections, see information given at \c HdFtPos enum
  explanation. <br>
  The 'better' way to specify content and settings of headers or
  footers is to call \c setHeaderFooterText ( or \c setHeaderFooterFont
  , \c setHeaderFooterFontUseRelSize , \c setHeaderFooterFontRelSize ,
  resp.) while specifying the appropriate \c HdFtPos. <br>
  The canonical way to retrieve settings and content of headers or
  footers is to call \c headerFooterText (or \c headerFooterFont ,
  \c headerFooterFontUseRelSize , \c headerFooterFontRelSize, resp.).

  \return the used font
  \sa HdFtPos, setHeaderFooterFont(), headerFooterFont()
  \sa setHeaderFooterFontUseRelSize(), headerFooterFontUseRelSize()
  \sa setHeaderFooterFontRelSize(), headerFooterFontRelSize()
  \sa setFooterFont(), setFooterText(), footerText(),
  setHeader1Font(), header1Font(), setHeader2Font(), header2Font()
  */


//@}
// END HEADERFOOTER



// PRIVATE VARIABLES
/**
  \var int KDChartParams::_globalLeadingLeft;
  Stores the distance between the chart and the left border of the painter area.
  */

/**
  \var int KDChartParams::_globalLeadingTop;

  Stores the distance between the chart and the upper border of the painter area.
  */


/**
  \var int KDChartParams::_globalLeadingRight;

  Stores the distance between the chart and the left border of the painter area.
  */


/**
  \var int KDChartParams::_globalLeadingBottom;

  Stores the distance between the chart and the right border of the painter area.
  */

/**
  \var ChartType KDChartParams::_chartType;

  Stores the chart type.
  */

/**
  \var ChartType KDChartParams::_additionalChartType;

  Stores the additional chart type.
  */

/**
  \var int KDChartParams::_numValues;

  Stores how many of the values should be shown. -1 means all
  available values.
  */

/**
  \var TQFont KDChartParams::_defaultFont;

  Stores our default font used for many different purposes.
  */

/**
  \var KDChartParams::AreaMap

  The type used for storing the frame settings for all of the chart areas.
  */

/**
  \var AreaMap KDChartParams::_areaMap;
  Stores the frame settings for all of the chart areas.
  */

/**
  \var CustomBoxMap KDChartParams::_customBoxDict;

  Stores the settings for all of the custom boxes.
  */


/**
  \var TQRect KDChartParams::_noRect;

  Stores an empty rectangle.
  */

/**
  \var KDFrame KDChartParams::_noFrame;

  Stores the default frame settings: no border, no corners, no background.
  */

/**
  \var KDChartFrameSettings KDChartParams::_noFrameSettings;

  Stores the default area settings: no frame, no inner gap, no outer gap.
  */


/**
  \class KDChartParams::ModeAndChart

  Stores the SourceMode and the chart(s) for one dataset.
  */


/**
  \var ModeAndChartMap KDChartParams::_dataSourceModeAndChart;

  Stores the SourceMode and the chart(s) for the datasets.
  */

/**
  \var typedef KDChartParams::ModeAndChartMap

  The type used for storing the source mode and charts of the datasets
  */


/**
  \var bool KDChartParams::_setChartSourceModeWasUsed;

  Stores whether setChartSourceMode() was called or not
  */

/**
  \var TQMap < uint, TQColor > KDChartParams::_dataColors;

  Stores the colors for the datasets.
  */

/**
  \var uint KDChartParams::_maxDatasetSourceMode;

  Stores the highest dataset number for which a SourceMode has been
  defined. Note that if you define a value for a dataset but not for a
  dataset with a lower number (and there is neither a default value), the
  source mode for that dataset with the lower number will be undefined.
  */


/**
  \var KDChartPropertySetList KDChartParams::_propertySetList;

  Stores all property-sets that were defined.
  Each of these sets may be assigned to an individual cell.
  */


/**
  \var double KDChartParams::_shadowBrightnessFactor;

  Stores a factor to be used to adjust the
  built-in brightness of shadow colors in
  3-dimensional drawings like e.g. 3D bar charts.
  */


/**
  \var TQt::BrushStyle KDChartParams::_shadowPattern;

  Stores a fill style to be used for filling shadow area in
  3-dimensional drawings like e.g. 3D bar charts.
  */

/**
  \var bool KDChartParams::_threeDShadowColors;

  Stores  whether shadowed colors are used for 3D effects. Only used
  for 3D effects in charts that support these.
  */


/**
  \var uint KDChartParams::_maxDatasetColor;

  Stores the highest dataset number for which a color has been
  defined. Note that if you define a value for a dataset but not for a
  dataset with a lower number (and there is neither a default value), the
  color for that dataset with the lower number will be undefined.
  */

/**
  \var TQMap < uint, TQColor > KDChartParams::_dataColorsShadow1;

  Stores the shadow colors that are somewhat darker than the colors in
  _dataColors.
  */

/**
  \var TQMap < uint, TQColor > KDChartParams::_dataColorsShadow2;

  Stores the shadow colors that are even more darker than the colors in
  _dataColorsShadow1;
  */

/**
  \var TQColor KDChartParams::_outlineDataColor;

  Stores the color to be used for outlines of data displays.
  */

/**
  \var uint KDChartParams::_outlineDataLineWidth;

  Stores the line width to be used for outlines of data displays.
  */

/**
  \var PenStyle KDChartParams::_outlineDataLineStyle;

  Stores the line style to be used for outlines of data displays.
  */



/**
  \struct PrintValueDataSettings KDChartParams.h

  Stores if and how a chart will print the data values near their
  respective entries.
  */


/**
  \var PrintDataValuesSettings KDChartParams::_printDataValuesSettings;

  Stores if and how the FIRST chart will print the data values
  near their respective entries.
  */

/**
  \var PrintDataValuesSettings KDChartParams::_printDataValuesSettings2;

  Stores if and how the SECOND chart will print the data values
  near their respective entries, in case two charts are to be
  drawn sharing the same data area.
  */

/**
  \var bool KDChartParams::_allowOverlappingDataValueTexts;

  Stores whether a data value may be drawn near it's respective entry
  even if it's region intersects with another data value text's region.

  By default this is FALSE to prevent ugly mutual overwriting of data
  value texts and to speed up drawing of cahrts containing thousands
  of data points.
  */


/**
  \var BarChartSubType KDChartParams::_barChartSubType;

  Stores the bar chart subtype. Only used when chartType() ==
  Bar
  */

/**
  \var bool KDChartParams::_threeDBars;

  Stores whether the engine should draw the bars in 3D. Only
  used if chartType() == Bar.
  */

/**
  \var int KDChartParams::_threeDBarAngle;

  Stores the angle used for 3D display. Only used if
  threeDBars == true.
  */

/**
  \var double KDChartParams::_threeDBarDepth;

  Stores the depth of the 3D Effect used for 3D bars
  in relation to the bar width.
  Only used if chartType() == Bar and threeDBars() == true.
  */


/**
  \var double KDChartParams::_cosThreeDBarAngle;

  The cosine in rad of the angle for 3D display. Only used if
  threeDBars == true.
  */

/**
  \var int KDChartParams::_datasetGap;

  Stores the number of pixels between two dataset values.
  */

/**
  \var bool KDChartParams::_datasetGapIsRelative;

  Stores if the value set by \c setDatasetGap
  is a per mille value of the chart data area width.
  */

/**
  \var int KDChartParams::_valueBlockGap;

  Stores the number of pixels between each value block.
  */

/**
  \var bool KDChartParams::_valueBlockGapIsRelative;

  Stores if the value set by \c setValueBlockGap
  is a per mille value of the chart data area width.
  */

/// LINES/AREAS-specific
/**
  \var LineChartSubType KDChartParams::_lineChartSubType;

  Stores the line chart subtype. Only used when chartType() ==
  Line
  */

/**
  \var bool KDChartParams::_threeDLines;

  Stores whether 3D lines should be drawn.
  */


/**
  \var int KDChartParams::_threeDLineDepth;

  Stores the depth of 3D lines.
  */


// documentation of this member variable temporary disabled:
// Feature is currently not supported, will be implemented
// by future versions of KDChart
/*
   \var int KDChartParams::_threeDLineXRotation;

   Stores the X rotation of 3D lines.
   */


// documentation of this member variable temporary disabled:
// Feature is currently not supported, will be implemented
// by future versions of KDChart
/*
   \var int KDChartParams::_threeDLineYRotation;

   Stores the Y rotation of 3D lines.
   */


/**
  \var bool KDChartParams::_lineMarker;

  Stores whether line markers should be drawn. Only used when
  chartType() == Line.
  */


/**
  \var LineMarkerStyleMap KDChartParams::_lineMarkerStyles;

  Stores the styles of the line makers
  */

/**
  \var uint KDChartParams::_maxDatasetLineMarkerStyle;

  Stores the highest dataset number for which a line marker has been
  defined. Note that if you define a value for a dataset but not for a
  dataset with a lower number (and there is neither a default value), the
  line marker for that dataset with the lower number will be undefined.
  */

/**
  \var TQSize KDChartParams::_lineMarkerSize;

  Stores the size of the line markers.
  */


/**
  \var TQColor KDChartParams::_lineColor;

  Stores the color of lines in line charts.
  */

/**
  \var int KDChartParams::_lineWidth;

  Stores the line width of lines in line charts.
  */

/**
  \var PenStyle KDChartParams::_lineStyle;

  Stores the line style of lines in line charts.
  */

/**
  \var AreaChartSubType KDChartParams::_areaChartSubType;

  Stores  the area chart subtype. Only used when chartType() ==
  Area
  */


/**
  \var AreaLocation KDChartParams::_areaLocation;

  Stores  whether the area above or below the value points should
  be filled.
  */


/// POLAR-specific
/**
  \var PolarChartSubType KDChartParams::_polarChartSubType;

  Stores  the polar chart subtype. Only used when chartType() ==
  Polar
  */

/**
  \var bool KDChartParams::_polarMarker;

  Stores  whether polar markers should be drawn. Only used when
  chartType() == Polar.
  */

/**
  \var PolarMarkerStyleMap KDChartParams::_polarMarkerStyles;

  Stores the styles of the markers in a polar char.
  */

/**
  \var uint KDChartParams::_maxDatasetPolarMarkerStyle;

  Stores the highest dataset number for which a polar marker has been
  defined. Note that if you define a value for a dataset but not for a
  dataset with a lower number (and there is neither a default value), the
  polar marker for that dataset with the lower number will be undefined.
  */

/**
  \var TQSize KDChartParams::_polarMarkerSize;

  Stores the size of the polar markers.
  */


/**
  \var int KDChartParams::_polarLineWidth;

  Stores the line width of lines in polar charts.
  */


/**
  \var int KDChartParams::_polarZeroDegreePos;

  Stores the zero degree position in polar charts.
  */


/**
  \var bool KDChartParams::_polarRotateCircularLabels;

  Stores whether to rotate circular labels in polar charts.
  */

/**
  \struct KDChartParams::_polarDelimsAndLabelStruct KDChartParams.h

  Stores whether to show circular delimiters and/or labels
  at a given position in polar charts.
  */

/**
  \var _polarDelimsAndLabelStruct KDChartParams::_polarDelimsAndLabels[ 1 + KDCHART_MAX_POLAR_DELIMS_AND_LABELS_POS ];

  Stores where to show circular delimiters and labels in polar charts.
  */



// PIES/RINGS
/**
  \var bool KDChartParams::_explode;

  Stores whether pies or ring segments are drawn exploding.
  */

/**
  \var double KDChartParams::_explodeFactor;

  Stores the default explode factor of pie or ring segments.
  */

/**
  \var TQMap<int,double> KDChartParams::_explodeFactors;

  Stores the list of segment-specific explode factors of pie or
  ring segments.
  */

/**
  \var TQValueList<int> KDChartParams::_explodeList;

  Stores the list of pies or ring segments to explode.
  */

/**
  \var bool KDChartParams::_threeDPies;

  Stores whether pies will have a 3D effect.
  */

/**
  \var int KDChartParams::_threeDPieHeight;

  Stores the height of the pie 3D effect.
  */

/**
  \var int KDChartParams::_pieStart;

  Stores the starting point of the pie circle.
  */

/**
  \var int KDChartParams::_ringStart;

  Stores the starting point of the ring circle.
  */

/**
  \var bool KDChartParams::_relativeRingThickness;

  Stores whether the ring thickness is relativ or constant.
  */


// HI-LO CHARTS

/**
  \var HiLoChartSubType KDChartParams::_hiLoChartSubType;

  Stores the HiLo subtype.
  */

/**
  \var bool KDChartParams::_hiLoChartPrintLowValues;

  Stores whether the low values
  will be printed under their respective entries.
  */


/**
  \var TQFont KDChartParams::_hiLoChartLowValuesFont;

  Stores the font to be used for printing the low values.
  */


/**
  \var bool KDChartParams::_hiLoChartLowValuesUseFontRelSize;

  Stores whether the font size to be used for printing the low
  values is calculated dynamically.
  */


/**
  \var int KDChartParams::_hiLoChartLowValuesFontRelSize;

  Stores the relative size (in per mille of the chart width) of
  font size to be used for printing the low values.
  */


/**
  \var TQColor KDChartParams::_hiLoChartLowValuesColor;

  Stores the colour of the font size to be used for printing the
  low values.
  */

/**
  \var bool KDChartParams::_hiLoChartPrintHighValues;

  Stores whether the high values will be printed under their
  respective entries.
  */


/**
  \var TQFont KDChartParams::_hiLoChartHighValuesFont;

  Stores the font to be used for printing the high values.
  */


/**
  \var bool KDChartParams::_hiLoChartHighValuesUseFontRelSize;

  Stores whether the font size to be used for printing the high
  values is calculated dynamically.
  */


/**
  \var int KDChartParams::_hiLoChartHighValuesFontRelSize;

  Stores the relative size (in per mille of the chart width) of
  font size to be used for printing the high values.
  */


/**
  \var TQColor KDChartParams::_hiLoChartHighValuesColor;

  Stores the colour of the font size to be used for printing the
  high values.
  */

/**
  \var bool KDChartParams::_hiLoChartPrintOpenValues;

  Stores whether the open values
  will be printed under their respective entries.
  */


/**
  \var TQFont KDChartParams::_hiLoChartOpenValuesFont;

  Stores the font to be used for printing the open values.
  */


/**
  \var bool KDChartParams::_hiLoChartOpenValuesUseFontRelSize;

  Stores whether the font size to be used for printing the open
  values is calculated dynamically.
  */


/**
  \var int KDChartParams::_hiLoChartOpenValuesFontRelSize;

  Stores the relative size (in per mille of the chart width) of
  font size to be used for printing the open values.
  */


/**
  \var TQColor KDChartParams::_hiLoChartOpenValuesColor;

  Stores the colour of the font size to be used for printing the
  open values.
  */

/**
  \var bool KDChartParams::_hiLoChartPrintCloseValues;

  Stores whether the close values will be printed under their
  respective entries.
  */


/**
  \var TQFont KDChartParams::_hiLoChartCloseValuesFont;

  Stores the font to be used for printing the close values.
  */


/**
  \var bool KDChartParams::_hiLoChartCloseValuesUseFontRelSize;

  Stores whether the font size to be used for printing the close
  values is calculated dynamically.
  */


/**
  \var int KDChartParams::_hiLoChartCloseValuesFontRelSize;

  Stores the relative size (in per mille of the chart width) of
  font size to be used for printing the close values.
  */


/**
  \var TQColor KDChartParams::_hiLoChartCloseValuesColor;

  Stores the colour of the font size to be used for printing the
  close values.
  */


/**
  \var BWChartSubType KDChartParams::_BWChartSubType;

  Stores the Box And Whisker subtype.
  */

/**
  \struct BWChartStatistics KDChartParams.h

  Stores the statistical data for a box-and-whisker chart
  */

/**
  \var BWChartStatistics KDChartParams::_BWChartStatistics[ BWStatValOffEndValue ];

  Stores whether and how the statistical data
  will be printed near the drawing.
  */

/**
  \var double KDChartParams::_BWChartFenceUpperInner;
  \var double KDChartParams::_BWChartFenceLowerInner;
  \var double KDChartParams::_BWChartFenceUpperOuter;
  \var double KDChartParams::_BWChartFenceLowerOuter;

  Stores the factors to be used to calculate the width of
  the inner and outer fences.
  */

/**
  \var int KDChartParams::_BWChartOutValMarkerSize;

  Stores the size (or the negative size factor, resp.) of
  the markers representing the outliers.
  */


/**
  \var TQBrush KDChartParams::_BWChartBrush;

  Stores the brush to be used.
  */

/**
  \var LegendPosition KDChartParams::_legendPosition;

  Stores the legend position.
  */

/**
  \var LegendSource KDChartParams::_legendSource;

  Stores the legend source.
  */

/**
  \var TQMap < int, TQString > KDChartParams::_legendText;

  Stores the manually set legend texts.
  */


/**
  \var TQColor KDChartParams::_legendTextColor;

  Stores the color for drawing the legend texts.
  */

/**
  \var TQFont KDChartParams::_legendFont;

  Stores the font for drawing the legends.
  */

/**
  \var bool KDChartParams::_legendFontUseRelSize;

  Stores  whether the size of the legend font is to be calculated
  on a relative basis.

  \sa setLegendFontUseRelSize, setLegendFontRelSize
  \sa setLegendFont
  */

/**
  \var int KDChartParams::_legendFontRelSize;

  Stores  the per mille basis for calculating the relative
  legend font size.

  \sa setLegendFontRelSize, setLegendFontUseRelSize
  \sa setLegendFont
  */


/**
  \var TQString KDChartParams::_legendTitleText;

  Stores the legend title text.
  */


/**
  \var TQColor KDChartParams::_legendTitleTextColor;

  Stores the color for drawing the legend title.
  */


/**
  \var TQFont KDChartParams::_legendTitleFont;

  Stores the font for drawing the legend title.
  */

/**
  \var bool KDChartParams::_legendTitleFontUseRelSize;

  Stores  whether the size of the legend title font is to be
  calculated on a relative basis.

  \sa setLegendTitleFontUseRelSize, setLegendTitleFontRelSize
  \sa setLegendTitleFont
  */

/**
  \var int KDChartParams::_legendTitleFontRelSize;

  Stores  the per mille basis for calculating the relative
  legend title font size.

  \sa setLegendTitleFontRelSize, setLegendTitleFontUseRelSize
  \sa setLegendTitleFont
  */


/**
  \var uint KDChartParams::_legendSpacing;

  Stores the number of pixels between the legend and the data display
  */


/**
  \struct KDChartParams::AxisSettings KDChartParams.h

  Stores  all the settings of all the axis \em plus one more
  parameter set containing the build-in defauls axis settings.
  */

/**
  \var KDChartParams::_axisSettings

  Stores the settings for each of the possible thirteen axes
  */



/**
  \struct HdFtParams KDChartParams.h

  Stores  all the settings of all the header sections
  and all the footer sections.
  */



/**
  Retrieves the ID of the first KDChartCustomBox that is anchored at axis \c n.

  By default this box is used for the default axis title text: it is created
  (or modified, resp.) by calling one of the axis title convenience functions
  setAxisTitleColor or setAxisTitleFont or setAxisTitleFontUseRelSize or setAxisTitleFontRelSize.

  \note If you have specified another custom box manually that is anchored to this axis
  before (or instead of, resp.) calling one of the convenience functions mentioned above
  your custom box will become the default axis title text box: you then can access/modify
  its properties using these convenience functions.

  \return TRUE if a KDChartCustomBox was found that is anchored to axis \c n.
  \param n the axis number, this could be KDChartAxisParams::AxisPosLeft or KDChartAxisParams::AxisPosBottom...
  \param boxID will obtain the respective KDChartCustomBox's ID if return value is TRUE, otherwise the parameter's value remains unchanged.
  \sa setAxisTitle, setAxisTitleColor, setAxisTitleFont, setAxisTitleFontUseRelSize, setAxisTitleFontRelSize
  */
bool KDChartParams::findFirstAxisCustomBoxID( uint n, uint& boxID ) const
{
    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 ) ) );
   */
}

/**
  Specifies the default axis title text.

  \note This is a convenience function accessing the first KDChartCustomBox that is anchored at axis \c n.

  \param axisTitle the axis title text
  \sa setAxisTitleColor,setAxisTitleFont,setAxisTitleFontUseRelSize, setAxisTitleFontRelSize
  \sa axisTitle, axisTitleColor, axisTitleFont, axisTitleFontUseRelSize, axisTitleFontRelSize
  */
void KDChartParams::setAxisTitle( uint n, const 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();
}
/**
  Returns the default axis title text

  \return the axis title text.
  \sa setAxisTitle
  */
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();
}

/**
  Specifies the color of the default axis title text.

  \param axisTitleColor the color of the axis title text
  \sa setAxisTitle, setAxisTitleFont,setAxisTitleFontUseRelSize, setAxisTitleFontRelSize
  \sa axisTitle, axisTitleColor, axisTitleFont, axisTitleFontUseRelSize, axisTitleFontRelSize
  */
void  KDChartParams::setAxisTitleColor( uint n, 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();
}
/**
  Returns the color of the default axis title text

  \return the color of the axis title text.
  \sa setAxisTitleColor
  */
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;
}

/**
  Specifies the font and the size of the default axis title text.

  \param axisTitleFont the font of the axis title text
  \param useFontSize flag indicating whether the font's size is to be used
  \param axisTitleFontRelSize the size to be used if \c useFontSize is false, this is interpreted as per mil value of the printable area size
  \sa setAxisTitle, setAxisTitleColor,setAxisTitleFontUseRelSize, setAxisTitleFontRelSize
  \sa axisTitle, axisTitleColor, axisTitleFont, axisTitleFontUseRelSize, axisTitleFontRelSize
  */
void  KDChartParams::setAxisTitleFont( uint n,
                                       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();
}

/**
  Specifies the font and the size of the default axis title text.
 \param axisTitleFont the font of the axis title text - by default the font will be relative
 \param useFixedFontSize flag indicating whether the font's size is to be used as fixed or calculated  as per mil value.
  \param axisTitleFontRelSize the size to be used if \c useFixedFontSize is false, this is interpreted as per mil value of the printable area size
  \sa setAxisTitle, setAxisTitleColor, setAxisTitleFont, setAxisTitleFontUseRelSize, setAxisTitleFontRelSize
  \sa axisTitle, axisTitleColor, axisTitleFont, axisTitleFontUseRelSize, axisTitleFontRelSize
  */

void KDChartParams::setAxisTitleFont( uint n,
				      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);

}


/**
  Returns the font of the default axis title text.

  \return the axis title's font.
  \sa setAxisTitleFont
  */
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 );
}

/**
  Specifies whether the fixed size of the the default axis title text's font.

  \param axisTitleFontUseRelSize flag indicating whether the font's size is to be used or the size specified via setAxisTitleFontRelSize.
  \sa setAxisTitle, setAxisTitleColor,setAxisTitleFont, setAxisTitleFontRelSize
  \sa axisTitle, axisTitleColor, axisTitleFont, axisTitleFontUseRelSize, axisTitleFontRelSize
  */
void  KDChartParams::setAxisTitleFontUseRelSize( uint n,
                                                 bool axisTitleFontUseRelSize )
{
    bool bDone = false;
    uint boxID;
    if( findFirstAxisCustomBoxID( n, boxID ) ){
        KDChartCustomBox* box = (KDChartCustomBox*)customBox( boxID );
        if( box ){
          if ( !axisTitleFontUseRelSize ) {
            if ( box->fontSize() < 0 )
	      box->setFontSize( -(box->fontSize()), true );
	  } else {
	    if( 0 <= box->fontSize() ) {
	      box->setFontSize( -(box->fontSize()), true );
	    } else
              box->setFontSize( box->fontSize(), true);
	  }
            bDone = true;
        }
    }
    if( !bDone )
        insertDefaultAxisTitleBox( n,
                                   false, TQString(),
                                   false, TQColor(),
                                   false, TQFont(),
                                   true,  axisTitleFontUseRelSize,
                                   false, 0 );
    emit changed();
}
/**
  Returns whether the fix font size is used for the default axis title text.

  \return whether the fix axis title font size is used.
  \sa setAxisTitleFontUseRelSize
  */
bool KDChartParams::axisTitleFontUseRelSize( uint n ) const
{
    uint boxID;
    if( findFirstAxisCustomBoxID( n, boxID ) ){
        const KDChartCustomBox* box = customBox( boxID );
        if( box )
            return ( 0 > box->fontSize() );
    }
    return true;
}

/**
  Specifies whether a relative size to be used for the default axis title text instead of the fixed size of the font.

  Calling this function implicitely sets this axis's \c axisTitleFontUseRelSize flag to TRUE.

  \param axisTitleFontRelSize the size to be used, this is interpreted as per mil value of the printable area size.
  \sa setAxisTitle, setAxisTitleColor,setAxisTitleFont, setAxisTitleFontUseRelSize
  \sa axisTitle, axisTitleColor, axisTitleFont, axisTitleFontUseRelSize, axisTitleFontRelSize
  */
void  KDChartParams::setAxisTitleFontRelSize( uint n,
                                              int axisTitleFontRelSize )
{
    bool bDone = false;
    uint boxID;
    if( findFirstAxisCustomBoxID( n, boxID ) ){
        KDChartCustomBox* box = (KDChartCustomBox*)customBox( boxID );
        if( box ){
            box->setFontSize( -axisTitleFontRelSize, true );
            bDone = true;
        }
    }
    if( !bDone )
        insertDefaultAxisTitleBox( n,
                                   false, TQString(),
                                   false, TQColor(),
                                   false, TQFont(),
                                   true,  true,
                                   true,  axisTitleFontRelSize );
    emit changed();
}
/**
  Returns the relative size of the default axis title text, should
  be ignored if \c axisTitleFontUseRelSize returns false.

  \return the axis title's relative font size.
  \sa setAxisTitleFontRelSize
  */
int KDChartParams::axisTitleFontRelSize( uint n ) const
{
    uint boxID;
    if( findFirstAxisCustomBoxID( n, boxID ) ){
        const KDChartCustomBox* box = customBox( boxID );
        if( box ){
            int i = box->fontSize();
            return (0 > i) ? -i : i;
        }
    }
    return 18;
}