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