KDChartParams_io.cpp

/*
   KDChart - a multi-platform charting engine
   */
 
/****************************************************************************
 ** Copyright (C) 2001-2003 Klarälvdalens Datakonsult AB.  All rights reserved.
 **
 ** This file is part of the KDChart library.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** Licensees holding valid commercial KDChart licenses may use this file in
 ** accordance with the KDChart Commercial License Agreement provided with
 ** the Software.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ** See http://www.klaralvdalens-datakonsult.se/?page=products for
 **   information about KDChart Commercial License Agreements.
 **
 ** Contact info@klaralvdalens-datakonsult.se if any conditions of this
 ** licensing are not clear to you.
 **
 **********************************************************************/
#include "KDChartParams.h"
#include <KDXMLTools.h>
 
#include <tqintdict.h>
 
TQTextStream& operator<<( TQTextStream& s, const KDChartParams& p )
{
    TQDomDocument document = p.saveXML();
    s << document.toString();
 
    return s;
}
 
void KDChartParams::saveAxesToXML(TQDomDocument& doc, TQDomElement& docRoot) const
{
    // the AxisSettings elements
    for( int axis = 0; axis < 13; axis++ ) {
        TQDomElement axisSettingsElement =
            doc.createElement( "AxisSettings" );
        docRoot.appendChild( axisSettingsElement );
        axisSettingsElement.setAttribute( "Dataset",
                _axisSettings[axis].dataset );
        axisSettingsElement.setAttribute( "Dataset2",
                _axisSettings[axis].dataset2 );
        axisSettingsElement.setAttribute( "Chart",
                _axisSettings[axis].chart );
        {
            // the Type element
            KDXML::createStringNode( doc, axisSettingsElement, "Type",
                    KDChartAxisParams::axisTypeToString( _axisSettings[axis].params._axisType ) );
 
            // the Visible element
            KDXML::createBoolNode( doc, axisSettingsElement, "Visible",
                    _axisSettings[axis].params._axisVisible );
 
            // the LabelsTouchEdges element
            KDXML::createBoolNode( doc, axisSettingsElement, "LabelsTouchEdges",
                    _axisSettings[axis].params._axisLabelsTouchEdges );
 
            // the AreaMode element
            KDXML::createStringNode( doc, axisSettingsElement, "AreaMode",
                    KDChartAxisParams::axisAreaModeToString( _axisSettings[axis].params._axisAreaMode ) );
 
            // the UseAvailableSpaceFrom element
            KDXML::createIntNode( doc, axisSettingsElement, "UseAvailableSpaceFrom",
                    _axisSettings[axis].params._axisUseAvailableSpaceFrom );
 
            // the UseAvailableSpaceTo element
            KDXML::createIntNode( doc, axisSettingsElement, "UseAvailableSpaceTo",
                    _axisSettings[axis].params._axisUseAvailableSpaceTo );
 
            // the IsometricReferenceAxis element
            KDXML::createIntNode( doc, axisSettingsElement, "IsometricReferenceAxis",
                    _axisSettings[axis].params._axisIsoRefAxis );
 
            // the AreaMin element
            KDXML::createIntNode( doc, axisSettingsElement, "AreaMin",
                    _axisSettings[axis].params._axisAreaMin );
 
            // the AreaMax element
            KDXML::createIntNode( doc, axisSettingsElement, "AreaMax",
                    _axisSettings[axis].params._axisAreaMax );
 
            // the CalcMode element
            KDXML::createStringNode( doc, axisSettingsElement, "CalcMode",
                    KDChartAxisParams::axisCalcModeToString( _axisSettings[axis].params._axisCalcMode ) );
 
            // the TrueAreaSize element
            KDXML::createIntNode( doc, axisSettingsElement, "TrueAreaSize",
                    _axisSettings[axis].params._axisTrueAreaSize );
 
            // the TrueAreaRect element
            KDXML::createRectNode( doc, axisSettingsElement, "TrueAreaRect",
                    _axisSettings[axis].params._axisTrueAreaRect );
 
            // the ShowSubDelimiters element
            KDXML::createBoolNode( doc, axisSettingsElement, "ShowSubDelimiters",
                    _axisSettings[axis].params._axisShowSubDelimiters );
 
            // the LineVisible element
            KDXML::createBoolNode( doc, axisSettingsElement, "LineVisible",
                    _axisSettings[axis].params._axisLineVisible );
 
            // the LineWidth element
            KDXML::createIntNode( doc, axisSettingsElement, "LineWidth",
                    _axisSettings[axis].params._axisLineWidth );
 
            // the TrueLineWidth element
            KDXML::createIntNode( doc, axisSettingsElement, "TrueLineWidth",
                    _axisSettings[axis].params._axisTrueLineWidth );
 
            // the LineColor element
            KDXML::createColorNode( doc, axisSettingsElement, "LineColor",
                    _axisSettings[axis].params._axisLineColor );
 
            // the ShowGrid element
            KDXML::createBoolNode( doc, axisSettingsElement, "ShowGrid",
                    _axisSettings[axis].params._axisShowGrid );
 
            // the GridColor element
            KDXML::createColorNode( doc, axisSettingsElement, "GridColor",
                    _axisSettings[axis].params._axisGridColor );
 
            // the GridLineWidth element
            KDXML::createIntNode( doc, axisSettingsElement, "GridLineWidth",
                    _axisSettings[axis].params._axisGridLineWidth );
 
            // the GridStyle element
            KDXML::createStringNode( doc, axisSettingsElement, "GridStyle",
                    KDXML::penStyleToString( _axisSettings[axis].params._axisGridStyle ) );
 
            // the GridSubColor element
            KDXML::createColorNode( doc, axisSettingsElement, "GridSubColor",
                    _axisSettings[axis].params._axisGridSubColor );
 
            // the GridSubLineWidth element
            KDXML::createIntNode( doc, axisSettingsElement, "GridSubLineWidth",
                    _axisSettings[axis].params._axisGridSubLineWidth );
 
            // the GridSubStyle element
            KDXML::createStringNode( doc, axisSettingsElement, "GridSubStyle",
                    KDXML::penStyleToString( _axisSettings[axis].params._axisGridSubStyle ) );
 
            // the ZeroLineColor element
            KDXML::createColorNode( doc, axisSettingsElement, "ZeroLineColor",
                    _axisSettings[axis].params._axisZeroLineColor );
 
            // the LabelsVisible element
            KDXML::createBoolNode( doc, axisSettingsElement, "LabelsVisible",
                    _axisSettings[axis].params._axisLabelsVisible );
 
            // the LabelsFont element
            createChartFontNode( doc, axisSettingsElement, "LabelsFont",
                    _axisSettings[axis].params._axisLabelsFont,
                    _axisSettings[axis].params._axisLabelsFontUseRelSize,
                    _axisSettings[axis].params._axisLabelsFontRelSize,
                    _axisSettings[axis].params._axisLabelsFontMinSize );
 
            // the LabelsDontShrinkFont element
            KDXML::createBoolNode( doc, axisSettingsElement, "LabelsDontShrinkFont",
                    _axisSettings[axis].params._axisLabelsDontShrinkFont );
 
            // the LabelsDontAutoRotate element
            KDXML::createBoolNode( doc, axisSettingsElement, "LabelsDontAutoRotate",
                    _axisSettings[axis].params._axisLabelsDontAutoRotate );
 
            // the LabelsRotation element
            KDXML::createIntNode( doc, axisSettingsElement, "LabelsRotation",
                    _axisSettings[axis].params._axisLabelsRotation );
 
            // the LabelsLeaveOut element
            KDXML::createIntNode( doc, axisSettingsElement, "LabelsLeaveOut",
                    _axisSettings[axis].params._axisValueLeaveOut );
 
            // the LabelsColor element
            KDXML::createColorNode( doc, axisSettingsElement, "LabelsColor",
                    _axisSettings[axis].params._axisLabelsColor );
 
            // the SteadyValueCalc element
            KDXML::createBoolNode( doc, axisSettingsElement, "SteadyValueCalc",
                    _axisSettings[axis].params._axisSteadyValueCalc );
 
            // the ValueStart element
            if( ! ( KDCHART_AXIS_LABELS_AUTO_LIMIT == _axisSettings[axis].params._axisValueStart ))
                createChartValueNode( doc, axisSettingsElement, "ValueStart",
                        _axisSettings[axis].params._axisValueStart,
                        0.0,
                        0 );
 
            // the ValueStartIsExact element
            KDXML::createBoolNode( doc, axisSettingsElement, "ValueStartIsExact",
                    _axisSettings[axis].params._axisValueStartIsExact );
 
            // the ValueEnd element
            if( ! ( KDCHART_AXIS_LABELS_AUTO_LIMIT == _axisSettings[axis].params._axisValueEnd ))
                createChartValueNode( doc, axisSettingsElement, "ValueEnd",
                        _axisSettings[axis].params._axisValueEnd,
                        0.0,
                        0 );
 
            // the ValueDelta element
            if( ! ( KDCHART_AXIS_LABELS_AUTO_DELTA == _axisSettings[axis].params._axisValueDelta ))
                KDXML::createDoubleNode( doc, axisSettingsElement, "ValueDelta",
                        _axisSettings[axis].params._axisValueDelta );
            KDXML::createIntNode( doc, axisSettingsElement, "ValueDeltaScale",
                    _axisSettings[axis].params._axisValueDeltaScale );
 
            // the ValuesDecreasing element
            KDXML::createBoolNode( doc, axisSettingsElement, "ValuesDecreasing",
                    _axisSettings[axis].params._axisValuesDecreasing );
 
            // the TrueLow element
            KDXML::createDoubleNode( doc, axisSettingsElement, "TrueLow",
                    _axisSettings[axis].params._trueLow );
 
            // the TrueHigh element
            KDXML::createDoubleNode( doc, axisSettingsElement, "TrueHigh",
                    _axisSettings[axis].params._trueHigh );
 
            // the TrueDelta element
            KDXML::createDoubleNode( doc, axisSettingsElement, "TrueDelta",
                    _axisSettings[axis].params._trueDelta );
 
            // the ZeroLineStart element
            TQDomElement zeroLineStartElement = doc.createElement( "ZeroLineStart" );
            axisSettingsElement.appendChild( zeroLineStartElement );
            zeroLineStartElement.setAttribute( "X", _axisSettings[axis].params._axisZeroLineStartX );
            zeroLineStartElement.setAttribute( "Y", _axisSettings[axis].params._axisZeroLineStartY );
 
            // the DigitsBehindComma element
            KDXML::createIntNode( doc, axisSettingsElement, "DigitsBehindComma",
                    _axisSettings[axis].params._axisDigitsBehindComma );
 
            // the LabelsDateTimeFormat element
            KDXML::createStringNode( doc, axisSettingsElement, "LabelsDateTimeFormat",
                    _axisSettings[axis].params._axisLabelsDateTimeFormat );
 
            // the MaxEmptyInnerSpan element
            KDXML::createIntNode( doc, axisSettingsElement, "MaxEmptyInnerSpan",
                    _axisSettings[axis].params._axisMaxEmptyInnerSpan );
 
            // the LabelsFromDataRow element
            KDXML::createStringNode( doc, axisSettingsElement, "LabelsFromDataRow",
                    KDChartAxisParams::labelsFromDataRowToString( _axisSettings[axis].params._takeLabelsFromDataRow ) );
 
            // the TextsDataRow element
            KDXML::createIntNode( doc, axisSettingsElement, "TextsDataRow",
                    _axisSettings[axis].params._labelTextsDataRow );
 
            // the LabelString elements
            KDXML::createStringListNodes( doc, axisSettingsElement, "LabelString",
                    &_axisSettings[axis].params._axisLabelStringList );
 
            // the ShortLabelString elements
            KDXML::createStringListNodes( doc, axisSettingsElement, "ShortLabelString",
                    &_axisSettings[axis].params._axisShortLabelsStringList );
 
            // the LabelText elements
            KDXML::createStringListNodes( doc, axisSettingsElement, "LabelText",
                    &_axisSettings[axis].params._axisLabelTexts );
 
            // the LabelTextsDirty element
            KDXML::createBoolNode( doc, axisSettingsElement, "LabelTextsDirty",
                    _axisSettings[axis].params._axisLabelTextsDirty );
 
            // labels formatting:
 
            // the extra FirstLabelText element
            KDXML::createStringNode( doc, axisSettingsElement, "FirstLabelReplacementText",
                    _axisSettings[axis].params._axisFirstLabelText );
 
            // the extra LastLabelText element
            KDXML::createStringNode( doc, axisSettingsElement, "LastLabelReplacementText",
                    _axisSettings[axis].params._axisLastLabelText );
 
            // the LabelsDivPow10 element
            KDXML::createIntNode( doc, axisSettingsElement, "LabelsDivPow10",
                    _axisSettings[axis].params._axisLabelsDivPow10 );
 
            // the LabelsDecimalPoint element
            KDXML::createStringNode( doc, axisSettingsElement, "LabelsDecimalPoint",
                    _axisSettings[axis].params._axisLabelsDecimalPoint );
 
            // the LabelsThousandsPoint element
            KDXML::createStringNode( doc, axisSettingsElement, "LabelsThousandsPoint",
                    _axisSettings[axis].params._axisLabelsThousandsPoint );
 
            // the LabelsNotation element
            KDXML::createStringNode( doc, axisSettingsElement, "LabelsNotation",
                    KDChartEnums::numberNotationToString( _axisSettings[axis].params._axisLabelsNotation ) );
 
            // the LabelsPrefix element
            KDXML::createStringNode( doc, axisSettingsElement, "LabelsPrefix",
                    _axisSettings[axis].params._axisLabelsPrefix );
 
            // the LabelsPostfix element
            KDXML::createStringNode( doc, axisSettingsElement, "LabelsPostfix",
                    _axisSettings[axis].params._axisLabelsPostfix );
 
            // the LabelsTotalLen element
            KDXML::createIntNode( doc, axisSettingsElement, "LabelsTotalLen",
                    _axisSettings[axis].params._axisLabelsTotalLen );
 
            // the LabelsPadFill element
            KDXML::createStringNode( doc, axisSettingsElement, "LabelsPadFill",
                    _axisSettings[axis].params._axisLabelsPadFill );
 
            // the LabelsBlockAlign element
            KDXML::createBoolNode( doc, axisSettingsElement, "LabelsBlockAlign",
                    _axisSettings[axis].params._axisLabelsBlockAlign );
        }
    }
}
 
 
TQDomDocument KDChartParams::saveXML( bool withPI ) const
{
    // Create an inital DOM document
    TQString docstart = "<ChartParams/>";
 
    TQDomDocument doc( "ChartParams" );
    doc.setContent( docstart );
    if( withPI )
        doc.appendChild( doc.createProcessingInstruction( "xml", "version=\"1.0\" encoding=\"UTF-8\"" ) );
 
    TQDomElement docRoot = doc.documentElement();
    docRoot.setAttribute( "xmlns", "http://www.klaralvdalens-datakonsult.se/kdchart" );
    docRoot.setAttribute( "xmlns:xsi", "http://www.w3.org/2000/10/XMLSchema-instance" );
    docRoot.setAttribute( "xsi:schemaLocation", "http://www.klaralvdalens-datakonsult.se/kdchart" );
 
    // the ChartType element
    TQDomElement chartTypeElement = doc.createElement( "ChartType" );
    docRoot.appendChild( chartTypeElement );
    chartTypeElement.setAttribute( "primary",
            chartTypeToString( _chartType ) );
    chartTypeElement.setAttribute( "secondary",
            chartTypeToString( _additionalChartType ) );
 
 
    // the NumValues element
    KDXML::createIntNode( doc, docRoot, "NumValues", _numValues );
 
    // the ModeAndChartMap element
    TQDomElement modeAndChartMapElement =
        doc.createElement( "ModeAndChartMap" );
    docRoot.appendChild( modeAndChartMapElement );
    for( TQMap<uint,KDChartParams::ModeAndChart>::ConstIterator it = _dataSourceModeAndChart.begin();
            it != _dataSourceModeAndChart.end(); ++it ) {
        // Dataset element
        TQDomElement datasetElement = doc.createElement( "Dataset" );
        TQDomText datasetContent =
            doc.createTextNode( TQString::number( it.key() ) );
        datasetElement.appendChild( datasetContent );
        modeAndChartMapElement.appendChild( datasetElement );
        // ModeAndChart element
        TQDomElement modeAndChartElement = doc.createElement( "ModeAndChart" );
        modeAndChartElement.setAttribute( "Mode", chartSourceModeToString( it.data().mode() ) );
        modeAndChartElement.setAttribute( "Chart", it.data().chart() );
        modeAndChartMapElement.appendChild( modeAndChartElement );
    }
 
    // the PropertySetMap element
    TQDomElement propertySetMapElement =
        doc.createElement( "PropertySetMap" );
    docRoot.appendChild( propertySetMapElement );
    TQIntDictIterator<KDChartPropertySet> it2( _propertySetList );
    for( ; it2.current(); ++it2 )
        propertySetMapElement.appendChild( it2.current()->saveXML( doc ) );
 
    KDXML::createBoolNode( doc, docRoot, "ChartSourceModeWasUsed",
            _setChartSourceModeWasUsed );
 
    // the MaxDatasetSourceMode element
    KDXML::createIntNode( doc, docRoot, "MaxDatasetSourceMode",
            _maxDatasetSourceMode );
 
    // the ColorSettings element
    TQDomElement colorSettingsElement =
        doc.createElement( "ColorSettings" );
    docRoot.appendChild( colorSettingsElement );
 
    {
        // the DataColors element
        createColorMapNode( doc, colorSettingsElement,
                "DataColors", _dataColors );
 
        // the MaxDatasetColor element
        KDXML::createIntNode( doc, colorSettingsElement, "MaxDatasetColor",
                _maxDatasetColor );
 
        // the ShadowBrightnessFactor element
        KDXML::createDoubleNode( doc, colorSettingsElement,
                "ShadowBrightnessFactor",
                _shadowBrightnessFactor );
 
        // the ShadowPattern element
        KDXML::createStringNode( doc, colorSettingsElement,
                "ShadowPattern",
                KDXML::brushStyleToString(_shadowPattern ) );
 
        // the ThreeDShadowColors element
        KDXML::createBoolNode( doc, colorSettingsElement,
                "ThreeDShadowColors",
                _threeDShadowColors );
 
        // the DataColorsShadow1 element
        createColorMapNode( doc, colorSettingsElement,
                "DataColorsShadow1",
                _dataColorsShadow1 );
 
        // the DataColorsShadow2 element
        createColorMapNode( doc, colorSettingsElement,
                "DataColorsShadow2",
                _dataColorsShadow2 );
 
        // the OutlineDataColor element
        KDXML::createColorNode( doc, colorSettingsElement,
                "OutlineDataColor",
                _outlineDataColor );
 
        // the OutlineDataLineWidth element
        KDXML::createIntNode( doc, colorSettingsElement,
                "OutlineDataLineWidth",
                _outlineDataLineWidth );
 
        // the OutlineDataLineStyle element
        TQDomElement outlineDataLineStyleElement =
            doc.createElement( "OutlineDataLineStyle" );
        colorSettingsElement.appendChild( outlineDataLineStyleElement );
        outlineDataLineStyleElement.setAttribute( "Style",
                KDXML::penStyleToString( _outlineDataLineStyle ) );
    }
 
 
    // the BarSettings elemenet
    TQDomElement barSettingsElement =
        doc.createElement( "BarSettings" );
    docRoot.appendChild( barSettingsElement );
 
    {
        // the SubType element
        KDXML::createStringNode( doc, barSettingsElement,
                "SubType", KDChartParams::barChartSubTypeToString( _barChartSubType ) );
 
        KDXML::createBoolNode( doc, barSettingsElement,
                "ThreeDBars", _threeDBars );
 
        KDXML::createDoubleNode( doc, barSettingsElement,
                "ThreeDBarDepth", _threeDBarDepth );
 
        KDXML::createIntNode( doc, barSettingsElement,
                "DatasetGap", _datasetGap );
 
        KDXML::createBoolNode( doc, barSettingsElement,
                "DatasetGapIsRelative", _datasetGapIsRelative );
 
        KDXML::createIntNode( doc, barSettingsElement,
                "ValueBlockGap", _valueBlockGap );
 
        KDXML::createBoolNode( doc, barSettingsElement,
                "ValueBlockGapIsRelative",
                _valueBlockGapIsRelative );
 
        KDXML::createIntNode( doc, barSettingsElement,
                "BarWidth", _barWidth );
 
        KDXML::createBoolNode( doc, barSettingsElement,
                "SolidExcessArrows", _solidExcessArrows );
    }
 
 
    // the LineSettings element
    TQDomElement lineSettingsElement =
        doc.createElement( "LineSettings" );
    docRoot.appendChild( lineSettingsElement );
 
    {
        // the SubType element
        KDXML::createStringNode( doc, lineSettingsElement,
                "SubType", KDChartParams::lineChartSubTypeToString( _lineChartSubType ) );
 
        // the Marker element
        KDXML::createBoolNode( doc, lineSettingsElement,
                "Marker", _lineMarker );
 
        // the MarkerStyles elements
        {for( TQMap<uint,KDChartParams::LineMarkerStyle>::ConstIterator it = _lineMarkerStyles.begin();
                it != _lineMarkerStyles.end(); ++it ) {
            TQDomElement markerStyleElement = doc.createElement( "MarkerStyle" );
            lineSettingsElement.appendChild( markerStyleElement );
            markerStyleElement.setAttribute( "Dataset", it.key() );
            markerStyleElement.setAttribute( "Style", KDChartParams::lineMarkerStyleToString( it.data() ) );
        }}
 
        // the MarkerSize element
        KDXML::createSizeNode( doc, lineSettingsElement,
                "MarkerSize", _lineMarkerSize );
 
        // the LineWidth element
        KDXML::createIntNode( doc, lineSettingsElement,
                "LineWidth", _lineWidth );
 
        // the LineColor element
        KDXML::createColorNode( doc, lineSettingsElement,
                "LineColor",
                _lineColor );
 
        // the LineStyle element
        TQDomElement lineStyleElement =
            doc.createElement( "LineStyle" );
        lineSettingsElement.appendChild( lineStyleElement );
        lineStyleElement.setAttribute( "Style",
                KDXML::penStyleToString( _lineStyle ) );
 
        // the DatasetLineStyles elements
        {for( TQMap<uint,  TQt::PenStyle>::ConstIterator it = _datasetLineStyles.begin();
                it != _datasetLineStyles.end(); ++it ) {
            TQDomElement lineStyleElement = doc.createElement( "DatasetLineStyle" );
            lineSettingsElement.appendChild( lineStyleElement );
            lineStyleElement.setAttribute( "Dataset", it.key() );
            lineStyleElement.setAttribute( "Style", KDXML::penStyleToString( it.data() ) );
        }}
 
        // the ThreeD element
        KDXML::createBoolNode( doc, lineSettingsElement,
                "ThreeD", _threeDLines );
 
        // the ThreeDDepth element
        KDXML::createIntNode( doc, lineSettingsElement,
                "ThreeDDepth", _threeDLineDepth );
 
        // the ThreeDXRotation element
        KDXML::createIntNode( doc, lineSettingsElement,
                "ThreeDXRotation", _threeDLineXRotation );
 
        // the ThreeDYRotation element
        KDXML::createIntNode( doc, lineSettingsElement,
                "ThreeDYRotation", _threeDLineYRotation );
    }
 
 
    // the AreaSettings element
    TQDomElement areaSettingsElement =
        doc.createElement( "AreaSettings" );
    docRoot.appendChild( areaSettingsElement );
 
    {
        // the SubType element
        KDXML::createStringNode( doc, areaSettingsElement, "SubType",
                KDChartParams::areaChartSubTypeToString( _areaChartSubType ) );
 
        // the Location elemenet
        KDXML::createStringNode( doc, areaSettingsElement, "Location",
                KDChartParams::areaLocationToString( _areaLocation ) );
    }
 
 
    // the PieRingSettings element
    TQDomElement pieRingSettingsElement =
        doc.createElement( "PieRingSettings" );
    docRoot.appendChild( pieRingSettingsElement );
 
    {
        // the Explode element
        KDXML::createBoolNode( doc, pieRingSettingsElement, "Explode",
                _explode );
 
        // the DefaultExplodeFactor element
        KDXML::createDoubleNode( doc, pieRingSettingsElement, "DefaultExplodeFactor",
                _explodeFactor );
 
        // the ExplodeFactors element
        createDoubleMapNode( doc, pieRingSettingsElement, "ExplodeFactors",
                _explodeFactors );
 
        // the ExplodeSegment element
        for( TQValueList<int>::ConstIterator it = _explodeList.begin();
                it != _explodeList.end(); ++it )
            KDXML::createIntNode( doc, pieRingSettingsElement,
                    "ExplodeSegment", *it );
 
        // the ThreeDPies element
        KDXML::createBoolNode( doc, pieRingSettingsElement, "ThreeDPies",
                _threeDPies );
 
        // the ThreeDPieHeight element
        KDXML::createIntNode( doc, pieRingSettingsElement, "ThreeDPieHeight",
                _threeDPieHeight );
 
        // the PieStart element
        KDXML::createIntNode( doc, pieRingSettingsElement, "PieStart",
                _pieStart );
 
        // the RingStart element
        KDXML::createIntNode( doc, pieRingSettingsElement, "RingStart",
                _ringStart );
 
        // the RelativeRingThickness element
        KDXML::createBoolNode( doc, pieRingSettingsElement,
                "RelativeRingThickness", _relativeRingThickness );
    }
 
    // the HiLoSettings element
    TQDomElement hiLoSettingsElement =
        doc.createElement( "HiLoSettings" );
    docRoot.appendChild( hiLoSettingsElement );
    {
        // the SubType element
        KDXML::createStringNode( doc, hiLoSettingsElement, "SubType",
                KDChartParams::hiLoChartSubTypeToString( _hiLoChartSubType ) );
 
        // the PrintLowValues element
        KDXML::createBoolNode( doc, hiLoSettingsElement, "PrintLowValues",
                _hiLoChartPrintLowValues );
 
        // the LowValuesFont element
        createChartFontNode( doc, hiLoSettingsElement, "LowValuesFont",
                _hiLoChartLowValuesFont,
                _hiLoChartLowValuesUseFontRelSize,
                _hiLoChartLowValuesFontRelSize );
 
        // the LowValuesColor element
        KDXML::createColorNode( doc, hiLoSettingsElement, "LowValuesColor",
                _hiLoChartLowValuesColor );
 
        // the PrintHighValues element
        KDXML::createBoolNode( doc, hiLoSettingsElement, "PrintHighValues",
                _hiLoChartPrintHighValues );
 
        // the HighValuesFont element
        createChartFontNode( doc, hiLoSettingsElement, "HighValuesFont",
                _hiLoChartHighValuesFont,
                _hiLoChartHighValuesUseFontRelSize,
                _hiLoChartHighValuesFontRelSize );
 
        // the HighValuesColor element
        KDXML::createColorNode( doc, hiLoSettingsElement, "HighValuesColor",
                _hiLoChartHighValuesColor );
 
        // the PrintOpenValues element
        KDXML::createBoolNode( doc, hiLoSettingsElement, "PrintOpenValues",
                _hiLoChartPrintOpenValues );
 
        // the OpenValuesFont element
        createChartFontNode( doc, hiLoSettingsElement, "OpenValuesFont",
                _hiLoChartOpenValuesFont,
                _hiLoChartOpenValuesUseFontRelSize,
                _hiLoChartOpenValuesFontRelSize );
 
        // the OpenValuesColor element
        KDXML::createColorNode( doc, hiLoSettingsElement, "OpenValuesColor",
                _hiLoChartOpenValuesColor );
 
        // the PrintCloseValues element
        KDXML::createBoolNode( doc, hiLoSettingsElement, "PrintCloseValues",
                _hiLoChartPrintCloseValues );
 
        // the CloseValuesFont element
        createChartFontNode( doc, hiLoSettingsElement, "CloseValuesFont",
                _hiLoChartCloseValuesFont,
                _hiLoChartCloseValuesUseFontRelSize,
                _hiLoChartCloseValuesFontRelSize );
 
        // the CloseValuesColor element
        KDXML::createColorNode( doc, hiLoSettingsElement, "CloseValuesColor",
                _hiLoChartCloseValuesColor );
    }
 
 
 
    // the BoxAndWhiskerSettings element
    TQDomElement bWSettingsElement =
        doc.createElement( "BoxAndWhiskerSettings" );
    docRoot.appendChild( bWSettingsElement );
    {
        // the SubType element
        KDXML::createStringNode( doc, bWSettingsElement, "SubType",
                KDChartParams::bWChartSubTypeToString( _BWChartSubType ) );
 
        // the fences elements
        KDXML::createDoubleNode( doc, bWSettingsElement, "FenceUpperInner",
                _BWChartFenceUpperInner );
        KDXML::createDoubleNode( doc, bWSettingsElement, "FenceLowerInner",
                _BWChartFenceLowerInner );
        KDXML::createDoubleNode( doc, bWSettingsElement, "FenceUpperOuter",
                _BWChartFenceUpperInner );
        KDXML::createDoubleNode( doc, bWSettingsElement, "FenceLowerOuter",
                _BWChartFenceLowerOuter );
 
        // the brush to be used
        KDXML::createBrushNode( doc, bWSettingsElement, "Brush",
                _BWChartBrush );
 
        // the size of the outlier markers
        KDXML::createIntNode( doc, bWSettingsElement, "OutlierSize",
                _BWChartOutValMarkerSize );
 
        // the PrintStatistics elements
        for( int i = BWStatValSTART; i <= BWStatValEND; ++i ){
            TQDomElement printStatElement =
                doc.createElement( "PrintStatistics"+bWChartStatValToString( (BWStatVal)i ) );
            KDXML::createBoolNode(  doc, printStatElement, "Active",
                    _BWChartStatistics[ i ].active );
            createChartFontNode(    doc, printStatElement, "Font",
                    _BWChartStatistics[ i ].font,
                    _BWChartStatistics[ i ].useRelSize,
                    _BWChartStatistics[ i ].relSize );
            KDXML::createColorNode( doc, printStatElement, "Color",
                    _BWChartStatistics[ i ].color );
            KDXML::createBrushNode( doc, printStatElement, "Brush",
                    _BWChartStatistics[ i ].brush );
        }
    }
 
 
 
    // the PolarSettings element
    TQDomElement polarSettingsElement =
        doc.createElement( "PolarSettings" );
    docRoot.appendChild( polarSettingsElement );
 
    {
        // the SubType element
        KDXML::createStringNode( doc, polarSettingsElement,
                "SubType", KDChartParams::polarChartSubTypeToString( _polarChartSubType ) );
 
        // the Marker element
        KDXML::createBoolNode( doc, polarSettingsElement,
                "Marker", _polarMarker );
 
        // the MarkerStyles elements
        for( TQMap<uint,KDChartParams::PolarMarkerStyle>::ConstIterator it = _polarMarkerStyles.begin();
                it != _polarMarkerStyles.end(); ++it ) {
            TQDomElement markerStyleElement = doc.createElement( "MarkerStyle" );
            polarSettingsElement.appendChild( markerStyleElement );
            markerStyleElement.setAttribute( "Dataset", it.key() );
            markerStyleElement.setAttribute( "Style", KDChartParams::polarMarkerStyleToString( it.data() ) );
        }
 
        // the MarkerSize element
        KDXML::createSizeNode( doc, polarSettingsElement,
                "MarkerSize", _polarMarkerSize );
 
        // the PolarLineWidth element
        KDXML::createIntNode( doc, polarSettingsElement,
                "PolarLineWidth", _polarLineWidth );
    }
 
 
 
    // the LegendSettings element
    TQDomElement legendSettingsElement =
        doc.createElement( "LegendSettings" );
    docRoot.appendChild( legendSettingsElement );
    {
        // the Position element
        KDXML::createStringNode( doc, legendSettingsElement, "Position",
                KDChartParams::legendPositionToString( _legendPosition ) );
 
        // the Orientation element
        KDXML::createOrientationNode( doc, legendSettingsElement,
                                      "Orientation", _legendOrientation );
 
        // the ShowLines element
        KDXML::createBoolNode( doc, legendSettingsElement,
                                    "ShowLines", _legendShowLines );
 
        // the Source element
        KDXML::createStringNode( doc, legendSettingsElement, "Source",
                KDChartParams::legendSourceToString( _legendSource ) );
 
        // the Text elements
        for( TQMap<int,TQString>::ConstIterator it = _legendText.begin();
                it != _legendText.end(); ++it ) {
            TQDomElement legendTextElement = doc.createElement( "LegendText" );
            legendSettingsElement.appendChild( legendTextElement );
            legendTextElement.setAttribute( "Dataset", it.key() );
            legendTextElement.setAttribute( "Text", it.data() );
        }
 
        // the TextColor element
        KDXML::createColorNode( doc, legendSettingsElement, "TextColor",
                _legendTextColor );
 
        // the TextFont element
        createChartFontNode( doc, legendSettingsElement, "TextFont",
                _legendFont,
                _legendFontUseRelSize,
                _legendFontRelSize );
 
        // the TitleText element
        KDXML::createStringNode( doc, legendSettingsElement, "TitleText",
                _legendTitleText );
 
        // the TitleColor element
        KDXML::createColorNode( doc, legendSettingsElement, "TitleColor",
                _legendTitleTextColor );
 
        // the TitleFont element
        createChartFontNode( doc, legendSettingsElement, "TitleFont",
                _legendTitleFont,
                _legendTitleFontUseRelSize,
                _legendTitleFontRelSize );
 
        // the Spacing element
        KDXML::createIntNode( doc, legendSettingsElement, "Spacing",
                _legendSpacing );
    }
 
    saveAxesToXML(doc, docRoot);
 
    // the HeaderFooterSettings elements
    for( int hf = 0; hf < 18; hf++ ) {
        TQDomElement hfSettingsElement =
            doc.createElement( "HeaderFooterSettings" );
        docRoot.appendChild( hfSettingsElement );
        {
            KDXML::createStringNode( doc, hfSettingsElement, "Text",
                    _hdFtParams[hf]._text );
            createChartFontNode( doc, hfSettingsElement, "Font",
                    _hdFtParams[hf]._font,
                    _hdFtParams[hf]._fontUseRelSize,
                    _hdFtParams[hf]._fontRelSize );
            KDXML::createColorNode( doc, hfSettingsElement, "Color",
                    _hdFtParams[hf]._color );
        }
    }
 
 
    // the GlobalLeading element
    TQDomElement globalLeadingElement =
        doc.createElement( "GlobalLeading" );
    docRoot.appendChild( legendSettingsElement );
    {
        KDXML::createIntNode( doc, globalLeadingElement, "Left",
                _globalLeadingLeft );
        KDXML::createIntNode( doc, globalLeadingElement, "Top",
                _globalLeadingTop );
        KDXML::createIntNode( doc, globalLeadingElement, "Right",
                _globalLeadingRight );
        KDXML::createIntNode( doc, globalLeadingElement, "Bottom",
                _globalLeadingBottom );
    }
 
    // the DataValuesSettings1 element
    TQDomElement dataValuesSettings1Element =
        doc.createElement( "DataValuesSettings1" );
    docRoot.appendChild( dataValuesSettings1Element );
    {
        KDXML::createBoolNode( doc, dataValuesSettings1Element, "PrintDataValues",
                _printDataValuesSettings._printDataValues );
        KDXML::createIntNode( doc, dataValuesSettings1Element, "DivPow10",
                _printDataValuesSettings._divPow10 );
        KDXML::createIntNode( doc, dataValuesSettings1Element, "DigitsBehindComma",
                _printDataValuesSettings._digitsBehindComma );
        createChartFontNode( doc, dataValuesSettings1Element, "Font",
                _printDataValuesSettings._dataValuesFont,
                _printDataValuesSettings._dataValuesUseFontRelSize,
                _printDataValuesSettings._dataValuesFontRelSize );
        KDXML::createColorNode( doc, dataValuesSettings1Element, "Color",
                _printDataValuesSettings._dataValuesColor );
        KDXML::createBrushNode( doc, dataValuesSettings1Element, "Background",
                _printDataValuesSettings._dataValuesBrush );
        KDXML::createBoolNode( doc, dataValuesSettings1Element, "AutoColor",
                _printDataValuesSettings._dataValuesAutoColor );
        KDXML::createStringNode( doc, dataValuesSettings1Element,
                "AnchorNegativePosition",
                KDChartEnums::positionFlagToString( _printDataValuesSettings._dataValuesAnchorNegativePosition ) );
        KDXML::createIntNode( doc, dataValuesSettings1Element,
                "AnchorNegativeAlign",
                _printDataValuesSettings._dataValuesAnchorNegativeAlign );
        KDXML::createIntNode( doc, dataValuesSettings1Element,
                "AnchorNegativeDeltaX",
                _printDataValuesSettings._dataValuesAnchorNegativeDeltaX );
        KDXML::createIntNode( doc, dataValuesSettings1Element,
                "AnchorNegativeDeltaY",
                _printDataValuesSettings._dataValuesAnchorNegativeDeltaY );
        KDXML::createIntNode( doc, dataValuesSettings1Element,
                "NegativeRotation",
                _printDataValuesSettings._dataValuesNegativeRotation );
        KDXML::createStringNode( doc, dataValuesSettings1Element,
                "AnchorPositivePosition",
                KDChartEnums::positionFlagToString( _printDataValuesSettings._dataValuesAnchorPositivePosition ) );
        KDXML::createIntNode( doc, dataValuesSettings1Element,
                "AnchorPositiveAlign",
                _printDataValuesSettings._dataValuesAnchorPositiveAlign );
        KDXML::createIntNode( doc, dataValuesSettings1Element,
                "AnchorPositiveDeltaX",
                _printDataValuesSettings._dataValuesAnchorPositiveDeltaX );
        KDXML::createIntNode( doc, dataValuesSettings1Element,
                "AnchorPositiveDeltaY",
                _printDataValuesSettings._dataValuesAnchorPositiveDeltaY );
        KDXML::createIntNode( doc, dataValuesSettings1Element,
                "PositiveRotation",
                _printDataValuesSettings._dataValuesPositiveRotation );
 
        KDXML::createStringNode( doc, dataValuesSettings1Element,
                "LayoutPolicy",
                KDChartEnums::layoutPolicyToString( _printDataValuesSettings._dataValuesLayoutPolicy ) );
 
        KDXML::createBoolNode( doc, dataValuesSettings1Element, "ShowInfinite",
                               _printDataValuesSettings._dataValuesShowInfinite );
    }
 
    // the DataValuesSettings2 element
    TQDomElement dataValuesSettings2Element =
        doc.createElement( "DataValuesSettings2" );
    docRoot.appendChild( dataValuesSettings2Element );
    {
        KDXML::createBoolNode( doc, dataValuesSettings2Element, "PrintDataValues",
                _printDataValuesSettings2._printDataValues );
        KDXML::createIntNode( doc, dataValuesSettings2Element, "DivPow10",
                _printDataValuesSettings2._divPow10 );
        KDXML::createIntNode( doc, dataValuesSettings2Element, "DigitsBehindComma",
                _printDataValuesSettings2._digitsBehindComma );
        createChartFontNode( doc, dataValuesSettings2Element, "Font",
                _printDataValuesSettings2._dataValuesFont,
                _printDataValuesSettings2._dataValuesUseFontRelSize,
                _printDataValuesSettings2._dataValuesFontRelSize );
        KDXML::createColorNode( doc, dataValuesSettings2Element, "Color",
                _printDataValuesSettings2._dataValuesColor );
        KDXML::createBrushNode( doc, dataValuesSettings2Element, "Background",
                _printDataValuesSettings2._dataValuesBrush );
        KDXML::createBoolNode( doc, dataValuesSettings2Element, "AutoColor",
                _printDataValuesSettings2._dataValuesAutoColor );
        KDXML::createStringNode( doc, dataValuesSettings2Element,
                "AnchorNegativePosition",
                KDChartEnums::positionFlagToString( _printDataValuesSettings2._dataValuesAnchorNegativePosition ) );
        KDXML::createIntNode( doc, dataValuesSettings2Element,
                "AnchorNegativeAlign",
                _printDataValuesSettings2._dataValuesAnchorNegativeAlign );
        KDXML::createIntNode( doc, dataValuesSettings2Element,
                "AnchorNegativeDeltaX",
                _printDataValuesSettings2._dataValuesAnchorNegativeDeltaX );
        KDXML::createIntNode( doc, dataValuesSettings2Element,
                "AnchorNegativeDeltaY",
                _printDataValuesSettings2._dataValuesAnchorNegativeDeltaY );
        KDXML::createIntNode( doc, dataValuesSettings2Element,
                "NegativeRotation",
                _printDataValuesSettings2._dataValuesNegativeRotation );
        KDXML::createStringNode( doc, dataValuesSettings2Element,
                "AnchorPositivePosition",
                KDChartEnums::positionFlagToString( _printDataValuesSettings2._dataValuesAnchorPositivePosition ) );
        KDXML::createIntNode( doc, dataValuesSettings2Element,
                "AnchorPositiveAlign",
                _printDataValuesSettings2._dataValuesAnchorPositiveAlign );
        KDXML::createIntNode( doc, dataValuesSettings2Element,
                "AnchorPositiveDeltaX",
                _printDataValuesSettings2._dataValuesAnchorPositiveDeltaX );
        KDXML::createIntNode( doc, dataValuesSettings2Element,
                "AnchorPositiveDeltaY",
                _printDataValuesSettings2._dataValuesAnchorPositiveDeltaY );
        KDXML::createIntNode( doc, dataValuesSettings2Element,
                "PositiveRotation",
                _printDataValuesSettings2._dataValuesPositiveRotation );
 
        KDXML::createStringNode( doc, dataValuesSettings2Element,
                "LayoutPolicy",
                KDChartEnums::layoutPolicyToString( _printDataValuesSettings2._dataValuesLayoutPolicy ) );
 
        KDXML::createBoolNode( doc, dataValuesSettings2Element, "ShowInfinite",
                               _printDataValuesSettings2._dataValuesShowInfinite );
    }
 
    // global settings for data value settings of _all_ charts
    TQDomElement dataValuesGlobalSettingsElement =
        doc.createElement( "DataValuesGlobalSettings" );
    docRoot.appendChild( dataValuesGlobalSettingsElement );
    {
        KDXML::createBoolNode( doc, dataValuesGlobalSettingsElement,
                "allowOverlappingTexts",
                _allowOverlappingDataValueTexts );
    }
 
    // the AreaMap element
    TQDomElement areaMapElement =
        doc.createElement( "AreaMap" );
    docRoot.appendChild( areaMapElement );
    {
        TQDictIterator<KDChartFrameSettings> it( _areaDict );
        for( ; it.current(); ++it ){
            KDChartFrameSettings::createFrameSettingsNode( doc, areaMapElement,
                    "FrameSettings",
                    it.current(),
                    it.currentKey().left(5).stripWhiteSpace().toUInt() );
        }
    }
 
    // the CustomBoxMap element
    TQDomElement customBoxMapElement =
        doc.createElement( "CustomBoxMap" );
    docRoot.appendChild( customBoxMapElement );
    {
        TQIntDictIterator<KDChartCustomBox> it( _customBoxDict );
        for( ; it.current(); ++it ){
            KDXML::createIntNode( doc, customBoxMapElement, "Number", it.currentKey() );
            KDChartCustomBox::createCustomBoxNode( doc, customBoxMapElement,
                    "CustomBox", it );
        }
    }
 
 
    return doc;
}
 
 
TQTextStream& operator>>( TQTextStream& s, KDChartParams& p )
{
    TQDomDocument doc( "ChartParams" );
    // would be nicer if TQDomDocument could read from a TQTextStream...
    TQString docString = s.read();
    doc.setContent( docString );
 
    p.loadXML( doc );
 
    return s;
}
 
 
void KDChartParams::loadAxesFormXML(int& curAxisSettings, TQDomElement& element)
{
    KDChartAxisParams* axisSettings =
        &( _axisSettings[ curAxisSettings ].params );
    TQDomNode node = element.firstChild();
    while( !node.isNull() ) {
        TQDomElement element = node.toElement();
        if( !element.isNull() ) { // was really an element
            TQString tagName = element.tagName();
            if( tagName == "Type" ) {
                TQString string;
                if( KDXML::readStringNode( element, string ) )
                    axisSettings->_axisType = KDChartAxisParams::stringToAxisType( string );
            } else if( tagName == "Visible" ) {
                bool visible;
                if( KDXML::readBoolNode( element, visible ) )
                    axisSettings->_axisVisible = visible;
            } else if( tagName == "LabelsTouchEdges" ) {
                bool labelsTouchEdges;
                if( KDXML::readBoolNode( element, labelsTouchEdges ) )
                    axisSettings->_axisLabelsTouchEdges = labelsTouchEdges;
            } else if( tagName == "AreaMode" ) {
                TQString string;
                if( KDXML::readStringNode( element, string ) )
                    axisSettings->_axisAreaMode = KDChartAxisParams::stringToAxisAreaMode( string );
            } else if( tagName == "UseAvailableSpaceFrom" ) {
                int spaceFrom;
                if( KDXML::readIntNode( element, spaceFrom ) )
                    axisSettings->_axisUseAvailableSpaceFrom = spaceFrom;
            } else if( tagName == "UseAvailableSpaceTo" ) {
                int spaceTo;
                if( KDXML::readIntNode( element, spaceTo ) )
                    axisSettings->_axisUseAvailableSpaceTo = spaceTo;
            } else if( tagName == "IsometricReferenceAxis" ) {
                int isoRefAxis;
                if( KDXML::readIntNode( element,    isoRefAxis ) )
                    axisSettings->_axisIsoRefAxis = isoRefAxis;
            } else if( tagName == "AreaMin" ) {
                int areaMin;
                if( KDXML::readIntNode( element, areaMin ) )
                    axisSettings->_axisAreaMin = areaMin;
            } else if( tagName == "AreaMax" ) {
                int areaMax;
                if( KDXML::readIntNode( element, areaMax ) )
                    axisSettings->_axisAreaMax = areaMax;
            } else if( tagName == "CalcMode" ) {
                TQString string;
                if( KDXML::readStringNode( element, string ) )
                    axisSettings->_axisCalcMode = KDChartAxisParams::stringToAxisCalcMode( string );
            } else if( tagName == "TrueAreaSize" ) {
                int trueAreaSize;
                if( KDXML::readIntNode( element, trueAreaSize ) )
                    axisSettings->_axisTrueAreaSize = trueAreaSize;
            } else if( tagName == "TrueAreaRect" ) {
                TQRect trueAreaRect;
                if( KDXML::readRectNode( element, trueAreaRect ) )
                    axisSettings->_axisTrueAreaRect = trueAreaRect;
            } else if( tagName == "ShowSubDelimiters" ) {
                bool showSubDelimiters;
                if( KDXML::readBoolNode( element, showSubDelimiters ) )
                    axisSettings->_axisShowSubDelimiters = showSubDelimiters;
            } else if( tagName == "LineVisible" ) {
                bool lineVisible;
                if( KDXML::readBoolNode( element, lineVisible ) )
                    axisSettings->_axisLineVisible = lineVisible;
            } else if( tagName == "LineWidth" ) {
                int lineWidth;
                if( KDXML::readIntNode( element, lineWidth ) )
                    axisSettings->_axisLineWidth = lineWidth;
            } else if( tagName == "TrueLineWidth" ) {
                int trueLineWidth;
                if( KDXML::readIntNode( element, trueLineWidth ) )
                    axisSettings->_axisTrueLineWidth = trueLineWidth;
            } else if( tagName == "LineColor" ) {
                TQColor color;
                if( KDXML::readColorNode( element, color ) )
                    axisSettings->_axisLineColor = color;
            } else if( tagName == "ShowGrid" ) {
                bool showGrid;
                if( KDXML::readBoolNode( element, showGrid ) )
                    axisSettings->_axisShowGrid = showGrid;
            } else if( tagName == "GridColor" ) {
                TQColor color;
                if( KDXML::readColorNode( element, color ) )
                    axisSettings->_axisGridColor = color;
            } else if( tagName == "GridLineWidth" ) {
                int gridLineWidth;
                if( KDXML::readIntNode( element, gridLineWidth ) )
                    axisSettings->_axisGridLineWidth = gridLineWidth;
            } else if( tagName == "GridStyle" ) {
                if( element.hasAttribute( "Style" ) )
                    axisSettings->_axisGridStyle = KDXML::stringToPenStyle( element.attribute( "Style" ) );
            } else if( tagName == "GridSubColor" ) {
                TQColor color;
                if( KDXML::readColorNode( element, color ) )
                    axisSettings->_axisGridSubColor = color;
            } else if( tagName == "GridSubLineWidth" ) {
                int gridSubLineWidth;
                if( KDXML::readIntNode( element, gridSubLineWidth ) )
                    axisSettings->_axisGridSubLineWidth = gridSubLineWidth;
            } else if( tagName == "GridSubStyle" ) {
                if( element.hasAttribute( "Style" ) )
                    axisSettings->_axisGridSubStyle = KDXML::stringToPenStyle( element.attribute( "Style" ) );
            } else if( tagName == "ZeroLineColor" ) {
                TQColor color;
                if( KDXML::readColorNode( element, color ) )
                    axisSettings->_axisZeroLineColor = color;
            } else if( tagName == "LabelsVisible" ) {
                bool labelsVisible;
                if( KDXML::readBoolNode( element, labelsVisible ) )
                    axisSettings->_axisLabelsVisible = labelsVisible;
            } else if( tagName == "LabelsFont" ) {
                readChartFontNode( element,
                        axisSettings->_axisLabelsFont,
                        axisSettings->_axisLabelsFontUseRelSize,
                        axisSettings->_axisLabelsFontRelSize,
                        &axisSettings->_axisLabelsFontMinSize );
            } else if( tagName == "LabelsDontShrinkFont" ) {
                bool dontShrink;
                if( KDXML::readBoolNode( element, dontShrink ) )
                    axisSettings->_axisLabelsDontShrinkFont = dontShrink;
            } else if( tagName == "LabelsDontAutoRotate" ) {
                bool dontRotate;
                if( KDXML::readBoolNode( element, dontRotate ) )
                    axisSettings->_axisLabelsDontAutoRotate = dontRotate;
            } else if( tagName == "LabelsRotation" ) {
                int rotation;
                if( KDXML::readIntNode( element, rotation ) )
                    axisSettings->_axisLabelsRotation = rotation;
            } else if( tagName == "LabelsLeaveOut" ) {
                int leaveOut;
                if( KDXML::readIntNode( element, leaveOut ) )
                    axisSettings->_axisValueLeaveOut = leaveOut;
            } else if( tagName == "LabelsColor" ) {
                TQColor color;
                if( KDXML::readColorNode( element, color ) )
                    axisSettings->_axisLabelsColor = color;
            } else if( tagName == "SteadyValueCalc" ) {
                bool steadyValueCalc;
                if( KDXML::readBoolNode( element, steadyValueCalc ) )
                    axisSettings->_axisSteadyValueCalc = steadyValueCalc;
            } else if( tagName == "ValueStart" ) {
                TQVariant valX, valY;
                int propID;
                if( readChartValueNode( element, valY, valX, propID ) &&
                    TQVariant::Double == valY.type() )
                    axisSettings->_axisValueStart = valY.toDouble();
            } else if( tagName == "ValueStartIsExact" ) {
                bool isExactValue;
                if( KDXML::readBoolNode( element, isExactValue ) )
                    axisSettings->_axisValueStartIsExact = isExactValue;
            } else if( tagName == "ValueEnd" ) {
                TQVariant valX, valY;
                int propID;
                if( readChartValueNode( element, valY, valX, propID ) &&
                    TQVariant::Double == valY.type()  )
                    axisSettings->_axisValueEnd = valY.toDouble();
            } else if( tagName == "ValueDelta" ) {
                double valueDelta;
                if( KDXML::readDoubleNode( element, valueDelta ) )
                    axisSettings->_axisValueDelta = valueDelta;
            } else if( tagName == "ValueDeltaScale" ) {
                int valueDeltaScale;
                if( KDXML::readIntNode( element, valueDeltaScale ) )
                    axisSettings->_axisValueDeltaScale = (KDChartAxisParams::ValueScale)valueDeltaScale;
            } else if( tagName == "ValuesDecreasing" ) {
                bool decreasing;
                if( KDXML::readBoolNode( element, decreasing ) )
                    axisSettings->_axisValuesDecreasing = decreasing;
            } else if( tagName == "TrueLow" ) {
                double trueLow;
                if( KDXML::readDoubleNode( element, trueLow ) )
                    axisSettings->_trueLow  = trueLow;
            } else if( tagName == "TrueHigh" ) {
                double trueHigh;
                if( KDXML::readDoubleNode( element, trueHigh ) )
                    axisSettings->_trueHigh  = trueHigh;
            } else if( tagName == "TrueDelta" ) {
                double trueDelta;
                if( KDXML::readDoubleNode( element, trueDelta ) )
                    axisSettings->_trueDelta  = trueDelta;
            } else if( tagName == "ZeroLineStart" ) {
                double x = 0.0;
                double y = 0.0;
                bool ok = true;
                if( element.hasAttribute( "X" ) &&
                        element.hasAttribute( "Y" ) ) {
                    x = element.attribute( "X" ).toDouble( &ok );
                    if( ok )
                        y = element.attribute( "Y" ).toDouble( &ok );
                } else
                    ok = false;
 
                if( ok ) {
                    axisSettings->_axisZeroLineStartX = x;
                    axisSettings->_axisZeroLineStartY = y;
                }
            } else if( tagName == "DigitsBehindComma" ) {
                int digitsBehindComma;
                if( KDXML::readIntNode( element, digitsBehindComma ) )
                    axisSettings->_axisDigitsBehindComma = digitsBehindComma;
            } else if( tagName == "LabelsDateTimeFormat" ) {
                TQString string;
                if( KDXML::readStringNode( element, string ) )
                    axisSettings->_axisLabelsDateTimeFormat = string;
            } else if( tagName == "MaxEmptyInnerSpan" ) {
                int maxEmptyInnerSpan;
                if( KDXML::readIntNode( element, maxEmptyInnerSpan ) )
                    axisSettings->_axisMaxEmptyInnerSpan = maxEmptyInnerSpan;
            } else if( tagName == "LabelsFromDataRow" ) {
                TQString string;
                if( KDXML::readStringNode( element, string ) )
                    axisSettings->_labelTextsDataRow = KDChartAxisParams::stringToLabelsFromDataRow( string );
            } else if( tagName == "TextsDataRow" ) {
                int textsDataRow;
                if( KDXML::readIntNode( element, textsDataRow ) )
                    axisSettings->_labelTextsDataRow = textsDataRow;
            } else if( tagName == "LabelString" ) {
                TQString string;
                if( KDXML::readStringNode( element, string ) )
                    axisSettings->_axisLabelStringList << string;
            } else if( tagName == "ShortLabelString" ) {
                TQString string;
                if( KDXML::readStringNode( element, string ) )
                    axisSettings->_axisShortLabelsStringList << string;
            } else if( tagName == "LabelText" ) {
                TQString string;
                if( KDXML::readStringNode( element, string ) )
                    axisSettings->_axisLabelTexts = string;
            } else if( tagName == "LabelTextsDirty" ) {
                bool labelTextsDirty;
                if( KDXML::readBoolNode( element, labelTextsDirty ) )
                    axisSettings->_axisLabelTextsDirty = labelTextsDirty;
            } else if( tagName == "FirstLabelReplacementText" ) {
                TQString value;
                if( KDXML::readStringNode( element, value ) )
                    axisSettings->_axisFirstLabelText = value;
            } else if( tagName == "LastLabelReplacementText" ) {
                TQString value;
                if( KDXML::readStringNode( element, value ) )
                    axisSettings->_axisLastLabelText = value;
            } else if( tagName == "LabelsDivPow10" ) {
                int divPow10;
                if( KDXML::readIntNode( element, divPow10 ) )
                    axisSettings->_axisLabelsDivPow10 = divPow10;
            } else if( tagName == "LabelsDecimalPoint" ) {
                TQString value;
                if( KDXML::readStringNode( element, value ) )
                    axisSettings->_axisLabelsDecimalPoint = value;
            } else if( tagName == "LabelsThousandsPoint" ) {
                TQString value;
                if( KDXML::readStringNode( element, value ) )
                    axisSettings->_axisLabelsThousandsPoint = value;
            } else if( tagName == "LabelsNotation" ) {
                TQString string;
                if( KDXML::readStringNode( element, string ) )
                    axisSettings->_axisLabelsNotation = KDChartEnums::stringToNumberNotation( string );
            } else if( tagName == "LabelsPrefix" ) {
                TQString value;
                if( KDXML::readStringNode( element, value ) )
                    axisSettings->_axisLabelsPrefix = value;
            } else if( tagName == "LabelsPostfix" ) {
                TQString value;
                if( KDXML::readStringNode( element, value ) )
                    axisSettings->_axisLabelsPostfix = value;
            } else if( tagName == "LabelsTotalLen" ) {
                int totalLen;
                if( KDXML::readIntNode( element, totalLen ) )
                    axisSettings->_axisLabelsTotalLen = totalLen;
            } else if( tagName == "LabelsPadFill" ) {
                TQString value;
                if( KDXML::readStringNode( element, value ) ){
                    if( value.isEmpty() )
                        axisSettings->_axisLabelsPadFill = ' ';
                    else
                        axisSettings->_axisLabelsPadFill = value.at(0);
                }
            } else if( tagName == "LabelsBlockAlign" ) {
                bool blockAlign;
                if( KDXML::readBoolNode( element, blockAlign ) )
                    axisSettings->_axisLabelsBlockAlign = blockAlign;
            } else {
                tqDebug( "Unknown subelement of AxisSettings found: %s", tagName.latin1() );
            }
        }
        node = node.nextSibling();
    }
    curAxisSettings++; // one axis settings entry finished
}
 
 
bool KDChartParams::loadXML( const TQDomDocument& doc )
{
    int curAxisSettings = 0;
    int curHFSettings = 0;
 
    TQDomElement docRoot = doc.documentElement(); // ChartParams element
    TQDomNode node = docRoot.firstChild();
    while( !node.isNull() ) {
        TQDomElement element = node.toElement();
        if( !element.isNull() ) { // was really an element
            TQString tagName = element.tagName();
            if( tagName == "ChartType" ) {
                if( element.hasAttribute( "primary" ) )
                    _chartType = KDChartParams::stringToChartType( element.attribute( "primary" ) );
                if( element.hasAttribute( "secondary" ) )
                    _additionalChartType = KDChartParams::stringToChartType( element.attribute( "secondary" ) );
            } else if( tagName == "NumValues" ) {
                int numValues;
                if( KDXML::readIntNode( element, numValues ) )
                    _numValues = numValues;
            } else if( tagName == "ModeAndChartMap" ) {
                int dataset = -1;
                TQDomNode node = element.firstChild();
                while( !node.isNull() ) {
                    TQDomElement element = node.toElement();
                    if( !element.isNull() ) { // was really an element
                        TQString tagName = element.tagName();
                        if( tagName == "Dataset" ) {
                            KDXML::readIntNode( element, dataset );
                        } else if( tagName == "ModeAndChart" ) {
                            Q_ASSERT( dataset != -1 ); // there must have been a dataset tag before
                            if( element.hasAttribute( "Mode" ) &&
                                    element.hasAttribute( "Chart" ) ) {
                                KDChartParams::SourceMode sourceMode = KDChartParams::stringToChartSourceMode( element.attribute( "Mode" ) );
                                bool ok = false;
                                uint chart = element.attribute( "Chart" ).toUInt( &ok );
                                if( ok )
                                    _dataSourceModeAndChart[dataset] = KDChartParams::ModeAndChart( sourceMode, chart );
                            }
                        } else {
                            tqDebug( "Unknown subelement of ModeAndChartMap found: %s", tagName.latin1() );
                        }
                    }
                    node = node.nextSibling();
                }
            } else if( tagName == "PropertySetMap" ) {
                // the PropertySetMap element
                TQDomNode node = element.firstChild();
                KDChartPropertySet set;
                while( !node.isNull() ) {
                    TQDomElement element = node.toElement();
                    if(    !element.isNull() // was really an element
                            && KDChartPropertySet::loadXML( element, set ) ) // parsed OK
                        setProperties( set.id(), set );
                    node = node.nextSibling();
                }
            } else if( tagName == "ChartSourceModeWasUsed" ) {
                bool chartSourceModeWasUsed;
                if( KDXML::readBoolNode( element, chartSourceModeWasUsed ) )
                    _setChartSourceModeWasUsed = chartSourceModeWasUsed;
            } else if( tagName == "MaxDatasetSourceMode" ) {
                int maxDatasetSourceMode;
                if( KDXML::readIntNode( element, maxDatasetSourceMode ) )
                    _maxDatasetSourceMode = maxDatasetSourceMode;
            } else if( tagName == "ColorSettings" ) {
                TQDomNode node = element.firstChild();
                while( !node.isNull() ) {
                    TQDomElement element = node.toElement();
                    if( !element.isNull() ) { // was really an element
                        TQString tagName = element.tagName();
                        if( tagName == "DataColors" ) {
                            TQMap<uint,TQColor>* map = &_dataColors;
                            readColorMapNode( element, map );
                        } else if( tagName == "MaxDatasetColor" ) {
                            int maxDatasetColor;
                            if( KDXML::readIntNode( element, maxDatasetColor ) )
                                _maxDatasetColor = maxDatasetColor;
                        } else if( tagName == "ShadowBrightnessFactor" ) {
                            double shadowBrightnessFactor;
                            if( KDXML::readDoubleNode( element, shadowBrightnessFactor ) )
                                _shadowBrightnessFactor = shadowBrightnessFactor;
                        } else if( tagName == "ShadowPattern" ) {
                            TQString value;
                            if( KDXML::readStringNode( element, value ) )
                                _shadowPattern = KDXML::stringToBrushStyle( value );
                        } else if( tagName == "ThreeDShadowColors" ) {
                            bool threeDShadowColors;
                            if( KDXML::readBoolNode( element, threeDShadowColors ) )
                                _threeDShadowColors = threeDShadowColors;
                        } else if( tagName == "DataColorsShadow1" ) {
                            TQMap<uint,TQColor>* map = &_dataColorsShadow1;
                            readColorMapNode( element, map );
                        } else if( tagName == "DataColorsShadow2" ) {
                            TQMap<uint,TQColor>* map = &_dataColorsShadow2;
                            readColorMapNode( element, map );
                        } else if( tagName == "OutlineDataColor" ) {
                            TQColor color;
                            if( KDXML::readColorNode( element, color ) )
                                _outlineDataColor = color;
                        } else if( tagName == "OutlineDataLineWidth" ) {
                            int outlineDataLineWidth;
                            if( KDXML::readIntNode( element, outlineDataLineWidth ) )
                                _outlineDataLineWidth = outlineDataLineWidth;
                        } else if( tagName == "OutlineDataLineStyle" ) {
                            if( element.hasAttribute( "Style" ) )
                                _outlineDataLineStyle = KDXML::stringToPenStyle( element.attribute( "Style" ) );
                        } else {
                            tqDebug( "!!!Unknown subelement of ColorSettings found: %s", tagName.latin1() );
                        }
                    }
                    node = node.nextSibling();
                }
            } else if( tagName == "BarSettings" ) {
                TQDomNode node = element.firstChild();
                while( !node.isNull() ) {
                    TQDomElement element = node.toElement();
                    if( !element.isNull() ) { // was really an element
                        TQString tagName = element.tagName();
                        if( tagName == "SubType" ) {
                            TQString value;
                            if( KDXML::readStringNode( element, value ) )
                                _barChartSubType = KDChartParams::stringToBarChartSubType( value );
                        } else if( tagName == "ThreeDBars" ) {
                            bool threeDBars;
                            if( KDXML::readBoolNode( element, threeDBars ) )
                                _threeDBars = threeDBars;
                        } else if( tagName == "ThreeDBarDepth" ) {
                            double threeDBarDepth;
                            if( KDXML::readDoubleNode( element, threeDBarDepth ) )
                                _threeDBarDepth = threeDBarDepth;
                        } else if( tagName == "DatasetGap" ) {
                            int datasetGap;
                            if( KDXML::readIntNode( element, datasetGap ) )
                                _datasetGap = datasetGap;
                        } else if( tagName == "DatasetGapIsRelative" ) {
                            bool datasetGapIsRelative;
                            if( KDXML::readBoolNode( element, datasetGapIsRelative ) )
                                _datasetGapIsRelative = datasetGapIsRelative;
                        } else if( tagName == "ValueBlockGap" ) {
                            int valueBlockGap;
                            if( KDXML::readIntNode( element, valueBlockGap ) )
                                _valueBlockGap = valueBlockGap;
                        } else if( tagName == "ValueBlockGapIsRelative" ) {
                            bool valueBlockGapIsRelative;
                            if( KDXML::readBoolNode( element, valueBlockGapIsRelative ) )
                                _valueBlockGapIsRelative = valueBlockGapIsRelative;
                         } else if( tagName == "BarWidth" ) {
                            int barWidth;
                            if( KDXML::readIntNode( element, barWidth ) )
                                _barWidth = barWidth;
                        } else if( tagName == "SolidExcessArrows" ) {
                            bool solidExcessArrows;
                            if( KDXML::readBoolNode( element, solidExcessArrows ) )
                                _solidExcessArrows = solidExcessArrows;
                        } else {
                            tqDebug( "Unknown subelement of BarSettings found: %s", tagName.latin1() );
                        }
                    }
                    node = node.nextSibling();
                }
            } else if( tagName == "LineSettings" ) {
                TQDomNode node = element.firstChild();
                while( !node.isNull() ) {
                    TQDomElement element = node.toElement();
                    if( !element.isNull() ) { // was really an element
                        TQString tagName = element.tagName();
                        if( tagName == "SubType" ) {
                            TQString value;
                            if( KDXML::readStringNode( element, value ) )
                                _lineChartSubType = KDChartParams::stringToLineChartSubType( value );
                        } else if( tagName == "Marker" ) {
                            bool marker;
                            if( KDXML::readBoolNode( element, marker ) )
                                _lineMarker = marker;
                        } else if( tagName == "MarkerStyle" ) {
                            bool ok = true;
                            uint dataset;
                            KDChartParams::LineMarkerStyle style = LineMarkerCircle;
                            if( element.hasAttribute( "Dataset" ) &&
                                    element.hasAttribute( "Style" ) ) {
                                dataset = element.attribute( "Dataset" ).toUInt( &ok );
                                if( ok )
                                    style = KDChartParams::stringToLineMarkerStyle( element.attribute( "Style" ) );
                            } else
                                ok = false;
                            if( ok )
                                _lineMarkerStyles[dataset] = style;
                        } else if( tagName == "MarkerSize" ) {
                            int width = 1;
                            int height= 1;
                            bool ok = true;
                            if( element.hasAttribute( "Width" ) &&
                                element.hasAttribute( "Height" ) ) {
                                width = element.attribute( "Width" ).toInt( &ok );
                                if( ok )
                                    height = element.attribute( "Height" ).toInt( &ok );
                            } else
                                ok = false;
 
                            if( ok ) {
                                _lineMarkerSize.setWidth( width );
                                _lineMarkerSize.setHeight( height );
                            }
                        } else if( tagName == "LineWidth" ) {
                            int lineWidth;
                            if( KDXML::readIntNode( element, lineWidth ) )
                                _lineWidth = lineWidth;
                        } else if( tagName == "LineColor" ) {
                            TQColor color;
                            if( KDXML::readColorNode( element, color ) )
                                _lineColor = color;
                        } else if( tagName == "LineStyle" ) {
                            if( element.hasAttribute( "Style" ) )
                                _lineStyle = KDXML::stringToPenStyle( element.attribute( "Style" ) );
                        } else if( tagName == "DatasetLineStyle" ) {
                            bool ok = true;
                            uint dataset;
                            TQt::PenStyle style = TQt::SolidLine;
                            if( element.hasAttribute( "Dataset" ) &&
                                element.hasAttribute( "Style" ) ) {
                                dataset = element.attribute( "Dataset" ).toUInt( &ok );
                                if( ok )
                                    style = KDXML::stringToPenStyle( element.attribute( "Style" ) );
                            } else
                                ok = false;
                            if( ok )
                                _datasetLineStyles[dataset] = style;
                        } else if( tagName == "ThreeD" ) {
                            bool threeD;
                            if( KDXML::readBoolNode( element, threeD ) )
                                _threeDLines = threeD;
                        } else if( tagName == "ThreeDDepth" ) {
                            int depth;
                            if( KDXML::readIntNode( element, depth ) )
                                _threeDLineDepth = depth;
                        } else if( tagName == "ThreeDXRotation" ) {
                            int rotation;
                            if( KDXML::readIntNode( element, rotation ) )
                                _threeDLineXRotation = rotation;
                        } else if( tagName == "ThreeDYRotation" ) {
                            int rotation;
                            if( KDXML::readIntNode( element, rotation ) )
                                _threeDLineYRotation = rotation;
                        } else {
                            tqDebug( "Unknown subelement of LineSettings found: %s", tagName.latin1() );
                        }
                    }
                    node = node.nextSibling();
                }
            } else if( tagName == "AreaSettings" ) {
                TQDomNode node = element.firstChild();
                while( !node.isNull() ) {
                    TQDomElement element = node.toElement();
                    if( !element.isNull() ) { // was really an element
                        TQString tagName = element.tagName();
                        if( tagName == "SubType" ) {
                            TQString value;
                            if( KDXML::readStringNode( element, value ) )
                                _areaChartSubType = KDChartParams::stringToAreaChartSubType( value );
                        } else if( tagName == "Location" ) {
                            TQString string;
                            if( KDXML::readStringNode( element, string ) )
                                _areaLocation = KDChartParams::stringToAreaLocation( string );
                        } else {
                            tqDebug( "Unknown subelement of AreaSettings found: %s", tagName.latin1() );
                        }
                    }
                    node = node.nextSibling();
                }
            } else if( tagName == "PieRingSettings" ) {
                TQDomNode node = element.firstChild();
                while( !node.isNull() ) {
                    TQDomElement element = node.toElement();
                    if( !element.isNull() ) { // was really an element
                        TQString tagName = element.tagName();
                        if( tagName == "Explode" ) {
                            bool explode;
                            if( KDXML::readBoolNode( element, explode ) )
                                _explode = explode;
                        } else if( tagName == "DefaultExplodeFactor" ) {
                            double defaultExplodeFactor;
                            if( KDXML::readDoubleNode( element, defaultExplodeFactor ) )
                                _explodeFactor = defaultExplodeFactor;
                        } else if( tagName == "ExplodeFactors" ) {
                            TQMap<int,double>* map = &_explodeFactors;
                            readDoubleMapNode( element, map );
                        } else if( tagName == "ExplodeSegment" ) {
                            int explodeSegment;
                            if( KDXML::readIntNode( element, explodeSegment ) )
                                _explodeList << explodeSegment;
                        } else if( tagName == "ThreeDPies" ) {
                            bool threeDPies;
                            if( KDXML::readBoolNode( element, threeDPies ) )
                                _threeDPies = threeDPies;
                        } else if( tagName == "ThreeDPieHeight" ) {
                            int threeDPieHeight;
                            if( KDXML::readIntNode( element, threeDPieHeight ) )
                                _threeDPieHeight = threeDPieHeight;
                        } else if( tagName == "PieStart" ) {
                            int pieStart;
                            if( KDXML::readIntNode( element, pieStart ) )
                                _pieStart = pieStart;
                        } else if( tagName == "RingStart" ) {
                            int ringStart;
                            if( KDXML::readIntNode( element, ringStart ) )
                                _ringStart = ringStart;
                        } else if( tagName == "RelativeRingThickness" ) {
                            bool relativeRingThickness;
                            if( KDXML::readBoolNode( element, relativeRingThickness ) )
                                _relativeRingThickness = relativeRingThickness;
                        } else {
                            tqDebug( "Unknown subelement of PieRingSettings found: %s", tagName.latin1() );
                        }
                    }
                    node = node.nextSibling();
                }
            } else if( tagName == "HiLoSettings" ) {
                TQDomNode node = element.firstChild();
                while( !node.isNull() ) {
                    TQDomElement element = node.toElement();
                    if( !element.isNull() ) { // was really an element
                        TQString tagName = element.tagName();
                        if( tagName == "SubType" ) {
                            TQString value;
                            if( KDXML::readStringNode( element, value ) )
                                _hiLoChartSubType = KDChartParams::stringToHiLoChartSubType( value );
                        } else if( tagName == "PrintLowValues" ) {
                            bool printLowValues;
                            if( KDXML::readBoolNode( element, printLowValues ) )
                                _hiLoChartPrintLowValues = printLowValues;
                        } else if( tagName == "LowValuesFont" ) {
                            readChartFontNode( element,
                                    _hiLoChartLowValuesFont,
                                    _hiLoChartLowValuesUseFontRelSize,
                                    _hiLoChartLowValuesFontRelSize );
                        } else if( tagName == "LowValuesColor" ) {
                            TQColor color;
                            if( KDXML::readColorNode( element, color ) )
                                _hiLoChartLowValuesColor = color;
                        } else if( tagName == "PrintHighValues" ) {
                            bool printHighValues;
                            if( KDXML::readBoolNode( element, printHighValues ) )
                                _hiLoChartPrintHighValues = printHighValues;
                        } else if( tagName == "HighValuesFont" ) {
                            readChartFontNode( element,
                                    _hiLoChartHighValuesFont,
                                    _hiLoChartHighValuesUseFontRelSize,
                                    _hiLoChartHighValuesFontRelSize );
                        } else if( tagName == "HighValuesColor" ) {
                            TQColor color;
                            if( KDXML::readColorNode( element, color ) )
                                _hiLoChartHighValuesColor = color;
                        } else if( tagName == "PrintOpenValues" ) {
                            bool printOpenValues;
                            if( KDXML::readBoolNode( element, printOpenValues ) )
                                _hiLoChartPrintOpenValues = printOpenValues;
                        } else if( tagName == "OpenValuesFont" ) {
                            readChartFontNode( element,
                                    _hiLoChartOpenValuesFont,
                                    _hiLoChartOpenValuesUseFontRelSize,
                                    _hiLoChartOpenValuesFontRelSize );
                        } else if( tagName == "OpenValuesColor" ) {
                            TQColor color;
                            if( KDXML::readColorNode( element, color ) )
                                _hiLoChartOpenValuesColor = color;
                        } else if( tagName == "PrintCloseValues" ) {
                            bool printCloseValues;
                            if( KDXML::readBoolNode( element, printCloseValues ) )
                                _hiLoChartPrintCloseValues = printCloseValues;
                        } else if( tagName == "CloseValuesFont" ) {
                            readChartFontNode( element,
                                    _hiLoChartCloseValuesFont,
                                    _hiLoChartCloseValuesUseFontRelSize,
                                    _hiLoChartCloseValuesFontRelSize );
                        } else if( tagName == "CloseValuesColor" ) {
                            TQColor color;
                            if( KDXML::readColorNode( element, color ) )
                                _hiLoChartCloseValuesColor = color;
                        } else {
                            tqDebug( "Unknown subelement of HiLoSettings found: %s", tagName.latin1() );
                        }
                    }
                    node = node.nextSibling();
                }
 
 
            } else if( tagName == "BoxAndWhiskerSettings" ) {
                TQDomNode node = element.firstChild();
                while( !node.isNull() ) {
                    TQDomElement element = node.toElement();
                    if( !element.isNull() ) { // was really an element
                        TQString tagName = element.tagName();
                        if( tagName == "SubType" ) {
                            TQString value;
                            if( KDXML::readStringNode( element, value ) )
                                _BWChartSubType = KDChartParams::stringToBWChartSubType( value );
                        } else if( tagName == "FenceUpperInner" ) {
                            double fence;
                            if( KDXML::readDoubleNode( element, fence ) )
                                _BWChartFenceUpperInner = fence;
                        } else if( tagName == "FenceLowerInner" ) {
                            double fence;
                            if( KDXML::readDoubleNode( element, fence ) )
                                _BWChartFenceUpperOuter = fence;
                        } else if( tagName == "FenceUpperOuter" ) {
                            double fence;
                            if( KDXML::readDoubleNode( element, fence ) )
                                _BWChartFenceUpperOuter = fence;
                        } else if( tagName == "FenceLowerOuter" ) {
                            double fence;
                            if( KDXML::readDoubleNode( element, fence ) )
                                _BWChartFenceUpperOuter = fence;
                        } else if( tagName == "Brush" ) {
                            TQBrush brush;
                            if( KDXML::readBrushNode( element, brush ) )
                                _BWChartBrush = brush;
                        } else if( tagName == "OutlierSize" ) {
                            int size;
                            if( KDXML::readIntNode( element, size ) )
                                _BWChartOutValMarkerSize = size;
                        } else if( tagName.startsWith("PrintStatistics") ) {
                            // 012345678901234
                            TQString statName(tagName.mid( 15 ));
                            BWStatVal i( stringToBWChartStatVal( statName ) );
                            if( BWStatValSTART <= i && i <= BWStatValEND ) {
                                TQDomNode node = element.firstChild();
                                while( !node.isNull() ) {
                                    TQDomElement element = node.toElement();
                                    if( !element.isNull() ) { // was really an element
                                        TQString tagName = element.tagName();
                                        if( tagName == "Active" ) {
                                            bool active;
                                            if( KDXML::readBoolNode( element, active ) )
                                                _BWChartStatistics[ i ].active = active;
                                        } else if( tagName == "Font" ) {
                                            readChartFontNode( element,
                                                    _BWChartStatistics[ i ].font,
                                                    _BWChartStatistics[ i ].useRelSize,
                                                    _BWChartStatistics[ i ].relSize );
                                        } else if( tagName == "Color" ) {
                                            TQColor color;
                                            if( KDXML::readColorNode( element, color ) )
                                                _BWChartStatistics[ i ].color = color;
                                        } else if( tagName == "Brush" ) {
                                            TQBrush brush;
                                            if( KDXML::readBrushNode( element, brush ) )
                                                _BWChartStatistics[ i ].brush = brush;
                                        } else {
                                            tqDebug( "Unknown subelement of BoxAndWhiskerSettings found: %s", tagName.latin1() );
                                        }
                                    }
                                }
                            } else {
                                tqDebug( "Unknown subelement of BoxAndWhiskerSettings found: %s", tagName.latin1() );
                            }
                        } else {
                            tqDebug( "Unknown subelement of BoxAndWhiskerSettings found: %s", tagName.latin1() );
                        }
                    }
                    node = node.nextSibling();
                }
            } else if( tagName == "PolarSettings" ) {
                TQDomNode node = element.firstChild();
                while( !node.isNull() ) {
                    TQDomElement element = node.toElement();
                    if( !element.isNull() ) { // was really an element
                        TQString tagName = element.tagName();
                        if( tagName == "SubType" ) {
                            TQString value;
                            if( KDXML::readStringNode( element, value ) )
                                _polarChartSubType = KDChartParams::stringToPolarChartSubType( value );
                        } else if( tagName == "Marker" ) {
                            bool marker;
                            if( KDXML::readBoolNode( element, marker ) )
                                _polarMarker = marker;
                        } else if( tagName == "MarkerStyle" ) {
                            bool ok = true;
                            uint dataset;
                            KDChartParams::PolarMarkerStyle style = PolarMarkerCircle;
                            if( element.hasAttribute( "Dataset" ) &&
                                    element.hasAttribute( "Style" ) ) {
                                dataset = element.attribute( "Dataset" ).toUInt( &ok );
                                if( ok )
                                    style = KDChartParams::stringToPolarMarkerStyle( element.attribute( "Style" ) );
                            } else
                                ok = false;
                            if( ok )
                                _polarMarkerStyles[dataset] = style;
                        } else if( tagName == "MarkerSize" ) {
                            int width = 1;
                            int height= 1;
                            bool ok = true;
                            if( element.hasAttribute( "Width" ) &&
                                    element.hasAttribute( "Height" ) ) {
                                width = element.attribute( "Width" ).toInt( &ok );
                                if( ok )
                                    height = element.attribute( "Height" ).toInt( &ok );
                            } else
                                ok = false;
 
                            if( ok ) {
                                _polarMarkerSize.setWidth( width );
                                _polarMarkerSize.setHeight( height );
                            }
                        } else if( tagName == "PolarLineWidth" ) {
                            int polarLineWidth;
                            if( KDXML::readIntNode( element, polarLineWidth ) )
                                _polarLineWidth = polarLineWidth;
                        } else {
                            tqDebug( "Unknown subelement of PolarSettings found: %s", tagName.latin1() );
                        }
                    }
                    node = node.nextSibling();
                }
            } else if( tagName == "LegendSettings" ) {
                TQDomNode node = element.firstChild();
                while( !node.isNull() ) {
                    TQDomElement element = node.toElement();
                    if( !element.isNull() ) { // was really an element
                        TQString tagName = element.tagName();
                        if( tagName == "Position" ) {
                            TQString string;
                            if( KDXML::readStringNode( element, string ) )
                                _legendPosition = KDChartParams::stringToLegendPosition( string );
                        } else if( tagName == "Orientation" ) {
                            TQt::Orientation value=TQt::Vertical;
                            if( KDXML::readOrientationNode( element, value ) )
                                _legendOrientation = value;
                        } else if( tagName == "ShowLines" ) {
                            bool showLines;
                            if( KDXML::readBoolNode( element, showLines ) )
                                _legendShowLines = showLines;
                        } else if( tagName == "Source" ) {
                            TQString string;
                            if( KDXML::readStringNode( element, string ) )
                                _legendSource = KDChartParams::stringToLegendSource( string );
                        } else if( tagName == "LegendText" ) {
                            bool ok = true;
                            uint dataset = 0;
                            TQString text;
                            if( element.hasAttribute( "Dataset" ) &&
                                    element.hasAttribute( "Text" ) ) {
                                dataset = element.attribute( "Dataset" ).toUInt( &ok );
                                if( ok )
                                    text = element.attribute( "Text" );
                            } else
                                ok = false;
                            if( ok )
                                _legendText[dataset] = text;
                        } else if( tagName == "TextColor" ) {
                            TQColor color;
                            if( KDXML::readColorNode( element, color ) )
                                _legendTextColor = color;
                        } else if( tagName == "TextFont" ) {
                            readChartFontNode( element,
                                    _legendFont,
                                    _legendFontUseRelSize,
                                    _legendFontRelSize );
                        } else if( tagName == "TitleText" ) {
                            TQString string;
                            if( KDXML::readStringNode( element, string ) )
                                _legendTitleText = string;
                        } else if( tagName == "TitleColor" ) {
                            TQColor color;
                            if( KDXML::readColorNode( element, color ) )
                                _legendTitleTextColor = color;
                        } else if( tagName == "TitleFont" ) {
                            readChartFontNode( element,
                                    _legendTitleFont,
                                    _legendTitleFontUseRelSize,
                                    _legendTitleFontRelSize );
                        } else if( tagName == "Spacing" ) {
                            int spacing;
                            if( KDXML::readIntNode( element, spacing ) )
                                _legendSpacing = spacing;
                        } else {
                            tqDebug( "Unknown subelement of LegendSettings found: %s", tagName.latin1() );
                        }
                    }
                    node = node.nextSibling();
                }
            } else if( tagName == "AxisSettings" ) {
 
                loadAxesFormXML(curAxisSettings, element);
 
            } else if( tagName == "HeaderFooterSettings" ) {
                KDChartParams::HdFtParams* hfSettings =
                    &( _hdFtParams[ curHFSettings ] );
                TQDomNode node = element.firstChild();
                while( !node.isNull() ) {
                    TQDomElement element = node.toElement();
                    if( !element.isNull() ) { // was really an element
                        TQString tagName = element.tagName();
                        if( tagName == "Text" ) {
                            TQString string;
                            if( KDXML::readStringNode( element, string ) )
                                hfSettings->_text = string;
                        } else if( tagName == "Font" ) {
                            readChartFontNode( element,
                                    hfSettings->_font,
                                    hfSettings->_fontUseRelSize,
                                    hfSettings->_fontRelSize );
                        } else if( tagName == "Color" ) {
                            TQColor color;
                            if( KDXML::readColorNode( element, color ) )
                                hfSettings->_color = color;
                        } else {
                            tqDebug( "Unknown subelement of HeaderFooterSettings found: %s", tagName.latin1() );
                        }
                    }
                    node = node.nextSibling();
                }
                curHFSettings++; // one header/footer setting finished
            } else if( tagName == "GlobalLeading" ) {
                TQDomNode node = element.firstChild();
                while( !node.isNull() ) {
                    TQDomElement element = node.toElement();
                    if( !element.isNull() ) { // was really an elemente
                        TQString tagName = element.tagName();
                        if( tagName == "Left" ) {
                            int value;
                            if( KDXML::readIntNode( element, value ) )
                                _globalLeadingLeft = value;
                        }
                        else if( tagName == "Top" ) {
                            int value;
                            if( KDXML::readIntNode( element, value ) )
                                _globalLeadingTop = value;
                        }
                        else if( tagName == "Right" ) {
                            int value;
                            if( KDXML::readIntNode( element, value ) )
                                _globalLeadingRight = value;
                        }
                        else if( tagName == "Bottom" ) {
                            int value;
                            if( KDXML::readIntNode( element, value ) )
                                _globalLeadingBottom = value;
                        } else {
                            tqDebug( "Unknown subelement of GlobalLeading found: %s", tagName.latin1() );
                        }
                    }
                    node = node.nextSibling();
                }
            } else if( tagName == "DataValuesSettings1" ) {
                TQDomNode node = element.firstChild();
                while( !node.isNull() ) {
                    TQDomElement element = node.toElement();
                    if( !element.isNull() ) { // was really an element
                        TQString tagName = element.tagName();
                        if( tagName == "PrintDataValues" ) {
                            bool value;
                            if( KDXML::readBoolNode( element, value ) )
                                _printDataValuesSettings._printDataValues = value;
                        } else if( tagName == "DivPow10" ) {
                            int value;
                            if( KDXML::readIntNode( element, value ) )
                                _printDataValuesSettings._divPow10 = value;
                        } else if( tagName == "DigitsBehindComma" ) {
                            int value;
                            if( KDXML::readIntNode( element, value ) )
                                _printDataValuesSettings._digitsBehindComma = value;
                        } else if( tagName == "Font" ) {
                            readChartFontNode( element,
                                    _printDataValuesSettings._dataValuesFont,
                                    _printDataValuesSettings._dataValuesUseFontRelSize,
                                    _printDataValuesSettings._dataValuesFontRelSize );
                        } else if( tagName == "Color" ) {
                            KDXML::readColorNode( element, _printDataValuesSettings._dataValuesColor );
                        } else if( tagName == "Background" ) {
                            KDXML::readBrushNode( element, _printDataValuesSettings._dataValuesBrush );
                        } else if( tagName == "AutoColor" ) {
                            KDXML::readBoolNode( element,
                                    _printDataValuesSettings._dataValuesAutoColor );
                        } else if( tagName == "AnchorNegativePosition" ) {
                            TQString value;
                            if( KDXML::readStringNode( element, value ) )
                                _printDataValuesSettings._dataValuesAnchorNegativePosition = KDChartEnums::stringToPositionFlag( value );
                        } else if( tagName == "AnchorNegativeAlign" ) {
                            int value;
                            if( KDXML::readIntNode( element, value ) )
                                _printDataValuesSettings._dataValuesAnchorNegativeAlign = value;
                        } else if( tagName == "AnchorNegativeDeltaX" ) {
                            int value;
                            if( KDXML::readIntNode( element, value ) )
                                _printDataValuesSettings._dataValuesAnchorNegativeDeltaX = value;
                        } else if( tagName == "AnchorNegativeDeltaY" ) {
                            int value;
                            if( KDXML::readIntNode( element, value ) )
                                _printDataValuesSettings._dataValuesAnchorNegativeDeltaY = value;
                        } else if( tagName == "NegativeRotation" ) {
                            int value;
                            if( KDXML::readIntNode( element, value ) )
                                _printDataValuesSettings._dataValuesNegativeRotation = value;
                        } else if( tagName == "AnchorPositivePosition" ) {
                            TQString value;
                            if( KDXML::readStringNode( element, value ) )
                                _printDataValuesSettings._dataValuesAnchorPositivePosition = KDChartEnums::stringToPositionFlag( value );
                        } else if( tagName == "AnchorPositiveAlign" ) {
                            int value;
                            if( KDXML::readIntNode( element, value ) )
                                _printDataValuesSettings._dataValuesAnchorPositiveAlign = value;
                        } else if( tagName == "AnchorPositiveDeltaX" ) {
                            int value;
                            if( KDXML::readIntNode( element, value ) )
                                _printDataValuesSettings._dataValuesAnchorPositiveDeltaX = value;
                        } else if( tagName == "AnchorPositiveDeltaY" ) {
                            int value;
                            if( KDXML::readIntNode( element, value ) )
                                _printDataValuesSettings._dataValuesAnchorPositiveDeltaY = value;
                        } else if( tagName == "PositiveRotation" ) {
                            int value;
                            if( KDXML::readIntNode( element, value ) )
                                _printDataValuesSettings._dataValuesPositiveRotation = value;
                        } else if( tagName == "LayoutPolicy" ) {
                            TQString value;
                            if( KDXML::readStringNode( element, value ) )
                                _printDataValuesSettings._dataValuesLayoutPolicy = KDChartEnums::stringToLayoutPolicy( value );
                        } else if( tagName == "ShowInfinite" ) {
                            KDXML::readBoolNode( element, _printDataValuesSettings._dataValuesShowInfinite );
                        } else {
                            tqDebug( "Unknown subelement of DataValuesSettings1 found: %s", tagName.latin1() );
                        }
                    }
                    node = node.nextSibling();
                }
            } else if( tagName == "DataValuesSettings2" ) {
                TQDomNode node = element.firstChild();
                while( !node.isNull() ) {
                    TQDomElement element = node.toElement();
                    if( !element.isNull() ) { // was really an element
                        TQString tagName = element.tagName();
                        if( tagName == "PrintDataValues" ) {
                            bool value;
                            if( KDXML::readBoolNode( element, value ) )
                                _printDataValuesSettings2._printDataValues = value;
                        } else if( tagName == "DivPow10" ) {
                            int value;
                            if( KDXML::readIntNode( element, value ) )
                                _printDataValuesSettings2._divPow10 = value;
                        } else if( tagName == "DigitsBehindComma" ) {
                            int value;
                            if( KDXML::readIntNode( element, value ) )
                                _printDataValuesSettings2._digitsBehindComma = value;
                        } else if( tagName == "Font" ) {
                            readChartFontNode( element,
                                    _printDataValuesSettings2._dataValuesFont,
                                    _printDataValuesSettings2._dataValuesUseFontRelSize,
                                    _printDataValuesSettings2._dataValuesFontRelSize );
                        } else if( tagName == "Color" ) {
                            KDXML::readColorNode( element, _printDataValuesSettings2._dataValuesColor );
                        } else if( tagName == "Background" ) {
                            KDXML::readBrushNode( element, _printDataValuesSettings2._dataValuesBrush );
                        } else if( tagName == "AutoColor" ) {
                            KDXML::readBoolNode( element,
                                    _printDataValuesSettings2._dataValuesAutoColor );
                        } else if( tagName == "AnchorNegativePosition" ) {
                            TQString value;
                            if( KDXML::readStringNode( element, value ) )
                                _printDataValuesSettings2._dataValuesAnchorNegativePosition = KDChartEnums::stringToPositionFlag( value );
                        } else if( tagName == "AnchorNegativeAlign" ) {
                            int value;
                            if( KDXML::readIntNode( element, value ) )
                                _printDataValuesSettings2._dataValuesAnchorNegativeAlign = value;
                        } else if( tagName == "AnchorNegativeDeltaX" ) {
                            int value;
                            if( KDXML::readIntNode( element, value ) )
                                _printDataValuesSettings2._dataValuesAnchorNegativeDeltaX = value;
                        } else if( tagName == "AnchorNegativeDeltaY" ) {
                            int value;
                            if( KDXML::readIntNode( element, value ) )
                                _printDataValuesSettings2._dataValuesAnchorNegativeDeltaY = value;
                        } else if( tagName == "NegativeRotation" ) {
                            int value;
                            if( KDXML::readIntNode( element, value ) )
                                _printDataValuesSettings2._dataValuesNegativeRotation = value;
                        } else if( tagName == "AnchorPositivePosition" ) {
                            TQString value;
                            if( KDXML::readStringNode( element, value ) )
                                _printDataValuesSettings2._dataValuesAnchorPositivePosition = KDChartEnums::stringToPositionFlag( value );
                        } else if( tagName == "AnchorPositiveAlign" ) {
                            int value;
                            if( KDXML::readIntNode( element, value ) )
                                _printDataValuesSettings2._dataValuesAnchorPositiveAlign = value;
                        } else if( tagName == "AnchorPositiveDeltaX" ) {
                            int value;
                            if( KDXML::readIntNode( element, value ) )
                                _printDataValuesSettings2._dataValuesAnchorPositiveDeltaX = value;
                        } else if( tagName == "AnchorPositiveDeltaY" ) {
                            int value;
                            if( KDXML::readIntNode( element, value ) )
                                _printDataValuesSettings2._dataValuesAnchorPositiveDeltaY = value;
                        } else if( tagName == "PositiveRotation" ) {
                            int value;
                            if( KDXML::readIntNode( element, value ) )
                                _printDataValuesSettings2._dataValuesPositiveRotation = value;
                        } else if( tagName == "LayoutPolicy" ) {
                            TQString value;
                            if( KDXML::readStringNode( element, value ) )
                                _printDataValuesSettings2._dataValuesLayoutPolicy = KDChartEnums::stringToLayoutPolicy( value );
                        } else if( tagName == "ShowInfinite" ) {
                            KDXML::readBoolNode( element, _printDataValuesSettings2._dataValuesShowInfinite );
                        } else {
                            tqDebug( "Unknown subelement of DataValuesSettings2 found: %s", tagName.latin1() );
                        }
                    }
                    node = node.nextSibling();
                }
            } else if( tagName == "DataValuesGlobalSettings" ) {
                TQDomNode node = element.firstChild();
                while( !node.isNull() ) {
                    TQDomElement element = node.toElement();
                    if( !element.isNull() ) { // was really an element
                        TQString tagName = element.tagName();
                        if( tagName == "allowOverlappingTexts" ) {
                            bool value;
                            if( KDXML::readBoolNode( element, value ) )
                                _allowOverlappingDataValueTexts = value;
                        }
                        else
                            tqDebug( "Unknown subelement of DataValuesGlobalSettings found: %s", tagName.latin1() );
                        // do _not_ return false here (to enable future extentions)
                    }
                    node = node.nextSibling();
                }
            } else if( tagName == "AreaMap" ) {
                TQDomNode node = element.firstChild();
                while( !node.isNull() ) {
                    TQDomElement element = node.toElement();
                    if( !element.isNull() ) { // was really an element
                        TQString tagName = element.tagName();
                        if( tagName == "FrameSettings" ) {
                            KDChartFrameSettings* frameSettings = new KDChartFrameSettings;
                            uint areaId = KDChartEnums::AreaUNKNOWN;
                            if( KDChartFrameSettings::readFrameSettingsNode(
                                        element, *frameSettings, areaId ) ) {
                                TQString str;
                                if(areaId == KDChartEnums::AreaChartDataRegion)
                                    str = TQString( "%1/%2/%3/%4" )
                                              .arg( areaId, 5 )
                                              .arg( frameSettings->dataRow(), 5 )
                                              .arg( frameSettings->dataCol(), 5 )
                                              .arg( 0, 5 );//frameSettings->data3rd(), 5 );
                                else
                                    str = TQString( "%1/-----/-----/-----" ).arg( areaId, 5 );
                                _areaDict.replace( str, frameSettings );
                            }
                        }
                        else
                            tqDebug( "Unknown tag in AreaMap found: %s", tagName.latin1() );
                        // do _not_ return false here (to enable future extentions)
                    }
                    node = node.nextSibling();
                }
            } else if( tagName == "CustomBoxMap" ) {
                TQDomNode node = element.firstChild();
                int curNumber = -1;
                while( !node.isNull() ) {
                    TQDomElement element = node.toElement();
                    if( !element.isNull() ) { // was really an element
                        TQString tagName = element.tagName();
                        if( tagName == "Number" ) {
                            KDXML::readIntNode( element, curNumber );
                        } else if( tagName == "CustomBox" ) {
                            Q_ASSERT( curNumber != -1 ); // there was a Dataset tag before
                            KDChartCustomBox customBox;
                            KDChartCustomBox::readCustomBoxNode( element,
                                    customBox );
                            _customBoxDict.insert( curNumber, customBox.clone() );
                        }
                        else
                            tqDebug( "Unknown tag in CustomBoxMap found: %s", tagName.latin1() );
                    }
                    node = node.nextSibling();
                }
            } else {
                tqDebug( "Unknown second-level element found: %s", tagName.latin1() );
                // NOTE: We do *not* 'return false' here but continue normal operation
                //       since additional elements might have been added in future versions
            }
        }
        node = node.nextSibling();
    }
    return true;
}
 
 
void KDChartParams::createColorMapNode( TQDomDocument& doc, TQDomNode& parent,
        const TQString& elementName,
        const TQMap< uint, TQColor >& map )
{
    TQDomElement mapElement =
        doc.createElement( elementName );
    parent.appendChild( mapElement );
    for( TQMap<uint,TQColor>::ConstIterator it = map.begin();
            it != map.end(); ++it ) {
        // Dataset element
        TQDomElement datasetElement = doc.createElement( "Dataset" );
        mapElement.appendChild( datasetElement );
        TQDomText datasetContent =
            doc.createTextNode( TQString::number( it.key() ) );
        datasetElement.appendChild( datasetContent );
        // Color element
        KDXML::createColorNode( doc, mapElement, "Color", it.data() );
    }
}
 
 
void KDChartParams::createDoubleMapNode( TQDomDocument& doc, TQDomNode& parent,
        const TQString& elementName,
        const TQMap< int, double >& map )
{
    TQDomElement mapElement =
        doc.createElement( elementName );
    parent.appendChild( mapElement );
    for( TQMap<int,double>::ConstIterator it = map.begin();
            it != map.end(); ++it ) {
        // Dataset element
        TQDomElement valueElement = doc.createElement( "Value" );
        mapElement.appendChild( valueElement );
        TQDomText valueContent =
            doc.createTextNode( TQString::number( it.key() ) );
        valueElement.appendChild( valueContent );
        // Color element
        KDXML::createDoubleNode( doc, mapElement, "Factor", it.data() );
    }
}
 
 
void dataCoordToElementAttr(const TQVariant& val, TQDomElement& element, const TQString& postfix)
{
    if( TQVariant::Double == val.type() )
        element.setAttribute( "DoubleValue"+postfix,
                              TQString::number( val.toDouble() ) );
    else if( TQVariant::String == val.type() )
        element.setAttribute( "StringValue"+postfix, val.toString() );
    else if( TQVariant::DateTime == val.type() )
        element.setAttribute( "DateTimeValue"+postfix,
                              val.toDateTime().toString( TQt::ISODate ) );
    else
        element.setAttribute( "NoValue"+postfix, "true" );
}
 
void KDChartParams::createChartValueNode( TQDomDocument& doc, TQDomNode& parent,
        const TQString& elementName,
        const TQVariant& valY,
        const TQVariant& valX,
        const int& propID )
{
    TQDomElement element = doc.createElement( elementName );
    parent.appendChild( element );
    dataCoordToElementAttr( valY, element, "" ); // no postfix for Y value: backwards compat.
    dataCoordToElementAttr( valX, element, "X" );
    element.setAttribute( "PropertySetID",
                          TQString::number( propID ) );
}
 
 
 
void KDChartParams::createChartFontNode( TQDomDocument& doc, TQDomNode& parent,
        const TQString& elementName,
        const TQFont& font, bool useRelFont,
        int relFont,
        int minFont )
{
    TQDomElement chartFontElement = doc.createElement( elementName );
    parent.appendChild( chartFontElement );
    KDXML::createFontNode( doc, chartFontElement, "Font", font );
    KDXML::createBoolNode( doc, chartFontElement, "UseRelFontSize",
            useRelFont );
    KDXML::createIntNode( doc, chartFontElement, "RelFontSize", relFont );
    if( 0 <= minFont )
        KDXML::createIntNode( doc, chartFontElement, "MinFontSize", minFont );
}
 
 
 
 
 
bool KDChartParams::readColorMapNode( const TQDomElement& element,
        TQMap<uint,TQColor>* value )
{
    TQDomNode node = element.firstChild();
    int curDataset = -1;
    while( !node.isNull() ) {
        TQDomElement element = node.toElement();
        if( !element.isNull() ) { // was really an element
            TQString tagName = element.tagName();
            if( tagName == "Dataset" ) {
                KDXML::readIntNode( element, curDataset );
            } else if( tagName == "Color" ) {
                Q_ASSERT( curDataset != -1 ); // there was a Dataset tag before
                TQColor color;
                KDXML::readColorNode( element, color );
                value->insert( curDataset, color );
            } else {
                tqDebug( "Unknown tag in color map" );
            }
        }
        node = node.nextSibling();
    }
 
    return true;
}
 
 
bool KDChartParams::readDoubleMapNode( const TQDomElement& element,
        TQMap<int,double>* value )
{
    TQDomNode node = element.firstChild();
    int curValue = -1;
    while( !node.isNull() ) {
        TQDomElement element = node.toElement();
        if( !element.isNull() ) { // was really an element
            TQString tagName = element.tagName();
            if( tagName == "Value" ) {
                KDXML::readIntNode( element, curValue );
            } else if( tagName == "Factor" ) {
                Q_ASSERT( curValue != -1 ); // there was a Value tag before
                double doubleValue;
                KDXML::readDoubleNode( element, doubleValue );
                value->insert( curValue, doubleValue );
            } else {
                tqDebug( "Unknown tag in double map" );
            }
        }
        node = node.nextSibling();
    }
 
    return true;
}
 
 
 
bool KDChartParams::readChartFontNode( const TQDomElement& element,
        TQFont& font,
        bool& useRelFont,
        int& relFontSize,
        int* minFontSize )
{
    bool ok = true;
    TQFont tempFont;
    bool tempRelFont;
    int tempRelFontSize;
    int tempMinFontSize=-1;
    TQDomNode node = element.firstChild();
    while( !node.isNull() ) {
        TQDomElement element = node.toElement();
        if( !element.isNull() ) { // was really an element
            TQString tagName = element.tagName();
            if( tagName == "Font" ) {
                ok = ok & KDXML::readFontNode( element, tempFont );
            } else if( tagName == "UseRelFontSize" ) {
                ok = ok & KDXML::readBoolNode( element, tempRelFont );
            } else if( tagName == "RelFontSize" ) {
                ok = ok & KDXML::readIntNode( element, tempRelFontSize );
            } else if( tagName == "MinFontSize" ) {
                ok = ok & KDXML::readIntNode( element, tempMinFontSize );
            } else {
                tqDebug( "Unknown tag in color map" );
            }
        }
        node = node.nextSibling();
    }
 
    if( ok ) {
        font = tempFont;
        useRelFont = tempRelFont;
        relFontSize = tempRelFontSize;
        if( minFontSize && 0 <= tempMinFontSize )
            *minFontSize = tempMinFontSize;
    }
 
    return ok;
}
 
 
bool foundCoordAttribute( const TQDomElement& element, const TQString& postfix,
                          TQVariant& val )
{
    if( element.hasAttribute( "NoValue"+postfix ) )
        val = TQVariant();
    else if( element.hasAttribute( "DoubleValue"+postfix ) )
        val = element.attribute(   "DoubleValue"+postfix );
    else if( element.hasAttribute( "DateTimeValue"+postfix ) )
        val = element.attribute(   "DateTimeValue"+postfix );
    else if( element.hasAttribute( "StringValue"+postfix ) )
        val = element.attribute(   "StringValue"+postfix );
    else
        return false;
 
    return true;
}
 
// PENDING(kalle) Support DateTime values, even when writing.
bool KDChartParams::readChartValueNode( const TQDomElement& element,
        TQVariant& valY,
        TQVariant& valX,
        int& propID )
{
    if( foundCoordAttribute( element, "",  valY ) ||
        foundCoordAttribute( element, "Y", valY ) ){  // valY must be there
        if( !foundCoordAttribute( element, "X", valX ) ){
            valX = TQVariant();
        }
        propID = 0;
        if( element.hasAttribute( "PropertySetID" ) ) {
            bool ok;
            int i = element.attribute( "PropertySetID" ).toInt( &ok );
            if( ok )
                propID = i;
        }
        return true;  // if Y value found everything is OK
    }
 
    return false;
}
 
 
TQString KDChartParams::chartTypeToString( ChartType type )
{
    switch( type ) {
        case NoType:
            return "NoType";
        case Bar:
            return "Bar";
        case Line:
            return "Line";
        case Area:
            return "Area";
        case Pie:
            return "Pie";
        case HiLo:
            return "HiLo";
        case BoxWhisker:
            return "BoxWhisker";
        case Ring:
            return "Ring";
        case Polar:
            return "Polar";
        default: // should not happen
            return "NoType";
    }
}
 
 
KDChartParams::ChartType KDChartParams::stringToChartType( const TQString& string )
{
    if( string == "NoType" )
        return NoType;
    else if( string == "Bar" )
        return Bar;
    else if( string == "Line" )
        return Line;
    else if( string == "Area" )
        return Area;
    else if( string == "Pie" )
        return Pie;
    else if( string == "HiLo" )
        return HiLo;
    else if( string == "BoxWhisker" )
        return BoxWhisker;
    else if( string == "Ring" )
        return Ring;
    else if( string == "Polar" )
        return Polar;
    else // default, should not happen
        return NoType;
}
 
 
 
TQString KDChartParams::markerStyleToString( int style )
{
    switch( style ) {
        case LineMarkerSquare:
            return "Square";
        case LineMarkerDiamond:
            return "Diamond";
        case LineMarkerCircle:
            return "Circle";
        case LineMarker1Pixel:
            return "one Pixel";
        case LineMarker4Pixels:
            return "four Pixels";
        case LineMarkerRing:
            return "Ring";
        case LineMarkerCross:
            return "Cross";
        case LineMarkerFastCross:
            return "fast Cross";
        default: // should not happen
            tqDebug( "Unknown marker style" );
            return "Circle";
    }
}
TQString KDChartParams::markerStyleToStringTr( int style )
{
    switch( style ) {
        case LineMarkerSquare:
            return tr( "Square" );
        case LineMarkerDiamond:
            return tr( "Diamond" );
        case LineMarkerCircle:
            return tr( "Circle" );
        case LineMarker1Pixel:
            return tr( "One pixel" );
        case LineMarker4Pixels:
            return tr( "Four pixels" );
        case LineMarkerRing:
            return tr( "Ring" );
        case LineMarkerCross:
            return tr( "Cross" );
        case LineMarkerFastCross:
            return tr( "fast Cross" );
        default: // should not happen
            tqDebug( "Unknown line marker style!" );
            return tr( "Circle" );
    }
}
int KDChartParams::stringToMarkerStyle( const TQString& string )
{
    if( string == "Square" )
        return LineMarkerSquare;
    else if( string == "Diamond" )
        return LineMarkerDiamond;
    else if( string == "Circle" )
        return LineMarkerCircle;
    else if( string == "one Pixel" )
        return LineMarker1Pixel;
    else if( string == "four Pixels" )
        return LineMarker4Pixels;
    else if( string == "Ring" )
        return LineMarkerRing;
    else if( string == "Cross" )
        return LineMarkerCross;
    else if( string == "fast Cross" )
        return LineMarkerFastCross;
    else // default, should not happen
        return LineMarkerCircle;
}
int KDChartParams::stringToMarkerStyleTr( const TQString& string )
{
    if( string == tr( "Square" ) )
        return LineMarkerSquare;
    else if( string == tr( "Diamond" ) )
        return LineMarkerDiamond;
    else if( string == tr( "Circle" ) )
        return LineMarkerCircle;
    else if( string == tr( "One pixel" ) )
        return LineMarker1Pixel;
    else if( string == tr( "Four pixels" ) )
        return LineMarker4Pixels;
    else if( string == tr( "Ring" ) )
        return LineMarkerRing;
    else if( string == tr( "Cross" ) )
        return LineMarkerCross;
    else if( string == tr( "fast Cross" ) )
        return LineMarkerFastCross;
    else // default, should not happen
        return LineMarkerCircle;
}
 
 
 
TQString KDChartParams::barChartSubTypeToString( BarChartSubType type ) {
    switch( type ) {
        case BarNormal:
            return "BarNormal";
        case BarStacked:
            return "BarStacked";
        case BarPercent:
            return "BarPercent";
        case BarMultiRows:
            return "BarMultiRows";
        default: // should not happen
            tqDebug( "Unknown bar type" );
            return "BarNormal";
    }
}
 
 
KDChartParams::BarChartSubType KDChartParams::stringToBarChartSubType( const TQString& string ) {
    if( string == "BarNormal" )
        return BarNormal;
    else if( string == "BarStacked" )
        return BarStacked;
    else if( string == "BarPercent" )
        return BarPercent;
    else if( string == "BarMultiRows" )
        return BarMultiRows;
    else // should not happen
        return BarNormal;
}
 
 
 
KDChartParams::LineChartSubType KDChartParams::stringToLineChartSubType( const TQString& string ) {
    if( string == "LineNormal" )
        return LineNormal;
    else if( string == "LineStacked" )
        return LineStacked;
    else if( string == "LinePercent" )
        return LinePercent;
    else // should not happen
        return LineNormal;
}
 
 
 
TQString KDChartParams::lineChartSubTypeToString( LineChartSubType type ) {
    switch( type ) {
        case LineNormal:
            return "LineNormal";
        case LineStacked:
            return "LineStacked";
        case LinePercent:
            return "LinePercent";
        default: // should not happen
            tqDebug( "Unknown bar type" );
            return "LineNormal";
    }
}
 
 
TQString KDChartParams::lineMarkerStyleToString( LineMarkerStyle style )
{
    return markerStyleToString( style );
}
 
 
TQString KDChartParams::lineMarkerStyleToStringTr( LineMarkerStyle style )
{
    return markerStyleToStringTr( style );
}
 
 
KDChartParams::LineMarkerStyle KDChartParams::stringToLineMarkerStyle( const TQString& string )
{
    return static_cast<KDChartParams::LineMarkerStyle>(stringToMarkerStyle( string ));
}
 
KDChartParams::LineMarkerStyle KDChartParams::stringToLineMarkerStyleTr( const TQString& string )
{
    return static_cast<KDChartParams::LineMarkerStyle>(stringToMarkerStyleTr( string ));
}
 
 
TQString KDChartParams::areaChartSubTypeToString( AreaChartSubType type ) {
    switch( type ) {
        case AreaNormal:
            return "AreaNormal";
        case AreaStacked:
            return "AreaStacked";
        case AreaPercent:
            return "AreaPercent";
        default: // should not happen
            tqDebug( "Unknown area chart subtype" );
            return "AreaNormal";
    }
}
 
 
KDChartParams::AreaChartSubType KDChartParams::stringToAreaChartSubType( const TQString& string ) {
    if( string == "AreaNormal" )
        return AreaNormal;
    else if( string == "AreaStacked" )
        return AreaStacked;
    else if( string == "AreaPercent" )
        return AreaPercent;
    else // should not happen
        return AreaNormal;
}
 
 
TQString KDChartParams::areaLocationToString( AreaLocation type ) {
    switch( type ) {
        case AreaAbove:
            return "Above";
        case AreaBelow:
            return "Below";
        default: // should not happen
            tqDebug( "Unknown area location" );
            return "Below";
    }
}
 
 
KDChartParams::AreaLocation KDChartParams::stringToAreaLocation( const TQString& string ) {
    if( string == "Above" )
        return AreaAbove;
    else if( string == "Below" )
        return AreaBelow;
    else // default, should not happen
        return AreaBelow;
}
 
 
KDChartParams::PolarChartSubType KDChartParams::stringToPolarChartSubType( const TQString& string ) {
    if( string == "PolarNormal" )
        return PolarNormal;
    else if( string == "PolarStacked" )
        return PolarStacked;
    else if( string == "PolarPercent" )
        return PolarPercent;
    else // should not happen
        return PolarNormal;
}
 
 
TQString KDChartParams::polarChartSubTypeToString( PolarChartSubType type ) {
    switch( type ) {
        case PolarNormal:
            return "PolarNormal";
        case LineStacked:
            return "PolarStacked";
        case LinePercent:
            return "PolarPercent";
        default: // should not happen
            tqDebug( "Unknown polar type" );
            return "PolarNormal";
    }
}
 
 
TQString KDChartParams::polarMarkerStyleToString( PolarMarkerStyle style )
{
    return markerStyleToString( style );
}
 
 
TQString KDChartParams::polarMarkerStyleToStringTr( PolarMarkerStyle style )
{
    return markerStyleToStringTr( style );
}
 
 
KDChartParams::PolarMarkerStyle KDChartParams::stringToPolarMarkerStyle( const TQString& string )
{
    return static_cast<KDChartParams::PolarMarkerStyle>(stringToMarkerStyle( string ));
}
 
 
KDChartParams::PolarMarkerStyle KDChartParams::stringToPolarMarkerStyleTr( const TQString& string )
{
    return static_cast<KDChartParams::PolarMarkerStyle>(stringToMarkerStyle( string ));
}
 
 
TQString KDChartParams::hiLoChartSubTypeToString( HiLoChartSubType type ) {
    switch( type ) {
        case HiLoSimple:
            return "HiLoSimple";
        case HiLoClose:
            return "HiLoClose";
        case HiLoOpenClose:
            return "HiLoOpenClose";
        default: // should not happen
            tqDebug( "Unknown HiLo chart subtype" );
            return "HiLoNormal";
    }
}
 
 
KDChartParams::HiLoChartSubType KDChartParams::stringToHiLoChartSubType( const TQString& string ) {
    if( string == "HiLoSimple" )
        return HiLoSimple;
    else if( string == "HiLoClose" )
        return HiLoClose;
    else if( string == "HiLoOpenClose" )
        return HiLoOpenClose;
    else // should not happen
        return HiLoNormal;
}
 
 
KDChartParams::BWChartSubType KDChartParams::stringToBWChartSubType( const TQString& string ) {
    if( string == "BWSimple" )
        return BWSimple;
    else // should not happen
        return BWNormal;
}
 
TQString KDChartParams::bWChartStatValToString( BWStatVal type ) {
    switch( type ) {
        case        UpperOuterFence:
            return "UpperOuterFence";
        case        UpperInnerFence:
            return "UpperInnerFence";
        case        Quartile3:
            return "Quartile3";
        case        Median:
            return "Median";
        case        Quartile1:
            return "Quartile1";
        case        LowerInnerFence:
            return "LowerInnerFence";
        case        LowerOuterFence:
            return "LowerOuterFence";
        case        MaxValue:
            return "MaxValue";
        case        MeanValue:
            return "MeanValue";
        case        MinValue:
            return "MinValue";
        default: // should not happen
            tqDebug( "Unknown BoxWhisker statistical value type" );
            return "unknown";
    }
}
 
KDChartParams::BWStatVal KDChartParams::stringToBWChartStatVal( const TQString& string ) {
    if(      string == "UpperOuterFence" )
        return     UpperOuterFence;
    else if( string == "UpperInnerFence" )
        return     UpperInnerFence;
    else if( string == "Quartile3" )
        return     Quartile3;
    else if( string == "Median" )
        return     Median;
    else if( string == "Quartile1" )
        return     Quartile1;
    else if( string == "LowerInnerFence" )
        return     LowerInnerFence;
    else if( string == "LowerOuterFence" )
        return     LowerOuterFence;
    else if( string == "MaxValue" )
        return     MaxValue;
    else if( string == "MeanValue" )
        return     MeanValue;
    else if( string == "MinValue" )
        return     MinValue;
    else // should not happen
        return BWStatValUNKNOWN;
}
 
 
TQString KDChartParams::legendPositionToString( LegendPosition pos ) {
    switch( pos ) {
        case NoLegend:
            return "NoLegend";
        case LegendTop:
            return "LegendTop";
        case LegendBottom:
            return "LegendBottom";
        case LegendLeft:
            return "LegendLeft";
        case LegendRight:
            return "LegendRight";
        case LegendTopLeft:
            return "LegendTopLeft";
        case LegendTopLeftTop:
            return "LegendTopLeftTop";
        case LegendTopLeftLeft:
            return "LegendTopLeftLeft";
        case LegendBottomLeft:
            return "LegendBottomLeft";
        case LegendBottomLeftBottom:
            return "LegendBottomLeftBottom";
        case LegendBottomLeftLeft:
            return "LegendBottomLeftLeft";
        case LegendTopRight:
            return "LegendTopRight";
        case LegendTopRightTop:
            return "LegendTopRightTop";
        case LegendTopRightRight:
            return "LegendTopRightRight";
        case LegendBottomRight:
            return "LegendBottomRight";
        case LegendBottomRightBottom:
            return "LegendBottomRightBottom";
        case LegendBottomRightRight:
            return "LegendBottomRightRight";
        default: // should not happen
            tqDebug( "Unknown legend position" );
            return "LegendLeft";
    }
}
 
 
KDChartParams::LegendPosition KDChartParams::stringToLegendPosition( const TQString& string ) {
    if( string == "NoLegend" )
        return NoLegend;
    else if( string == "LegendTop" )
        return LegendTop;
    else if( string == "LegendBottom" )
        return LegendBottom;
    else if( string == "LegendLeft" )
        return LegendLeft;
    else if( string == "LegendRight" )
        return LegendRight;
    else if( string == "LegendTopLeft" )
        return LegendTopLeft;
    else if( string == "LegendTopLeftTop" )
        return LegendTopLeftTop;
    else if( string == "LegendTopLeftLeft" )
        return LegendTopLeftLeft;
    else if( string == "LegendBottomLeft" )
        return LegendBottomLeft;
    else if( string == "LegendBottomLeftBottom" )
        return LegendBottomLeftBottom;
    else if( string == "LegendBottomLeftLeft" )
        return LegendBottomLeftLeft;
    else if( string == "LegendTopRight" )
        return LegendTopRight;
    else if( string == "LegendTopRightTop" )
        return LegendTopRightTop;
    else if( string == "LegendTopRightRight" )
        return LegendTopRightRight;
    else if( string == "LegendBottomRight" )
        return LegendBottomRight;
    else if( string == "LegendBottomRightBottom" )
        return LegendBottomRightBottom;
    else if( string == "LegendBottomRightRight" )
        return LegendBottomRightRight;
    else // default, should not happen
        return LegendLeft;
}
 
TQString KDChartParams::legendSourceToString( LegendSource source ) {
    switch( source ) {
        case LegendManual:
            return "Manual";
        case LegendFirstColumn:
            return "FirstColumn";
        case LegendAutomatic:
            return "Automatic";
        default: // should not happen
            tqDebug( "Unknown legend source" );
            return "Automatic";
    }
}
 
 
KDChartParams::LegendSource KDChartParams::stringToLegendSource( const TQString& string ) {
    if( string == "Manual" )
        return LegendManual;
    else if( string == "FirstColumn" )
        return LegendFirstColumn;
    else if( string == "Automatic" )
        return LegendAutomatic;
    else // default, should not happen
        return LegendAutomatic;
}
 
 
TQString KDChartParams::chartSourceModeToString( const SourceMode& mode )
{
    switch( mode ){
    case UnknownMode:
        return "UnknownMode";
    case DontUse:
        return "DontUse";
    case DataEntry:
        return "DataEntry";
    case AxisLabel:
        return "AxisLabel";
    case LegendText:
        return "LegendText";
    case ExtraLinesAnchor:
        return "ExtraLinesAnchor";
    default: // should not happen
        return "UnknownMode";
    }
}
 
 
KDChartParams::SourceMode KDChartParams::stringToChartSourceMode( const TQString& string )
{
    if( string.isEmpty() )
        return UnknownMode;
    // compatibility with pre-1.0 KDChart stream format:
    bool bOk;
    int mode = string.toInt( &bOk );
    if( bOk && mode >= 0 && mode <= Last_SourceMode )
        return (KDChartParams::SourceMode)mode;
    // new (KDChart 1.0...) stream format:
    if( string == "UnknownMode" )
        return UnknownMode;
    if( string == "DontUse" )
        return DontUse;
    if( string == "DataEntry" )
        return DataEntry;
    if( string == "AxisLabel" )
        return AxisLabel;
    if( string == "LegendText" )
        return LegendText;
    if( string == "ExtraLinesAnchor" )
        return ExtraLinesAnchor;
    // should not happen
    return UnknownMode;
}
 
 
TQString KDChartParams::bWChartSubTypeToString( BWChartSubType type ) {
    switch( type ) {
        case BWSimple:
            return "BWSimple";
        default: // should not happen
            tqDebug( "Unknown BoxWhisker chart subtype" );
            return "BWNormal";
    }
}