Added kmymoney

git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/applications/kmymoney@1239792 283d02a7-25f6-0310-bc7c-ecb5cbfe19da

1 files changed, 3333 insertions, 0 deletions

diff --git a/libkdchart/KDChartParams_io.cpp b/libkdchart/KDChartParams_io.cpp
new file mode 100644
index 0000000..092229e
--- /dev/null
+++ b/libkdchart/KDChartParams_io.cpp
@@ -0,0 +1,3333 @@
+/* -*- Mode: C++ -*-
+   KDChart - a multi-platform charting engine
+   */
+
+/****************************************************************************
+ ** Copyright (C) 2001-2003 Klarälvdalens Datakonsult AB.  All rights reserved.
+ **
+ ** This file is part of the KDChart library.
+ **
+ ** This file may be distributed and/or modified under the terms of the
+ ** GNU General Public License version 2 as published by the Free Software
+ ** Foundation and appearing in the file LICENSE.GPL included in the
+ ** packaging of this file.
+ **
+ ** Licensees holding valid commercial KDChart licenses may use this file in
+ ** accordance with the KDChart Commercial License Agreement provided with
+ ** the Software.
+ **
+ ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
+ ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ **
+ ** See http://www.klaralvdalens-datakonsult.se/?page=products for
+ **   information about KDChart Commercial License Agreements.
+ **
+ ** Contact info@klaralvdalens-datakonsult.se if any conditions of this
+ ** licensing are not clear to you.
+ **
+ **********************************************************************/
+#include "KDChartParams.h"
+#include <KDXMLTools.h>
+
+#include <qintdict.h>
+
+/**
+  \fn QTextStream& operator<<( QTextStream& s, const KDChartParams& p );
+
+  Writes the KDChartParams object p as an XML document to the text stream s.
+
+  \param s the text stream to write to
+  \param p the KDChartParams object to write
+  \return the text stream after the write operation
+  */
+QTextStream& operator<<( QTextStream& s, const KDChartParams& p )
+{
+    QDomDocument document = p.saveXML();
+    s << document.toString();
+
+    return s;
+}
+
+/**
+  Helper method saving the axis parameters to an XML file,
+  this is called by saveXML() only.
+*/
+void KDChartParams::saveAxesToXML(QDomDocument& doc, QDomElement& docRoot) const
+{
+    // the AxisSettings elements
+    for( int axis = 0; axis < 13; axis++ ) {
+        QDomElement 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
+            QDomElement 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 );
+        }
+    }
+}
+
+
+/**
+  Saves the parameters to an XML document.
+
+  \return the XML document that represents the parameters
+  \sa loadXML
+  */
+QDomDocument KDChartParams::saveXML( bool withPI ) const
+{
+    // Create an inital DOM document
+    QString docstart = "<ChartParams/>";
+
+    QDomDocument doc( "ChartParams" );
+    doc.setContent( docstart );
+    if( withPI )
+        doc.appendChild( doc.createProcessingInstruction( "xml", "version=\"1.0\" encoding=\"UTF-8\"" ) );
+
+    QDomElement 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
+    QDomElement 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
+    QDomElement modeAndChartMapElement =
+        doc.createElement( "ModeAndChartMap" );
+    docRoot.appendChild( modeAndChartMapElement );
+    for( QMap<uint,KDChartParams::ModeAndChart>::ConstIterator it = _dataSourceModeAndChart.begin();
+            it != _dataSourceModeAndChart.end(); ++it ) {
+        // Dataset element
+        QDomElement datasetElement = doc.createElement( "Dataset" );
+        QDomText datasetContent =
+            doc.createTextNode( QString::number( it.key() ) );
+        datasetElement.appendChild( datasetContent );
+        modeAndChartMapElement.appendChild( datasetElement );
+        // ModeAndChart element
+        QDomElement modeAndChartElement = doc.createElement( "ModeAndChart" );
+        modeAndChartElement.setAttribute( "Mode", chartSourceModeToString( it.data().mode() ) );
+        modeAndChartElement.setAttribute( "Chart", it.data().chart() );
+        modeAndChartMapElement.appendChild( modeAndChartElement );
+    }
+
+    // the PropertySetMap element
+    QDomElement propertySetMapElement =
+        doc.createElement( "PropertySetMap" );
+    docRoot.appendChild( propertySetMapElement );
+    QIntDictIterator<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
+    QDomElement 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
+        QDomElement outlineDataLineStyleElement =
+            doc.createElement( "OutlineDataLineStyle" );
+        colorSettingsElement.appendChild( outlineDataLineStyleElement );
+        outlineDataLineStyleElement.setAttribute( "Style",
+                KDXML::penStyleToString( _outlineDataLineStyle ) );
+    }
+
+
+    // the BarSettings elemenet
+    QDomElement 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
+    QDomElement 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( QMap<uint,KDChartParams::LineMarkerStyle>::ConstIterator it = _lineMarkerStyles.begin();
+                it != _lineMarkerStyles.end(); ++it ) {
+            QDomElement 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
+        QDomElement lineStyleElement =
+            doc.createElement( "LineStyle" );
+        lineSettingsElement.appendChild( lineStyleElement );
+        lineStyleElement.setAttribute( "Style",
+                KDXML::penStyleToString( _lineStyle ) );
+
+        // the DatasetLineStyles elements
+        {for( QMap<uint,  PenStyle>::ConstIterator it = _datasetLineStyles.begin();
+                it != _datasetLineStyles.end(); ++it ) {
+            QDomElement 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
+    QDomElement 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
+    QDomElement 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( QValueList<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
+    QDomElement 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
+    QDomElement 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 ){
+            QDomElement 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
+    QDomElement 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( QMap<uint,KDChartParams::PolarMarkerStyle>::ConstIterator it = _polarMarkerStyles.begin();
+                it != _polarMarkerStyles.end(); ++it ) {
+            QDomElement 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
+    QDomElement 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( QMap<int,QString>::ConstIterator it = _legendText.begin();
+                it != _legendText.end(); ++it ) {
+            QDomElement 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++ ) {
+        QDomElement 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
+    QDomElement 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
+    QDomElement 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
+    QDomElement 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
+    QDomElement dataValuesGlobalSettingsElement =
+        doc.createElement( "DataValuesGlobalSettings" );
+    docRoot.appendChild( dataValuesGlobalSettingsElement );
+    {
+        KDXML::createBoolNode( doc, dataValuesGlobalSettingsElement,
+                "allowOverlappingTexts",
+                _allowOverlappingDataValueTexts );
+    }
+
+    // the AreaMap element
+    QDomElement areaMapElement =
+        doc.createElement( "AreaMap" );
+    docRoot.appendChild( areaMapElement );
+    {
+        QDictIterator<KDChartFrameSettings> it( _areaDict );
+        for( ; it.current(); ++it ){
+            KDChartFrameSettings::createFrameSettingsNode( doc, areaMapElement,
+                    "FrameSettings",
+                    it.current(),
+                    it.currentKey().left(5).stripWhiteSpace().toUInt() );
+        }
+    }
+
+    // the CustomBoxMap element
+    QDomElement customBoxMapElement =
+        doc.createElement( "CustomBoxMap" );
+    docRoot.appendChild( customBoxMapElement );
+    {
+        QIntDictIterator<KDChartCustomBox> it( _customBoxDict );
+        for( ; it.current(); ++it ){
+            KDXML::createIntNode( doc, customBoxMapElement, "Number", it.currentKey() );
+            KDChartCustomBox::createCustomBoxNode( doc, customBoxMapElement,
+                    "CustomBox", it );
+        }
+    }
+
+
+    return doc;
+}
+
+
+/**
+  \fn QTextStream& operator>>( QTextStream& s, KDChartParams& p );
+
+  Reads the an XML document from the text stream s into the
+  KDChartParams object p
+
+  \param s the text stream to read from
+  \param p the KDChartParams object to read into
+  \return the text stream after the read operation
+  */
+QTextStream& operator>>( QTextStream& s, KDChartParams& p )
+{
+    QDomDocument doc( "ChartParams" );
+    // would be nicer if QDomDocument could read from a QTextStream...
+    QString docString = s.read();
+    doc.setContent( docString );
+
+    p.loadXML( doc );
+
+    return s;
+}
+
+
+/**
+  Helper method called by loadXML() only.
+  */
+void KDChartParams::loadAxesFormXML(int& curAxisSettings, QDomElement& element)
+{
+    KDChartAxisParams* axisSettings =
+        &( _axisSettings[ curAxisSettings ].params );
+    QDomNode node = element.firstChild();
+    while( !node.isNull() ) {
+        QDomElement element = node.toElement();
+        if( !element.isNull() ) { // was really an element
+            QString tagName = element.tagName();
+            if( tagName == "Type" ) {
+                QString 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" ) {
+                QString 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" ) {
+                QString 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" ) {
+                QRect 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" ) {
+                QColor 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" ) {
+                QColor 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" ) {
+                QColor 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" ) {
+                QColor 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" ) {
+                QColor 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" ) {
+                QVariant valX, valY;
+                int propID;
+                if( readChartValueNode( element, valY, valX, propID ) &&
+                    QVariant::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" ) {
+                QVariant valX, valY;
+                int propID;
+                if( readChartValueNode( element, valY, valX, propID ) &&
+                    QVariant::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" ) {
+                QString 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" ) {
+                QString 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" ) {
+                QString string;
+                if( KDXML::readStringNode( element, string ) )
+                    axisSettings->_axisLabelStringList << string;
+            } else if( tagName == "ShortLabelString" ) {
+                QString string;
+                if( KDXML::readStringNode( element, string ) )
+                    axisSettings->_axisShortLabelsStringList << string;
+            } else if( tagName == "LabelText" ) {
+                QString 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" ) {
+                QString value;
+                if( KDXML::readStringNode( element, value ) )
+                    axisSettings->_axisFirstLabelText = value;
+            } else if( tagName == "LastLabelReplacementText" ) {
+                QString 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" ) {
+                QString value;
+                if( KDXML::readStringNode( element, value ) )
+                    axisSettings->_axisLabelsDecimalPoint = value;
+            } else if( tagName == "LabelsThousandsPoint" ) {
+                QString value;
+                if( KDXML::readStringNode( element, value ) )
+                    axisSettings->_axisLabelsThousandsPoint = value;
+            } else if( tagName == "LabelsNotation" ) {
+                QString string;
+                if( KDXML::readStringNode( element, string ) )
+                    axisSettings->_axisLabelsNotation = KDChartEnums::stringToNumberNotation( string );
+            } else if( tagName == "LabelsPrefix" ) {
+                QString value;
+                if( KDXML::readStringNode( element, value ) )
+                    axisSettings->_axisLabelsPrefix = value;
+            } else if( tagName == "LabelsPostfix" ) {
+                QString 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" ) {
+                QString 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 {
+                qDebug( "Unknown subelement of AxisSettings found: %s", tagName.latin1() );
+            }
+        }
+        node = node.nextSibling();
+    }
+    curAxisSettings++; // one axis settings entry finished
+}
+
+
+/**
+  Reads the parameters from an XML document.
+  \param doc the XML document to read from
+  \return true if the parameters could be read, false if a file
+  format error occurred
+  \sa saveXML
+  */
+bool KDChartParams::loadXML( const QDomDocument& doc )
+{
+    int curAxisSettings = 0;
+    int curHFSettings = 0;
+
+    QDomElement docRoot = doc.documentElement(); // ChartParams element
+    QDomNode node = docRoot.firstChild();
+    while( !node.isNull() ) {
+        QDomElement element = node.toElement();
+        if( !element.isNull() ) { // was really an element
+            QString 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;
+                QDomNode node = element.firstChild();
+                while( !node.isNull() ) {
+                    QDomElement element = node.toElement();
+                    if( !element.isNull() ) { // was really an element
+                        QString 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 {
+                            qDebug( "Unknown subelement of ModeAndChartMap found: %s", tagName.latin1() );
+                        }
+                    }
+                    node = node.nextSibling();
+                }
+            } else if( tagName == "PropertySetMap" ) {
+                // the PropertySetMap element
+                QDomNode node = element.firstChild();
+                KDChartPropertySet set;
+                while( !node.isNull() ) {
+                    QDomElement 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" ) {
+                QDomNode node = element.firstChild();
+                while( !node.isNull() ) {
+                    QDomElement element = node.toElement();
+                    if( !element.isNull() ) { // was really an element
+                        QString tagName = element.tagName();
+                        if( tagName == "DataColors" ) {
+                            QMap<uint,QColor>* 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" ) {
+                            QString 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" ) {
+                            QMap<uint,QColor>* map = &_dataColorsShadow1;
+                            readColorMapNode( element, map );
+                        } else if( tagName == "DataColorsShadow2" ) {
+                            QMap<uint,QColor>* map = &_dataColorsShadow2;
+                            readColorMapNode( element, map );
+                        } else if( tagName == "OutlineDataColor" ) {
+                            QColor 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 {
+                            qDebug( "!!!Unknown subelement of ColorSettings found: %s", tagName.latin1() );
+                        }
+                    }
+                    node = node.nextSibling();
+                }
+            } else if( tagName == "BarSettings" ) {
+                QDomNode node = element.firstChild();
+                while( !node.isNull() ) {
+                    QDomElement element = node.toElement();
+                    if( !element.isNull() ) { // was really an element
+                        QString tagName = element.tagName();
+                        if( tagName == "SubType" ) {
+                            QString 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 {
+                            qDebug( "Unknown subelement of BarSettings found: %s", tagName.latin1() );
+                        }
+                    }
+                    node = node.nextSibling();
+                }
+            } else if( tagName == "LineSettings" ) {
+                QDomNode node = element.firstChild();
+                while( !node.isNull() ) {
+                    QDomElement element = node.toElement();
+                    if( !element.isNull() ) { // was really an element
+                        QString tagName = element.tagName();
+                        if( tagName == "SubType" ) {
+                            QString 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" ) {
+                            QColor 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;
+                            PenStyle style = Qt::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 {
+                            qDebug( "Unknown subelement of LineSettings found: %s", tagName.latin1() );
+                        }
+                    }
+                    node = node.nextSibling();
+                }
+            } else if( tagName == "AreaSettings" ) {
+                QDomNode node = element.firstChild();
+                while( !node.isNull() ) {
+                    QDomElement element = node.toElement();
+                    if( !element.isNull() ) { // was really an element
+                        QString tagName = element.tagName();
+                        if( tagName == "SubType" ) {
+                            QString value;
+                            if( KDXML::readStringNode( element, value ) )
+                                _areaChartSubType = KDChartParams::stringToAreaChartSubType( value );
+                        } else if( tagName == "Location" ) {
+                            QString string;
+                            if( KDXML::readStringNode( element, string ) )
+                                _areaLocation = KDChartParams::stringToAreaLocation( string );
+                        } else {
+                            qDebug( "Unknown subelement of AreaSettings found: %s", tagName.latin1() );
+                        }
+                    }
+                    node = node.nextSibling();
+                }
+            } else if( tagName == "PieRingSettings" ) {
+                QDomNode node = element.firstChild();
+                while( !node.isNull() ) {
+                    QDomElement element = node.toElement();
+                    if( !element.isNull() ) { // was really an element
+                        QString 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" ) {
+                            QMap<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 {
+                            qDebug( "Unknown subelement of PieRingSettings found: %s", tagName.latin1() );
+                        }
+                    }
+                    node = node.nextSibling();
+                }
+            } else if( tagName == "HiLoSettings" ) {
+                QDomNode node = element.firstChild();
+                while( !node.isNull() ) {
+                    QDomElement element = node.toElement();
+                    if( !element.isNull() ) { // was really an element
+                        QString tagName = element.tagName();
+                        if( tagName == "SubType" ) {
+                            QString 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" ) {
+                            QColor 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" ) {
+                            QColor 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" ) {
+                            QColor 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" ) {
+                            QColor color;
+                            if( KDXML::readColorNode( element, color ) )
+                                _hiLoChartCloseValuesColor = color;
+                        } else {
+                            qDebug( "Unknown subelement of HiLoSettings found: %s", tagName.latin1() );
+                        }
+                    }
+                    node = node.nextSibling();
+                }
+
+
+            } else if( tagName == "BoxAndWhiskerSettings" ) {
+                QDomNode node = element.firstChild();
+                while( !node.isNull() ) {
+                    QDomElement element = node.toElement();
+                    if( !element.isNull() ) { // was really an element
+                        QString tagName = element.tagName();
+                        if( tagName == "SubType" ) {
+                            QString 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" ) {
+                            QBrush 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
+                            QString statName(tagName.mid( 15 ));
+                            BWStatVal i( stringToBWChartStatVal( statName ) );
+                            if( BWStatValSTART <= i && i <= BWStatValEND ) {
+                                QDomNode node = element.firstChild();
+                                while( !node.isNull() ) {
+                                    QDomElement element = node.toElement();
+                                    if( !element.isNull() ) { // was really an element
+                                        QString 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" ) {
+                                            QColor color;
+                                            if( KDXML::readColorNode( element, color ) )
+                                                _BWChartStatistics[ i ].color = color;
+                                        } else if( tagName == "Brush" ) {
+                                            QBrush brush;
+                                            if( KDXML::readBrushNode( element, brush ) )
+                                                _BWChartStatistics[ i ].brush = brush;
+                                        } else {
+                                            qDebug( "Unknown subelement of BoxAndWhiskerSettings found: %s", tagName.latin1() );
+                                        }
+                                    }
+                                }
+                            } else {
+                                qDebug( "Unknown subelement of BoxAndWhiskerSettings found: %s", tagName.latin1() );
+                            }
+                        } else {
+                            qDebug( "Unknown subelement of BoxAndWhiskerSettings found: %s", tagName.latin1() );
+                        }
+                    }
+                    node = node.nextSibling();
+                }
+            } else if( tagName == "PolarSettings" ) {
+                QDomNode node = element.firstChild();
+                while( !node.isNull() ) {
+                    QDomElement element = node.toElement();
+                    if( !element.isNull() ) { // was really an element
+                        QString tagName = element.tagName();
+                        if( tagName == "SubType" ) {
+                            QString 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 {
+                            qDebug( "Unknown subelement of PolarSettings found: %s", tagName.latin1() );
+                        }
+                    }
+                    node = node.nextSibling();
+                }
+            } else if( tagName == "LegendSettings" ) {
+                QDomNode node = element.firstChild();
+                while( !node.isNull() ) {
+                    QDomElement element = node.toElement();
+                    if( !element.isNull() ) { // was really an element
+                        QString tagName = element.tagName();
+                        if( tagName == "Position" ) {
+                            QString string;
+                            if( KDXML::readStringNode( element, string ) )
+                                _legendPosition = KDChartParams::stringToLegendPosition( string );
+                        } else if( tagName == "Orientation" ) {
+                            Qt::Orientation value=Qt::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" ) {
+                            QString string;
+                            if( KDXML::readStringNode( element, string ) )
+                                _legendSource = KDChartParams::stringToLegendSource( string );
+                        } else if( tagName == "LegendText" ) {
+                            bool ok = true;
+                            uint dataset = 0;
+                            QString 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" ) {
+                            QColor color;
+                            if( KDXML::readColorNode( element, color ) )
+                                _legendTextColor = color;
+                        } else if( tagName == "TextFont" ) {
+                            readChartFontNode( element,
+                                    _legendFont,
+                                    _legendFontUseRelSize,
+                                    _legendFontRelSize );
+                        } else if( tagName == "TitleText" ) {
+                            QString string;
+                            if( KDXML::readStringNode( element, string ) )
+                                _legendTitleText = string;
+                        } else if( tagName == "TitleColor" ) {
+                            QColor 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 {
+                            qDebug( "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 ] );
+                QDomNode node = element.firstChild();
+                while( !node.isNull() ) {
+                    QDomElement element = node.toElement();
+                    if( !element.isNull() ) { // was really an element
+                        QString tagName = element.tagName();
+                        if( tagName == "Text" ) {
+                            QString 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" ) {
+                            QColor color;
+                            if( KDXML::readColorNode( element, color ) )
+                                hfSettings->_color = color;
+                        } else {
+                            qDebug( "Unknown subelement of HeaderFooterSettings found: %s", tagName.latin1() );
+                        }
+                    }
+                    node = node.nextSibling();
+                }
+                curHFSettings++; // one header/footer setting finished
+            } else if( tagName == "GlobalLeading" ) {
+                QDomNode node = element.firstChild();
+                while( !node.isNull() ) {
+                    QDomElement element = node.toElement();
+                    if( !element.isNull() ) { // was really an elemente
+                        QString 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 {
+                            qDebug( "Unknown subelement of GlobalLeading found: %s", tagName.latin1() );
+                        }
+                    }
+                    node = node.nextSibling();
+                }
+            } else if( tagName == "DataValuesSettings1" ) {
+                QDomNode node = element.firstChild();
+                while( !node.isNull() ) {
+                    QDomElement element = node.toElement();
+                    if( !element.isNull() ) { // was really an element
+                        QString 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" ) {
+                            QString 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" ) {
+                            QString 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" ) {
+                            QString value;
+                            if( KDXML::readStringNode( element, value ) )
+                                _printDataValuesSettings._dataValuesLayoutPolicy = KDChartEnums::stringToLayoutPolicy( value );
+                        } else if( tagName == "ShowInfinite" ) {
+                            KDXML::readBoolNode( element, _printDataValuesSettings._dataValuesShowInfinite );
+                        } else {
+                            qDebug( "Unknown subelement of DataValuesSettings1 found: %s", tagName.latin1() );
+                        }
+                    }
+                    node = node.nextSibling();
+                }
+            } else if( tagName == "DataValuesSettings2" ) {
+                QDomNode node = element.firstChild();
+                while( !node.isNull() ) {
+                    QDomElement element = node.toElement();
+                    if( !element.isNull() ) { // was really an element
+                        QString 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" ) {
+                            QString 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" ) {
+                            QString 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" ) {
+                            QString value;
+                            if( KDXML::readStringNode( element, value ) )
+                                _printDataValuesSettings2._dataValuesLayoutPolicy = KDChartEnums::stringToLayoutPolicy( value );
+                        } else if( tagName == "ShowInfinite" ) {
+                            KDXML::readBoolNode( element, _printDataValuesSettings2._dataValuesShowInfinite );
+                        } else {
+                            qDebug( "Unknown subelement of DataValuesSettings2 found: %s", tagName.latin1() );
+                        }
+                    }
+                    node = node.nextSibling();
+                }
+            } else if( tagName == "DataValuesGlobalSettings" ) {
+                QDomNode node = element.firstChild();
+                while( !node.isNull() ) {
+                    QDomElement element = node.toElement();
+                    if( !element.isNull() ) { // was really an element
+                        QString tagName = element.tagName();
+                        if( tagName == "allowOverlappingTexts" ) {
+                            bool value;
+                            if( KDXML::readBoolNode( element, value ) )
+                                _allowOverlappingDataValueTexts = value;
+                        }
+                        else
+                            qDebug( "Unknown subelement of DataValuesGlobalSettings found: %s", tagName.latin1() );
+                        // do _not_ return false here (to enable future extentions)
+                    }
+                    node = node.nextSibling();
+                }
+            } else if( tagName == "AreaMap" ) {
+                QDomNode node = element.firstChild();
+                while( !node.isNull() ) {
+                    QDomElement element = node.toElement();
+                    if( !element.isNull() ) { // was really an element
+                        QString tagName = element.tagName();
+                        if( tagName == "FrameSettings" ) {
+                            KDChartFrameSettings* frameSettings = new KDChartFrameSettings;
+                            uint areaId = KDChartEnums::AreaUNKNOWN;
+                            if( KDChartFrameSettings::readFrameSettingsNode(
+                                        element, *frameSettings, areaId ) ) {
+                                QString str;
+                                if(areaId == KDChartEnums::AreaChartDataRegion)
+                                    str = QString( "%1/%2/%3/%4" )
+                                              .arg( areaId, 5 )
+                                              .arg( frameSettings->dataRow(), 5 )
+                                              .arg( frameSettings->dataCol(), 5 )
+                                              .arg( 0, 5 );//frameSettings->data3rd(), 5 );
+                                else
+                                    str = QString( "%1/-----/-----/-----" ).arg( areaId, 5 );
+                                _areaDict.replace( str, frameSettings );
+                            }
+                        }
+                        else
+                            qDebug( "Unknown tag in AreaMap found: %s", tagName.latin1() );
+                        // do _not_ return false here (to enable future extentions)
+                    }
+                    node = node.nextSibling();
+                }
+            } else if( tagName == "CustomBoxMap" ) {
+                QDomNode node = element.firstChild();
+                int curNumber = -1;
+                while( !node.isNull() ) {
+                    QDomElement element = node.toElement();
+                    if( !element.isNull() ) { // was really an element
+                        QString 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
+                            qDebug( "Unknown tag in CustomBoxMap found: %s", tagName.latin1() );
+                    }
+                    node = node.nextSibling();
+                }
+            } else {
+                qDebug( "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;
+}
+
+
+/**
+  Creates a DOM element node that represents a map of QColor objects
+  for use in a DOM document.
+
+  \param doc the DOM document to which the node will belong
+  \param parent the parent node to which the new node will be appended
+  \param elementName the name of the new node
+  \param map the map of colors to be represented
+  */
+void KDChartParams::createColorMapNode( QDomDocument& doc, QDomNode& parent,
+        const QString& elementName,
+        const QMap< uint, QColor >& map )
+{
+    QDomElement mapElement =
+        doc.createElement( elementName );
+    parent.appendChild( mapElement );
+    for( QMap<uint,QColor>::ConstIterator it = map.begin();
+            it != map.end(); ++it ) {
+        // Dataset element
+        QDomElement datasetElement = doc.createElement( "Dataset" );
+        mapElement.appendChild( datasetElement );
+        QDomText datasetContent =
+            doc.createTextNode( QString::number( it.key() ) );
+        datasetElement.appendChild( datasetContent );
+        // Color element
+        KDXML::createColorNode( doc, mapElement, "Color", it.data() );
+    }
+}
+
+
+/**
+  Creates a DOM element node that represents a map of doubles
+  for use in a DOM document.
+
+  \param doc the DOM document to which the node will belong
+  \param parent the parent node to which the new node will be appended
+  \param elementName the name of the new node
+  \param map the map of doubles to be represented
+  */
+void KDChartParams::createDoubleMapNode( QDomDocument& doc, QDomNode& parent,
+        const QString& elementName,
+        const QMap< int, double >& map )
+{
+    QDomElement mapElement =
+        doc.createElement( elementName );
+    parent.appendChild( mapElement );
+    for( QMap<int,double>::ConstIterator it = map.begin();
+            it != map.end(); ++it ) {
+        // Dataset element
+        QDomElement valueElement = doc.createElement( "Value" );
+        mapElement.appendChild( valueElement );
+        QDomText valueContent =
+            doc.createTextNode( QString::number( it.key() ) );
+        valueElement.appendChild( valueContent );
+        // Color element
+        KDXML::createDoubleNode( doc, mapElement, "Factor", it.data() );
+    }
+}
+
+
+void dataCoordToElementAttr(const QVariant& val, QDomElement& element, const QString& postfix)
+{
+    if( QVariant::Double == val.type() )
+        element.setAttribute( "DoubleValue"+postfix,
+                              QString::number( val.toDouble() ) );
+    else if( QVariant::String == val.type() )
+        element.setAttribute( "StringValue"+postfix, val.toString() );
+    else if( QVariant::DateTime == val.type() )
+        element.setAttribute( "DateTimeValue"+postfix,
+                              val.toDateTime().toString( Qt::ISODate ) );
+    else
+        element.setAttribute( "NoValue"+postfix, "true" );
+}
+
+/**
+  Creates a DOM element node that represents a
+  chart value for use in a DOM document.
+
+  \param doc the DOM document to which the node will belong
+  \param parent the parent node to which the new node will be appended
+  \param elementName the name of the new node
+  \param data the chart value to be represented
+  */
+void KDChartParams::createChartValueNode( QDomDocument& doc, QDomNode& parent,
+        const QString& elementName,
+        const QVariant& valY,
+        const QVariant& valX,
+        const int& propID )
+{
+    QDomElement element = doc.createElement( elementName );
+    parent.appendChild( element );
+    dataCoordToElementAttr( valY, element, "" ); // no postfix for Y value: backwards compat.
+    dataCoordToElementAttr( valX, element, "X" );
+    element.setAttribute( "PropertySetID",
+                          QString::number( propID ) );
+}
+
+
+
+/**
+  Creates a DOM element node that represents a font used in a
+  chart for use in a DOM document.
+
+  \param doc the DOM document to which the node will belong
+  \param parent the parent node to which the new node will be appended
+  \param elementName the name of the new node
+  \param font the font to be resented
+  \param useRelFont the specification whether the font size
+  is relative
+  \param relFont the relative font size
+  \param minFont the minimal font size in points, leave this parameter out if not needed
+  */
+void KDChartParams::createChartFontNode( QDomDocument& doc, QDomNode& parent,
+        const QString& elementName,
+        const QFont& font, bool useRelFont,
+        int relFont,
+        int minFont )
+{
+    QDomElement 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 );
+}
+
+
+
+
+
+/**
+  Creates a DOM element node that represents a color map
+  for use in a DOM document.
+
+  \param doc the DOM document to which the node will belong
+  \param parent the parent node to which the new node will be appended
+  \param elementName the name of the new node
+  \param map the color map to be represented
+  */
+bool KDChartParams::readColorMapNode( const QDomElement& element,
+        QMap<uint,QColor>* value )
+{
+    QDomNode node = element.firstChild();
+    int curDataset = -1;
+    while( !node.isNull() ) {
+        QDomElement element = node.toElement();
+        if( !element.isNull() ) { // was really an element
+            QString tagName = element.tagName();
+            if( tagName == "Dataset" ) {
+                KDXML::readIntNode( element, curDataset );
+            } else if( tagName == "Color" ) {
+                Q_ASSERT( curDataset != -1 ); // there was a Dataset tag before
+                QColor color;
+                KDXML::readColorNode( element, color );
+                value->insert( curDataset, color );
+            } else {
+                qDebug( "Unknown tag in color map" );
+            }
+        }
+        node = node.nextSibling();
+    }
+
+    return true;
+}
+
+
+/**
+  Reads data from a DOM element node that represents a double
+  map and fills a double map with the data.
+
+  \param element the DOM element to read from
+  \param map the frame settings object to read the data into
+  */
+bool KDChartParams::readDoubleMapNode( const QDomElement& element,
+        QMap<int,double>* value )
+{
+    QDomNode node = element.firstChild();
+    int curValue = -1;
+    while( !node.isNull() ) {
+        QDomElement element = node.toElement();
+        if( !element.isNull() ) { // was really an element
+            QString 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 {
+                qDebug( "Unknown tag in double map" );
+            }
+        }
+        node = node.nextSibling();
+    }
+
+    return true;
+}
+
+
+
+/**
+  Reads data from a DOM element node that represents a font
+  uses in a chart and fills the reference parameters
+  with the data.
+
+  \param element the DOM element to read from
+  \param font the represented font
+  \param useRelFont whether the font size is relative
+  \param relFontSize the relative font size
+  */
+bool KDChartParams::readChartFontNode( const QDomElement& element,
+        QFont& font,
+        bool& useRelFont,
+        int& relFontSize,
+        int* minFontSize )
+{
+    bool ok = true;
+    QFont tempFont;
+    bool tempRelFont;
+    int tempRelFontSize;
+    int tempMinFontSize=-1;
+    QDomNode node = element.firstChild();
+    while( !node.isNull() ) {
+        QDomElement element = node.toElement();
+        if( !element.isNull() ) { // was really an element
+            QString 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 {
+                qDebug( "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 QDomElement& element, const QString& postfix,
+                          QVariant& val )
+{
+    if( element.hasAttribute( "NoValue"+postfix ) )
+        val = QVariant();
+    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.
+/**
+  Reads data from a DOM element node that represents a chart
+  value and fills a KDChartData object with the data.
+
+  \param element the DOM element to read from
+  \param value the chart data object to read the data into
+  */
+bool KDChartParams::readChartValueNode( const QDomElement& element,
+        QVariant& valY,
+        QVariant& valX,
+        int& propID )
+{
+    if( foundCoordAttribute( element, "",  valY ) ||
+        foundCoordAttribute( element, "Y", valY ) ){  // valY must be there
+        if( !foundCoordAttribute( element, "X", valX ) ){
+            valX = QVariant();
+        }
+        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;
+}
+
+
+/**
+  Converts the specified chart type enum to a string representation.
+
+  \param type the type enum to convert
+  \return the string representation of the type enum
+  */
+QString 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";
+    }
+}
+
+
+/**
+  Converts the specified string to a chart type enum value.
+
+  \param string the string to convert
+  \return the chart type enum value
+  */
+KDChartParams::ChartType KDChartParams::stringToChartType( const QString& 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;
+}
+
+
+
+QString 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
+            qDebug( "Unknown marker style" );
+            return "Circle";
+    }
+}
+QString 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
+            qDebug( "Unknown line marker style!" );
+            return tr( "Circle" );
+    }
+}
+int KDChartParams::stringToMarkerStyle( const QString& 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 QString& 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;
+}
+
+
+
+/**
+  Converts the specified bar chart subtype enum to a string representation.
+
+  \param type the type enum to convert
+  \return the string representation of the type enum
+  */
+QString 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
+            qDebug( "Unknown bar type" );
+            return "BarNormal";
+    }
+}
+
+
+/**
+  Converts the specified string to a bar chart subtype enum value.
+
+  \param string the string to convert
+  \return the bar chart subtype enum value
+  */
+KDChartParams::BarChartSubType KDChartParams::stringToBarChartSubType( const QString& 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;
+}
+
+
+
+/**
+  Converts the specified string to a line chart subtype enum value.
+
+  \param string the string to convert
+  \return the line chart subtype enum value
+  */
+KDChartParams::LineChartSubType KDChartParams::stringToLineChartSubType( const QString& string ) {
+    if( string == "LineNormal" )
+        return LineNormal;
+    else if( string == "LineStacked" )
+        return LineStacked;
+    else if( string == "LinePercent" )
+        return LinePercent;
+    else // should not happen
+        return LineNormal;
+}
+
+
+
+/**
+  Converts the specified line chart subtype enum to a string representation.
+
+  \param type the type enum to convert
+  \return the string representation of the type enum
+  */
+QString KDChartParams::lineChartSubTypeToString( LineChartSubType type ) {
+    switch( type ) {
+        case LineNormal:
+            return "LineNormal";
+        case LineStacked:
+            return "LineStacked";
+        case LinePercent:
+            return "LinePercent";
+        default: // should not happen
+            qDebug( "Unknown bar type" );
+            return "LineNormal";
+    }
+}
+
+
+/**
+  Converts the specified line marker style enum to a string
+  representation.
+
+  \param type the type enum to convert
+  \return the string representation of the type enum
+  */
+QString KDChartParams::lineMarkerStyleToString( LineMarkerStyle style )
+{
+    return markerStyleToString( style );
+}
+
+
+/**
+  Converts the specified line marker style enum to a localized
+  string representation that can be used for string output.
+
+  \param type the type enum to convert
+  \return the localized string representation of the type enum
+  */
+QString KDChartParams::lineMarkerStyleToStringTr( LineMarkerStyle style )
+{
+    return markerStyleToStringTr( style );
+}
+
+
+/**
+  Converts the specified string to a line marker style value.
+
+  \param string the string to convert
+  \return the line marker style enum value
+  */
+KDChartParams::LineMarkerStyle KDChartParams::stringToLineMarkerStyle( const QString& string )
+{
+    return static_cast<KDChartParams::LineMarkerStyle>(stringToMarkerStyle( string ));
+}
+
+/**
+  Converts the specified localized string to a line marker style
+  value.
+
+  \param string the string to convert
+  \return the line marker style enum value
+  */
+KDChartParams::LineMarkerStyle KDChartParams::stringToLineMarkerStyleTr( const QString& string )
+{
+    return static_cast<KDChartParams::LineMarkerStyle>(stringToMarkerStyleTr( string ));
+}
+
+
+/**
+  Converts the specified area chart subtype enum to a string representation.
+
+  \param type the subtype enum to convert
+  \return the string representation of the type enum
+  */
+QString KDChartParams::areaChartSubTypeToString( AreaChartSubType type ) {
+    switch( type ) {
+        case AreaNormal:
+            return "AreaNormal";
+        case AreaStacked:
+            return "AreaStacked";
+        case AreaPercent:
+            return "AreaPercent";
+        default: // should not happen
+            qDebug( "Unknown area chart subtype" );
+            return "AreaNormal";
+    }
+}
+
+
+/**
+  Converts the specified string to a area chart subtype enum value.
+
+  \param string the string to convert
+  \return the area chart subtype enum value
+  */
+KDChartParams::AreaChartSubType KDChartParams::stringToAreaChartSubType( const QString& string ) {
+    if( string == "AreaNormal" )
+        return AreaNormal;
+    else if( string == "AreaStacked" )
+        return AreaStacked;
+    else if( string == "AreaPercent" )
+        return AreaPercent;
+    else // should not happen
+        return AreaNormal;
+}
+
+
+/**
+  Converts the specified area location enum to a string representation.
+
+  \param type the location enum to convert
+  \return the string representation of the type enum
+  */
+QString KDChartParams::areaLocationToString( AreaLocation type ) {
+    switch( type ) {
+        case AreaAbove:
+            return "Above";
+        case AreaBelow:
+            return "Below";
+        default: // should not happen
+            qDebug( "Unknown area location" );
+            return "Below";
+    }
+}
+
+
+/**
+  Converts the specified string to an area location enum value.
+
+  \param string the string to convert
+  \return the aration location enum value
+  */
+KDChartParams::AreaLocation KDChartParams::stringToAreaLocation( const QString& string ) {
+    if( string == "Above" )
+        return AreaAbove;
+    else if( string == "Below" )
+        return AreaBelow;
+    else // default, should not happen
+        return AreaBelow;
+}
+
+
+/**
+  Converts the specified string to a polar chart subtype enum value.
+
+  \param string the string to convert
+  \return the polar chart subtype enum value
+  */
+KDChartParams::PolarChartSubType KDChartParams::stringToPolarChartSubType( const QString& string ) {
+    if( string == "PolarNormal" )
+        return PolarNormal;
+    else if( string == "PolarStacked" )
+        return PolarStacked;
+    else if( string == "PolarPercent" )
+        return PolarPercent;
+    else // should not happen
+        return PolarNormal;
+}
+
+
+/**
+  Converts the specified polar chart subtype enum to a string representation.
+
+  \param type the type enum to convert
+  \return the string representation of the type enum
+  */
+QString KDChartParams::polarChartSubTypeToString( PolarChartSubType type ) {
+    switch( type ) {
+        case PolarNormal:
+            return "PolarNormal";
+        case LineStacked:
+            return "PolarStacked";
+        case LinePercent:
+            return "PolarPercent";
+        default: // should not happen
+            qDebug( "Unknown polar type" );
+            return "PolarNormal";
+    }
+}
+
+
+/**
+  Converts the specified polar marker style enum to a string
+  representation.
+
+  \param type the type enum to convert
+  \return the string representation of the type enum
+  */
+QString KDChartParams::polarMarkerStyleToString( PolarMarkerStyle style )
+{
+    return markerStyleToString( style );
+}
+
+
+/**
+  Converts the specified polar marker style enum to a localized
+  string representation that can be used for string output.
+
+  \param type the type enum to convert
+  \return the localized string representation of the type enum
+  */
+QString KDChartParams::polarMarkerStyleToStringTr( PolarMarkerStyle style )
+{
+    return markerStyleToStringTr( style );
+}
+
+
+/**
+  Converts the specified string to a polar marker style value.
+
+  \param string the string to convert
+  \return the polar marker style enum value
+  */
+KDChartParams::PolarMarkerStyle KDChartParams::stringToPolarMarkerStyle( const QString& string )
+{
+    return static_cast<KDChartParams::PolarMarkerStyle>(stringToMarkerStyle( string ));
+}
+
+
+/**
+  Converts the specified localized string to a polar marker style
+  value.
+
+  \param string the string to convert
+  \return the polar marker style enum value
+  */
+KDChartParams::PolarMarkerStyle KDChartParams::stringToPolarMarkerStyleTr( const QString& string )
+{
+    return static_cast<KDChartParams::PolarMarkerStyle>(stringToMarkerStyle( string ));
+}
+
+
+/**
+  Converts the specified HiLo chart subtype enum to a string representation.
+
+  \param type the subtype enum to convert
+  \return the string representation of the type enum
+  */
+QString KDChartParams::hiLoChartSubTypeToString( HiLoChartSubType type ) {
+    switch( type ) {
+        case HiLoSimple:
+            return "HiLoSimple";
+        case HiLoClose:
+            return "HiLoClose";
+        case HiLoOpenClose:
+            return "HiLoOpenClose";
+        default: // should not happen
+            qDebug( "Unknown HiLo chart subtype" );
+            return "HiLoNormal";
+    }
+}
+
+
+/**
+  Converts the specified string to a HiLo chart subtype enum value.
+
+  \param string the string to convert
+  \return the HiLo chart subtype enum value
+  */
+KDChartParams::HiLoChartSubType KDChartParams::stringToHiLoChartSubType( const QString& string ) {
+    if( string == "HiLoSimple" )
+        return HiLoSimple;
+    else if( string == "HiLoClose" )
+        return HiLoClose;
+    else if( string == "HiLoOpenClose" )
+        return HiLoOpenClose;
+    else // should not happen
+        return HiLoNormal;
+}
+
+
+/**
+  Converts the specified string to a BoxWhisker chart subtype enum value.
+
+  \param string the string to convert
+  \return the BoxWhisker chart subtype enum value
+  */
+KDChartParams::BWChartSubType KDChartParams::stringToBWChartSubType( const QString& string ) {
+    if( string == "BWSimple" )
+        return BWSimple;
+    else // should not happen
+        return BWNormal;
+}
+
+/**
+  Converts the specified BWStatVal enum to a string representation.
+
+  \param type the BWStatVal enum to convert
+  \return the string representation of the type BWStatVal
+  */
+QString 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
+            qDebug( "Unknown BoxWhisker statistical value type" );
+            return "unknown";
+    }
+}
+
+/**
+  Converts the specified string to a BWStatVal enum value.
+
+  \param string the string to convert
+  \return the BWStatVal enum value
+  */
+KDChartParams::BWStatVal KDChartParams::stringToBWChartStatVal( const QString& 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;
+}
+
+
+/**
+  Converts the specified legend position enum to a string representation.
+
+  \param type the legend position enum to convert
+  \return the string representation of the type enum
+  */
+QString 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
+            qDebug( "Unknown legend position" );
+            return "LegendLeft";
+    }
+}
+
+
+/**
+  Converts the specified string to a legend position enum value.
+
+  \param string the string to convert
+  \return the legend position enum value
+  */
+KDChartParams::LegendPosition KDChartParams::stringToLegendPosition( const QString& 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;
+}
+
+/**
+  Converts the specified legend source enum to a string representation.
+
+  \param source the legend source enum to convert
+  \return the string representation of the type enum
+  */
+QString KDChartParams::legendSourceToString( LegendSource source ) {
+    switch( source ) {
+        case LegendManual:
+            return "Manual";
+        case LegendFirstColumn:
+            return "FirstColumn";
+        case LegendAutomatic:
+            return "Automatic";
+        default: // should not happen
+            qDebug( "Unknown legend source" );
+            return "Automatic";
+    }
+}
+
+
+/**
+  Converts the specified string to a legend source enum value.
+
+  \param string the string to convert
+  \return the legend source enum value
+  */
+KDChartParams::LegendSource KDChartParams::stringToLegendSource( const QString& 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;
+}
+
+
+/**
+  Converts the specified chart source mode enum value to a string.
+
+  \param mode the chart source mode enum value to convert
+  \return the string
+  */
+QString 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";
+    }
+}
+
+
+/**
+  Converts the specified string to a chart source mode enum value.
+
+  \param string the string to convert
+  \return the chart source mode enum value
+  */
+KDChartParams::SourceMode KDChartParams::stringToChartSourceMode( const QString& 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;
+}
+
+
+/**
+  Converts the specified BoxWhisker chart subtype enum to a string
+  representation.
+
+  \param type the subtype enum to convert
+  \return the string representation of the type enum
+  */
+QString KDChartParams::bWChartSubTypeToString( BWChartSubType type ) {
+    switch( type ) {
+        case BWSimple:
+            return "BWSimple";
+        default: // should not happen
+            qDebug( "Unknown BoxWhisker chart subtype" );
+            return "BWNormal";
+    }
+}
+