/* -*- Mode: C++ -*-
KDChart - a multi-platform charting engine
*/
/****************************************************************************
** Copyright (C) 2001-2003 Klarälvdalens Datakonsult AB. All rights reserved.
**
** This file is part of the KDChart library.
**
** This file may be distributed and/or modified under the terms of the
** GNU General Public License version 2 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file.
**
** Licensees holding valid commercial KDChart licenses may use this file in
** accordance with the KDChart Commercial License Agreement provided with
** the Software.
**
** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
**
** See http://www.klaralvdalens-datakonsult.se/?page=products for
** information about KDChart Commercial License Agreements.
**
** Contact info@klaralvdalens-datakonsult.se if any conditions of this
** licensing are not clear to you.
**
**********************************************************************/
#include "KDChartParams.h"
#include <KDXMLTools.h>
#include <tqintdict.h>
/**
\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 = "<ChartParams/>";
TQDomDocument doc( "ChartParams" );
doc.setContent( docstart );
if( withPI )
doc.appendChild( doc.createProcessingInstruction( "xml", "version=\"1.0\" encoding=\"UTF-8\"" ) );
TQDomElement docRoot = doc.documentElement();
docRoot.setAttribute( "xmlns", "http://www.klaralvdalens-datakonsult.se/kdchart" );
docRoot.setAttribute( "xmlns:xsi", "http://www.w3.org/2000/10/XMLSchema-instance" );
docRoot.setAttribute( "xsi:schemaLocation", "http://www.klaralvdalens-datakonsult.se/kdchart" );
// the ChartType element
TQDomElement chartTypeElement = doc.createElement( "ChartType" );
docRoot.appendChild( chartTypeElement );
chartTypeElement.setAttribute( "primary",
chartTypeToString( _chartType ) );
chartTypeElement.setAttribute( "secondary",
chartTypeToString( _additionalChartType ) );
// the NumValues element
KDXML::createIntNode( doc, docRoot, "NumValues", _numValues );
// the ModeAndChartMap element
TQDomElement modeAndChartMapElement =
doc.createElement( "ModeAndChartMap" );
docRoot.appendChild( modeAndChartMapElement );
for( TQMap<uint,KDChartParams::ModeAndChart>::ConstIterator it = _dataSourceModeAndChart.begin();
it != _dataSourceModeAndChart.end(); ++it ) {
// Dataset element
TQDomElement datasetElement = doc.createElement( "Dataset" );
TQDomText datasetContent =
doc.createTextNode( TQString::number( it.key() ) );
datasetElement.appendChild( datasetContent );
modeAndChartMapElement.appendChild( datasetElement );
// ModeAndChart element
TQDomElement modeAndChartElement = doc.createElement( "ModeAndChart" );
modeAndChartElement.setAttribute( "Mode", chartSourceModeToString( it.data().mode() ) );
modeAndChartElement.setAttribute( "Chart", it.data().chart() );
modeAndChartMapElement.appendChild( modeAndChartElement );
}
// the PropertySetMap element
TQDomElement propertySetMapElement =
doc.createElement( "PropertySetMap" );
docRoot.appendChild( propertySetMapElement );
TQIntDictIterator<KDChartPropertySet> it2( _propertySetList );
for( ; it2.current(); ++it2 )
propertySetMapElement.appendChild( it2.current()->saveXML( doc ) );
KDXML::createBoolNode( doc, docRoot, "ChartSourceModeWasUsed",
_setChartSourceModeWasUsed );
// the MaxDatasetSourceMode element
KDXML::createIntNode( doc, docRoot, "MaxDatasetSourceMode",
_maxDatasetSourceMode );
// the ColorSettings element
TQDomElement colorSettingsElement =
doc.createElement( "ColorSettings" );
docRoot.appendChild( colorSettingsElement );
{
// the DataColors element
createColorMapNode( doc, colorSettingsElement,
"DataColors", _dataColors );
// the MaxDatasetColor element
KDXML::createIntNode( doc, colorSettingsElement, "MaxDatasetColor",
_maxDatasetColor );
// the ShadowBrightnessFactor element
KDXML::createDoubleNode( doc, colorSettingsElement,
"ShadowBrightnessFactor",
_shadowBrightnessFactor );
// the ShadowPattern element
KDXML::createStringNode( doc, colorSettingsElement,
"ShadowPattern",
KDXML::brushStyleToString(_shadowPattern ) );
// the ThreeDShadowColors element
KDXML::createBoolNode( doc, colorSettingsElement,
"ThreeDShadowColors",
_threeDShadowColors );
// the DataColorsShadow1 element
createColorMapNode( doc, colorSettingsElement,
"DataColorsShadow1",
_dataColorsShadow1 );
// the DataColorsShadow2 element
createColorMapNode( doc, colorSettingsElement,
"DataColorsShadow2",
_dataColorsShadow2 );
// the OutlineDataColor element
KDXML::createColorNode( doc, colorSettingsElement,
"OutlineDataColor",
_outlineDataColor );
// the OutlineDataLineWidth element
KDXML::createIntNode( doc, colorSettingsElement,
"OutlineDataLineWidth",
_outlineDataLineWidth );
// the OutlineDataLineStyle element
TQDomElement outlineDataLineStyleElement =
doc.createElement( "OutlineDataLineStyle" );
colorSettingsElement.appendChild( outlineDataLineStyleElement );
outlineDataLineStyleElement.setAttribute( "Style",
KDXML::penStyleToString( _outlineDataLineStyle ) );
}
// the BarSettings elemenet
TQDomElement barSettingsElement =
doc.createElement( "BarSettings" );
docRoot.appendChild( barSettingsElement );
{
// the SubType element
KDXML::createStringNode( doc, barSettingsElement,
"SubType", KDChartParams::barChartSubTypeToString( _barChartSubType ) );
KDXML::createBoolNode( doc, barSettingsElement,
"ThreeDBars", _threeDBars );
KDXML::createDoubleNode( doc, barSettingsElement,
"ThreeDBarDepth", _threeDBarDepth );
KDXML::createIntNode( doc, barSettingsElement,
"DatasetGap", _datasetGap );
KDXML::createBoolNode( doc, barSettingsElement,
"DatasetGapIsRelative", _datasetGapIsRelative );
KDXML::createIntNode( doc, barSettingsElement,
"ValueBlockGap", _valueBlockGap );
KDXML::createBoolNode( doc, barSettingsElement,
"ValueBlockGapIsRelative",
_valueBlockGapIsRelative );
KDXML::createIntNode( doc, barSettingsElement,
"BarWidth", _barWidth );
KDXML::createBoolNode( doc, barSettingsElement,
"SolidExcessArrows", _solidExcessArrows );
}
// the LineSettings element
TQDomElement lineSettingsElement =
doc.createElement( "LineSettings" );
docRoot.appendChild( lineSettingsElement );
{
// the SubType element
KDXML::createStringNode( doc, lineSettingsElement,
"SubType", KDChartParams::lineChartSubTypeToString( _lineChartSubType ) );
// the Marker element
KDXML::createBoolNode( doc, lineSettingsElement,
"Marker", _lineMarker );
// the MarkerStyles elements
{for( TQMap<uint,KDChartParams::LineMarkerStyle>::ConstIterator it = _lineMarkerStyles.begin();
it != _lineMarkerStyles.end(); ++it ) {
TQDomElement markerStyleElement = doc.createElement( "MarkerStyle" );
lineSettingsElement.appendChild( markerStyleElement );
markerStyleElement.setAttribute( "Dataset", it.key() );
markerStyleElement.setAttribute( "Style", KDChartParams::lineMarkerStyleToString( it.data() ) );
}}
// the MarkerSize element
KDXML::createSizeNode( doc, lineSettingsElement,
"MarkerSize", _lineMarkerSize );
// the LineWidth element
KDXML::createIntNode( doc, lineSettingsElement,
"LineWidth", _lineWidth );
// the LineColor element
KDXML::createColorNode( doc, lineSettingsElement,
"LineColor",
_lineColor );
// the LineStyle element
TQDomElement lineStyleElement =
doc.createElement( "LineStyle" );
lineSettingsElement.appendChild( lineStyleElement );
lineStyleElement.setAttribute( "Style",
KDXML::penStyleToString( _lineStyle ) );
// the DatasetLineStyles elements
{for( TQMap<uint, Qt::PenStyle>::ConstIterator it = _datasetLineStyles.begin();
it != _datasetLineStyles.end(); ++it ) {
TQDomElement lineStyleElement = doc.createElement( "DatasetLineStyle" );
lineSettingsElement.appendChild( lineStyleElement );
lineStyleElement.setAttribute( "Dataset", it.key() );
lineStyleElement.setAttribute( "Style", KDXML::penStyleToString( it.data() ) );
}}
// the ThreeD element
KDXML::createBoolNode( doc, lineSettingsElement,
"ThreeD", _threeDLines );
// the ThreeDDepth element
KDXML::createIntNode( doc, lineSettingsElement,
"ThreeDDepth", _threeDLineDepth );
// the ThreeDXRotation element
KDXML::createIntNode( doc, lineSettingsElement,
"ThreeDXRotation", _threeDLineXRotation );
// the ThreeDYRotation element
KDXML::createIntNode( doc, lineSettingsElement,
"ThreeDYRotation", _threeDLineYRotation );
}
// the AreaSettings element
TQDomElement areaSettingsElement =
doc.createElement( "AreaSettings" );
docRoot.appendChild( areaSettingsElement );
{
// the SubType element
KDXML::createStringNode( doc, areaSettingsElement, "SubType",
KDChartParams::areaChartSubTypeToString( _areaChartSubType ) );
// the Location elemenet
KDXML::createStringNode( doc, areaSettingsElement, "Location",
KDChartParams::areaLocationToString( _areaLocation ) );
}
// the PieRingSettings element
TQDomElement pieRingSettingsElement =
doc.createElement( "PieRingSettings" );
docRoot.appendChild( pieRingSettingsElement );
{
// the Explode element
KDXML::createBoolNode( doc, pieRingSettingsElement, "Explode",
_explode );
// the DefaultExplodeFactor element
KDXML::createDoubleNode( doc, pieRingSettingsElement, "DefaultExplodeFactor",
_explodeFactor );
// the ExplodeFactors element
createDoubleMapNode( doc, pieRingSettingsElement, "ExplodeFactors",
_explodeFactors );
// the ExplodeSegment element
for( TQValueList<int>::ConstIterator it = _explodeList.begin();
it != _explodeList.end(); ++it )
KDXML::createIntNode( doc, pieRingSettingsElement,
"ExplodeSegment", *it );
// the ThreeDPies element
KDXML::createBoolNode( doc, pieRingSettingsElement, "ThreeDPies",
_threeDPies );
// the ThreeDPieHeight element
KDXML::createIntNode( doc, pieRingSettingsElement, "ThreeDPieHeight",
_threeDPieHeight );
// the PieStart element
KDXML::createIntNode( doc, pieRingSettingsElement, "PieStart",
_pieStart );
// the RingStart element
KDXML::createIntNode( doc, pieRingSettingsElement, "RingStart",
_ringStart );
// the RelativeRingThickness element
KDXML::createBoolNode( doc, pieRingSettingsElement,
"RelativeRingThickness", _relativeRingThickness );
}
// the HiLoSettings element
TQDomElement hiLoSettingsElement =
doc.createElement( "HiLoSettings" );
docRoot.appendChild( hiLoSettingsElement );
{
// the SubType element
KDXML::createStringNode( doc, hiLoSettingsElement, "SubType",
KDChartParams::hiLoChartSubTypeToString( _hiLoChartSubType ) );
// the PrintLowValues element
KDXML::createBoolNode( doc, hiLoSettingsElement, "PrintLowValues",
_hiLoChartPrintLowValues );
// the LowValuesFont element
createChartFontNode( doc, hiLoSettingsElement, "LowValuesFont",
_hiLoChartLowValuesFont,
_hiLoChartLowValuesUseFontRelSize,
_hiLoChartLowValuesFontRelSize );
// the LowValuesColor element
KDXML::createColorNode( doc, hiLoSettingsElement, "LowValuesColor",
_hiLoChartLowValuesColor );
// the PrintHighValues element
KDXML::createBoolNode( doc, hiLoSettingsElement, "PrintHighValues",
_hiLoChartPrintHighValues );
// the HighValuesFont element
createChartFontNode( doc, hiLoSettingsElement, "HighValuesFont",
_hiLoChartHighValuesFont,
_hiLoChartHighValuesUseFontRelSize,
_hiLoChartHighValuesFontRelSize );
// the HighValuesColor element
KDXML::createColorNode( doc, hiLoSettingsElement, "HighValuesColor",
_hiLoChartHighValuesColor );
// the PrintOpenValues element
KDXML::createBoolNode( doc, hiLoSettingsElement, "PrintOpenValues",
_hiLoChartPrintOpenValues );
// the OpenValuesFont element
createChartFontNode( doc, hiLoSettingsElement, "OpenValuesFont",
_hiLoChartOpenValuesFont,
_hiLoChartOpenValuesUseFontRelSize,
_hiLoChartOpenValuesFontRelSize );
// the OpenValuesColor element
KDXML::createColorNode( doc, hiLoSettingsElement, "OpenValuesColor",
_hiLoChartOpenValuesColor );
// the PrintCloseValues element
KDXML::createBoolNode( doc, hiLoSettingsElement, "PrintCloseValues",
_hiLoChartPrintCloseValues );
// the CloseValuesFont element
createChartFontNode( doc, hiLoSettingsElement, "CloseValuesFont",
_hiLoChartCloseValuesFont,
_hiLoChartCloseValuesUseFontRelSize,
_hiLoChartCloseValuesFontRelSize );
// the CloseValuesColor element
KDXML::createColorNode( doc, hiLoSettingsElement, "CloseValuesColor",
_hiLoChartCloseValuesColor );
}
// the BoxAndWhiskerSettings element
TQDomElement bWSettingsElement =
doc.createElement( "BoxAndWhiskerSettings" );
docRoot.appendChild( bWSettingsElement );
{
// the SubType element
KDXML::createStringNode( doc, bWSettingsElement, "SubType",
KDChartParams::bWChartSubTypeToString( _BWChartSubType ) );
// the fences elements
KDXML::createDoubleNode( doc, bWSettingsElement, "FenceUpperInner",
_BWChartFenceUpperInner );
KDXML::createDoubleNode( doc, bWSettingsElement, "FenceLowerInner",
_BWChartFenceLowerInner );
KDXML::createDoubleNode( doc, bWSettingsElement, "FenceUpperOuter",
_BWChartFenceUpperInner );
KDXML::createDoubleNode( doc, bWSettingsElement, "FenceLowerOuter",
_BWChartFenceLowerOuter );
// the brush to be used
KDXML::createBrushNode( doc, bWSettingsElement, "Brush",
_BWChartBrush );
// the size of the outlier markers
KDXML::createIntNode( doc, bWSettingsElement, "OutlierSize",
_BWChartOutValMarkerSize );
// the PrintStatistics elements
for( int i = BWStatValSTART; i <= BWStatValEND; ++i ){
TQDomElement printStatElement =
doc.createElement( "PrintStatistics"+bWChartStatValToString( (BWStatVal)i ) );
KDXML::createBoolNode( doc, printStatElement, "Active",
_BWChartStatistics[ i ].active );
createChartFontNode( doc, printStatElement, "Font",
_BWChartStatistics[ i ].font,
_BWChartStatistics[ i ].useRelSize,
_BWChartStatistics[ i ].relSize );
KDXML::createColorNode( doc, printStatElement, "Color",
_BWChartStatistics[ i ].color );
KDXML::createBrushNode( doc, printStatElement, "Brush",
_BWChartStatistics[ i ].brush );
}
}
// the PolarSettings element
TQDomElement polarSettingsElement =
doc.createElement( "PolarSettings" );
docRoot.appendChild( polarSettingsElement );
{
// the SubType element
KDXML::createStringNode( doc, polarSettingsElement,
"SubType", KDChartParams::polarChartSubTypeToString( _polarChartSubType ) );
// the Marker element
KDXML::createBoolNode( doc, polarSettingsElement,
"Marker", _polarMarker );
// the MarkerStyles elements
for( TQMap<uint,KDChartParams::PolarMarkerStyle>::ConstIterator it = _polarMarkerStyles.begin();
it != _polarMarkerStyles.end(); ++it ) {
TQDomElement markerStyleElement = doc.createElement( "MarkerStyle" );
polarSettingsElement.appendChild( markerStyleElement );
markerStyleElement.setAttribute( "Dataset", it.key() );
markerStyleElement.setAttribute( "Style", KDChartParams::polarMarkerStyleToString( it.data() ) );
}
// the MarkerSize element
KDXML::createSizeNode( doc, polarSettingsElement,
"MarkerSize", _polarMarkerSize );
// the PolarLineWidth element
KDXML::createIntNode( doc, polarSettingsElement,
"PolarLineWidth", _polarLineWidth );
}
// the LegendSettings element
TQDomElement legendSettingsElement =
doc.createElement( "LegendSettings" );
docRoot.appendChild( legendSettingsElement );
{
// the Position element
KDXML::createStringNode( doc, legendSettingsElement, "Position",
KDChartParams::legendPositionToString( _legendPosition ) );
// the Qt::Orientation element
KDXML::createOrientationNode( doc, legendSettingsElement,
"Orientation", _legendOrientation );
// the ShowLines element
KDXML::createBoolNode( doc, legendSettingsElement,
"ShowLines", _legendShowLines );
// the Source element
KDXML::createStringNode( doc, legendSettingsElement, "Source",
KDChartParams::legendSourceToString( _legendSource ) );
// the Text elements
for( TQMap<int,TQString>::ConstIterator it = _legendText.begin();
it != _legendText.end(); ++it ) {
TQDomElement legendTextElement = doc.createElement( "LegendText" );
legendSettingsElement.appendChild( legendTextElement );
legendTextElement.setAttribute( "Dataset", it.key() );
legendTextElement.setAttribute( "Text", it.data() );
}
// the TextColor element
KDXML::createColorNode( doc, legendSettingsElement, "TextColor",
_legendTextColor );
// the TextFont element
createChartFontNode( doc, legendSettingsElement, "TextFont",
_legendFont,
_legendFontUseRelSize,
_legendFontRelSize );
// the TitleText element
KDXML::createStringNode( doc, legendSettingsElement, "TitleText",
_legendTitleText );
// the TitleColor element
KDXML::createColorNode( doc, legendSettingsElement, "TitleColor",
_legendTitleTextColor );
// the TitleFont element
createChartFontNode( doc, legendSettingsElement, "TitleFont",
_legendTitleFont,
_legendTitleFontUseRelSize,
_legendTitleFontRelSize );
// the Spacing element
KDXML::createIntNode( doc, legendSettingsElement, "Spacing",
_legendSpacing );
}
saveAxesToXML(doc, docRoot);
// the HeaderFooterSettings elements
for( int hf = 0; hf < 18; hf++ ) {
TQDomElement hfSettingsElement =
doc.createElement( "HeaderFooterSettings" );
docRoot.appendChild( hfSettingsElement );
{
KDXML::createStringNode( doc, hfSettingsElement, "Text",
_hdFtParams[hf]._text );
createChartFontNode( doc, hfSettingsElement, "Font",
_hdFtParams[hf]._font,
_hdFtParams[hf]._fontUseRelSize,
_hdFtParams[hf]._fontRelSize );
KDXML::createColorNode( doc, hfSettingsElement, "Color",
_hdFtParams[hf]._color );
}
}
// the GlobalLeading element
TQDomElement globalLeadingElement =
doc.createElement( "GlobalLeading" );
docRoot.appendChild( legendSettingsElement );
{
KDXML::createIntNode( doc, globalLeadingElement, "Left",
_globalLeadingLeft );
KDXML::createIntNode( doc, globalLeadingElement, "Top",
_globalLeadingTop );
KDXML::createIntNode( doc, globalLeadingElement, "Right",
_globalLeadingRight );
KDXML::createIntNode( doc, globalLeadingElement, "Bottom",
_globalLeadingBottom );
}
// the DataValuesSettings1 element
TQDomElement dataValuesSettings1Element =
doc.createElement( "DataValuesSettings1" );
docRoot.appendChild( dataValuesSettings1Element );
{
KDXML::createBoolNode( doc, dataValuesSettings1Element, "PrintDataValues",
_printDataValuesSettings._printDataValues );
KDXML::createIntNode( doc, dataValuesSettings1Element, "DivPow10",
_printDataValuesSettings._divPow10 );
KDXML::createIntNode( doc, dataValuesSettings1Element, "DigitsBehindComma",
_printDataValuesSettings._digitsBehindComma );
createChartFontNode( doc, dataValuesSettings1Element, "Font",
_printDataValuesSettings._dataValuesFont,
_printDataValuesSettings._dataValuesUseFontRelSize,
_printDataValuesSettings._dataValuesFontRelSize );
KDXML::createColorNode( doc, dataValuesSettings1Element, "Color",
_printDataValuesSettings._dataValuesColor );
KDXML::createBrushNode( doc, dataValuesSettings1Element, "Background",
_printDataValuesSettings._dataValuesBrush );
KDXML::createBoolNode( doc, dataValuesSettings1Element, "AutoColor",
_printDataValuesSettings._dataValuesAutoColor );
KDXML::createStringNode( doc, dataValuesSettings1Element,
"AnchorNegativePosition",
KDChartEnums::positionFlagToString( _printDataValuesSettings._dataValuesAnchorNegativePosition ) );
KDXML::createIntNode( doc, dataValuesSettings1Element,
"AnchorNegativeAlign",
_printDataValuesSettings._dataValuesAnchorNegativeAlign );
KDXML::createIntNode( doc, dataValuesSettings1Element,
"AnchorNegativeDeltaX",
_printDataValuesSettings._dataValuesAnchorNegativeDeltaX );
KDXML::createIntNode( doc, dataValuesSettings1Element,
"AnchorNegativeDeltaY",
_printDataValuesSettings._dataValuesAnchorNegativeDeltaY );
KDXML::createIntNode( doc, dataValuesSettings1Element,
"NegativeRotation",
_printDataValuesSettings._dataValuesNegativeRotation );
KDXML::createStringNode( doc, dataValuesSettings1Element,
"AnchorPositivePosition",
KDChartEnums::positionFlagToString( _printDataValuesSettings._dataValuesAnchorPositivePosition ) );
KDXML::createIntNode( doc, dataValuesSettings1Element,
"AnchorPositiveAlign",
_printDataValuesSettings._dataValuesAnchorPositiveAlign );
KDXML::createIntNode( doc, dataValuesSettings1Element,
"AnchorPositiveDeltaX",
_printDataValuesSettings._dataValuesAnchorPositiveDeltaX );
KDXML::createIntNode( doc, dataValuesSettings1Element,
"AnchorPositiveDeltaY",
_printDataValuesSettings._dataValuesAnchorPositiveDeltaY );
KDXML::createIntNode( doc, dataValuesSettings1Element,
"PositiveRotation",
_printDataValuesSettings._dataValuesPositiveRotation );
KDXML::createStringNode( doc, dataValuesSettings1Element,
"LayoutPolicy",
KDChartEnums::layoutPolicyToString( _printDataValuesSettings._dataValuesLayoutPolicy ) );
KDXML::createBoolNode( doc, dataValuesSettings1Element, "ShowInfinite",
_printDataValuesSettings._dataValuesShowInfinite );
}
// the DataValuesSettings2 element
TQDomElement dataValuesSettings2Element =
doc.createElement( "DataValuesSettings2" );
docRoot.appendChild( dataValuesSettings2Element );
{
KDXML::createBoolNode( doc, dataValuesSettings2Element, "PrintDataValues",
_printDataValuesSettings2._printDataValues );
KDXML::createIntNode( doc, dataValuesSettings2Element, "DivPow10",
_printDataValuesSettings2._divPow10 );
KDXML::createIntNode( doc, dataValuesSettings2Element, "DigitsBehindComma",
_printDataValuesSettings2._digitsBehindComma );
createChartFontNode( doc, dataValuesSettings2Element, "Font",
_printDataValuesSettings2._dataValuesFont,
_printDataValuesSettings2._dataValuesUseFontRelSize,
_printDataValuesSettings2._dataValuesFontRelSize );
KDXML::createColorNode( doc, dataValuesSettings2Element, "Color",
_printDataValuesSettings2._dataValuesColor );
KDXML::createBrushNode( doc, dataValuesSettings2Element, "Background",
_printDataValuesSettings2._dataValuesBrush );
KDXML::createBoolNode( doc, dataValuesSettings2Element, "AutoColor",
_printDataValuesSettings2._dataValuesAutoColor );
KDXML::createStringNode( doc, dataValuesSettings2Element,
"AnchorNegativePosition",
KDChartEnums::positionFlagToString( _printDataValuesSettings2._dataValuesAnchorNegativePosition ) );
KDXML::createIntNode( doc, dataValuesSettings2Element,
"AnchorNegativeAlign",
_printDataValuesSettings2._dataValuesAnchorNegativeAlign );
KDXML::createIntNode( doc, dataValuesSettings2Element,
"AnchorNegativeDeltaX",
_printDataValuesSettings2._dataValuesAnchorNegativeDeltaX );
KDXML::createIntNode( doc, dataValuesSettings2Element,
"AnchorNegativeDeltaY",
_printDataValuesSettings2._dataValuesAnchorNegativeDeltaY );
KDXML::createIntNode( doc, dataValuesSettings2Element,
"NegativeRotation",
_printDataValuesSettings2._dataValuesNegativeRotation );
KDXML::createStringNode( doc, dataValuesSettings2Element,
"AnchorPositivePosition",
KDChartEnums::positionFlagToString( _printDataValuesSettings2._dataValuesAnchorPositivePosition ) );
KDXML::createIntNode( doc, dataValuesSettings2Element,
"AnchorPositiveAlign",
_printDataValuesSettings2._dataValuesAnchorPositiveAlign );
KDXML::createIntNode( doc, dataValuesSettings2Element,
"AnchorPositiveDeltaX",
_printDataValuesSettings2._dataValuesAnchorPositiveDeltaX );
KDXML::createIntNode( doc, dataValuesSettings2Element,
"AnchorPositiveDeltaY",
_printDataValuesSettings2._dataValuesAnchorPositiveDeltaY );
KDXML::createIntNode( doc, dataValuesSettings2Element,
"PositiveRotation",
_printDataValuesSettings2._dataValuesPositiveRotation );
KDXML::createStringNode( doc, dataValuesSettings2Element,
"LayoutPolicy",
KDChartEnums::layoutPolicyToString( _printDataValuesSettings2._dataValuesLayoutPolicy ) );
KDXML::createBoolNode( doc, dataValuesSettings2Element, "ShowInfinite",
_printDataValuesSettings2._dataValuesShowInfinite );
}
// global settings for data value settings of _all_ charts
TQDomElement dataValuesGlobalSettingsElement =
doc.createElement( "DataValuesGlobalSettings" );
docRoot.appendChild( dataValuesGlobalSettingsElement );
{
KDXML::createBoolNode( doc, dataValuesGlobalSettingsElement,
"allowOverlappingTexts",
_allowOverlappingDataValueTexts );
}
// the AreaMap element
TQDomElement areaMapElement =
doc.createElement( "AreaMap" );
docRoot.appendChild( areaMapElement );
{
TQDictIterator<KDChartFrameSettings> it( _areaDict );
for( ; it.current(); ++it ){
KDChartFrameSettings::createFrameSettingsNode( doc, areaMapElement,
"FrameSettings",
it.current(),
it.currentKey().left(5).stripWhiteSpace().toUInt() );
}
}
// the CustomBoxMap element
TQDomElement customBoxMapElement =
doc.createElement( "CustomBoxMap" );
docRoot.appendChild( customBoxMapElement );
{
TQIntDictIterator<KDChartCustomBox> it( _customBoxDict );
for( ; it.current(); ++it ){
KDXML::createIntNode( doc, customBoxMapElement, "Number", it.currentKey() );
KDChartCustomBox::createCustomBoxNode( doc, customBoxMapElement,
"CustomBox", it );
}
}
return doc;
}
/**
\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<uint,TQColor>* map = &_dataColors;
readColorMapNode( element, map );
} else if( tagName == "MaxDatasetColor" ) {
int maxDatasetColor;
if( KDXML::readIntNode( element, maxDatasetColor ) )
_maxDatasetColor = maxDatasetColor;
} else if( tagName == "ShadowBrightnessFactor" ) {
double shadowBrightnessFactor;
if( KDXML::readDoubleNode( element, shadowBrightnessFactor ) )
_shadowBrightnessFactor = shadowBrightnessFactor;
} else if( tagName == "ShadowPattern" ) {
TQString value;
if( KDXML::readStringNode( element, value ) )
_shadowPattern = KDXML::stringToBrushStyle( value );
} else if( tagName == "ThreeDShadowColors" ) {
bool threeDShadowColors;
if( KDXML::readBoolNode( element, threeDShadowColors ) )
_threeDShadowColors = threeDShadowColors;
} else if( tagName == "DataColorsShadow1" ) {
TQMap<uint,TQColor>* map = &_dataColorsShadow1;
readColorMapNode( element, map );
} else if( tagName == "DataColorsShadow2" ) {
TQMap<uint,TQColor>* map = &_dataColorsShadow2;
readColorMapNode( element, map );
} else if( tagName == "OutlineDataColor" ) {
TQColor color;
if( KDXML::readColorNode( element, color ) )
_outlineDataColor = color;
} else if( tagName == "OutlineDataLineWidth" ) {
int outlineDataLineWidth;
if( KDXML::readIntNode( element, outlineDataLineWidth ) )
_outlineDataLineWidth = outlineDataLineWidth;
} else if( tagName == "OutlineDataLineStyle" ) {
if( element.hasAttribute( "Style" ) )
_outlineDataLineStyle = KDXML::stringToPenStyle( element.attribute( "Style" ) );
} else {
tqDebug( "!!!Unknown subelement of ColorSettings found: %s", tagName.latin1() );
}
}
node = node.nextSibling();
}
} else if( tagName == "BarSettings" ) {
TQDomNode node = element.firstChild();
while( !node.isNull() ) {
TQDomElement element = node.toElement();
if( !element.isNull() ) { // was really an element
TQString tagName = element.tagName();
if( tagName == "SubType" ) {
TQString value;
if( KDXML::readStringNode( element, value ) )
_barChartSubType = KDChartParams::stringToBarChartSubType( value );
} else if( tagName == "ThreeDBars" ) {
bool threeDBars;
if( KDXML::readBoolNode( element, threeDBars ) )
_threeDBars = threeDBars;
} else if( tagName == "ThreeDBarDepth" ) {
double threeDBarDepth;
if( KDXML::readDoubleNode( element, threeDBarDepth ) )
_threeDBarDepth = threeDBarDepth;
} else if( tagName == "DatasetGap" ) {
int datasetGap;
if( KDXML::readIntNode( element, datasetGap ) )
_datasetGap = datasetGap;
} else if( tagName == "DatasetGapIsRelative" ) {
bool datasetGapIsRelative;
if( KDXML::readBoolNode( element, datasetGapIsRelative ) )
_datasetGapIsRelative = datasetGapIsRelative;
} else if( tagName == "ValueBlockGap" ) {
int valueBlockGap;
if( KDXML::readIntNode( element, valueBlockGap ) )
_valueBlockGap = valueBlockGap;
} else if( tagName == "ValueBlockGapIsRelative" ) {
bool valueBlockGapIsRelative;
if( KDXML::readBoolNode( element, valueBlockGapIsRelative ) )
_valueBlockGapIsRelative = valueBlockGapIsRelative;
} else if( tagName == "BarWidth" ) {
int barWidth;
if( KDXML::readIntNode( element, barWidth ) )
_barWidth = barWidth;
} else if( tagName == "SolidExcessArrows" ) {
bool solidExcessArrows;
if( KDXML::readBoolNode( element, solidExcessArrows ) )
_solidExcessArrows = solidExcessArrows;
} else {
tqDebug( "Unknown subelement of BarSettings found: %s", tagName.latin1() );
}
}
node = node.nextSibling();
}
} else if( tagName == "LineSettings" ) {
TQDomNode node = element.firstChild();
while( !node.isNull() ) {
TQDomElement element = node.toElement();
if( !element.isNull() ) { // was really an element
TQString tagName = element.tagName();
if( tagName == "SubType" ) {
TQString value;
if( KDXML::readStringNode( element, value ) )
_lineChartSubType = KDChartParams::stringToLineChartSubType( value );
} else if( tagName == "Marker" ) {
bool marker;
if( KDXML::readBoolNode( element, marker ) )
_lineMarker = marker;
} else if( tagName == "MarkerStyle" ) {
bool ok = true;
uint dataset;
KDChartParams::LineMarkerStyle style = LineMarkerCircle;
if( element.hasAttribute( "Dataset" ) &&
element.hasAttribute( "Style" ) ) {
dataset = element.attribute( "Dataset" ).toUInt( &ok );
if( ok )
style = KDChartParams::stringToLineMarkerStyle( element.attribute( "Style" ) );
} else
ok = false;
if( ok )
_lineMarkerStyles[dataset] = style;
} else if( tagName == "MarkerSize" ) {
int width = 1;
int height= 1;
bool ok = true;
if( element.hasAttribute( "Width" ) &&
element.hasAttribute( "Height" ) ) {
width = element.attribute( "Width" ).toInt( &ok );
if( ok )
height = element.attribute( "Height" ).toInt( &ok );
} else
ok = false;
if( ok ) {
_lineMarkerSize.setWidth( width );
_lineMarkerSize.setHeight( height );
}
} else if( tagName == "LineWidth" ) {
int lineWidth;
if( KDXML::readIntNode( element, lineWidth ) )
_lineWidth = lineWidth;
} else if( tagName == "LineColor" ) {
TQColor color;
if( KDXML::readColorNode( element, color ) )
_lineColor = color;
} else if( tagName == "LineStyle" ) {
if( element.hasAttribute( "Style" ) )
_lineStyle = KDXML::stringToPenStyle( element.attribute( "Style" ) );
} else if( tagName == "DatasetLineStyle" ) {
bool ok = true;
uint dataset;
Qt::PenStyle style = Qt::SolidLine;
if( element.hasAttribute( "Dataset" ) &&
element.hasAttribute( "Style" ) ) {
dataset = element.attribute( "Dataset" ).toUInt( &ok );
if( ok )
style = KDXML::stringToPenStyle( element.attribute( "Style" ) );
} else
ok = false;
if( ok )
_datasetLineStyles[dataset] = style;
} else if( tagName == "ThreeD" ) {
bool threeD;
if( KDXML::readBoolNode( element, threeD ) )
_threeDLines = threeD;
} else if( tagName == "ThreeDDepth" ) {
int depth;
if( KDXML::readIntNode( element, depth ) )
_threeDLineDepth = depth;
} else if( tagName == "ThreeDXRotation" ) {
int rotation;
if( KDXML::readIntNode( element, rotation ) )
_threeDLineXRotation = rotation;
} else if( tagName == "ThreeDYRotation" ) {
int rotation;
if( KDXML::readIntNode( element, rotation ) )
_threeDLineYRotation = rotation;
} else {
tqDebug( "Unknown subelement of LineSettings found: %s", tagName.latin1() );
}
}
node = node.nextSibling();
}
} else if( tagName == "AreaSettings" ) {
TQDomNode node = element.firstChild();
while( !node.isNull() ) {
TQDomElement element = node.toElement();
if( !element.isNull() ) { // was really an element
TQString tagName = element.tagName();
if( tagName == "SubType" ) {
TQString value;
if( KDXML::readStringNode( element, value ) )
_areaChartSubType = KDChartParams::stringToAreaChartSubType( value );
} else if( tagName == "Location" ) {
TQString string;
if( KDXML::readStringNode( element, string ) )
_areaLocation = KDChartParams::stringToAreaLocation( string );
} else {
tqDebug( "Unknown subelement of AreaSettings found: %s", tagName.latin1() );
}
}
node = node.nextSibling();
}
} else if( tagName == "PieRingSettings" ) {
TQDomNode node = element.firstChild();
while( !node.isNull() ) {
TQDomElement element = node.toElement();
if( !element.isNull() ) { // was really an element
TQString tagName = element.tagName();
if( tagName == "Explode" ) {
bool explode;
if( KDXML::readBoolNode( element, explode ) )
_explode = explode;
} else if( tagName == "DefaultExplodeFactor" ) {
double defaultExplodeFactor;
if( KDXML::readDoubleNode( element, defaultExplodeFactor ) )
_explodeFactor = defaultExplodeFactor;
} else if( tagName == "ExplodeFactors" ) {
TQMap<int,double>* map = &_explodeFactors;
readDoubleMapNode( element, map );
} else if( tagName == "ExplodeSegment" ) {
int explodeSegment;
if( KDXML::readIntNode( element, explodeSegment ) )
_explodeList << explodeSegment;
} else if( tagName == "ThreeDPies" ) {
bool threeDPies;
if( KDXML::readBoolNode( element, threeDPies ) )
_threeDPies = threeDPies;
} else if( tagName == "ThreeDPieHeight" ) {
int threeDPieHeight;
if( KDXML::readIntNode( element, threeDPieHeight ) )
_threeDPieHeight = threeDPieHeight;
} else if( tagName == "PieStart" ) {
int pieStart;
if( KDXML::readIntNode( element, pieStart ) )
_pieStart = pieStart;
} else if( tagName == "RingStart" ) {
int ringStart;
if( KDXML::readIntNode( element, ringStart ) )
_ringStart = ringStart;
} else if( tagName == "RelativeRingThickness" ) {
bool relativeRingThickness;
if( KDXML::readBoolNode( element, relativeRingThickness ) )
_relativeRingThickness = relativeRingThickness;
} else {
tqDebug( "Unknown subelement of PieRingSettings found: %s", tagName.latin1() );
}
}
node = node.nextSibling();
}
} else if( tagName == "HiLoSettings" ) {
TQDomNode node = element.firstChild();
while( !node.isNull() ) {
TQDomElement element = node.toElement();
if( !element.isNull() ) { // was really an element
TQString tagName = element.tagName();
if( tagName == "SubType" ) {
TQString value;
if( KDXML::readStringNode( element, value ) )
_hiLoChartSubType = KDChartParams::stringToHiLoChartSubType( value );
} else if( tagName == "PrintLowValues" ) {
bool printLowValues;
if( KDXML::readBoolNode( element, printLowValues ) )
_hiLoChartPrintLowValues = printLowValues;
} else if( tagName == "LowValuesFont" ) {
readChartFontNode( element,
_hiLoChartLowValuesFont,
_hiLoChartLowValuesUseFontRelSize,
_hiLoChartLowValuesFontRelSize );
} else if( tagName == "LowValuesColor" ) {
TQColor color;
if( KDXML::readColorNode( element, color ) )
_hiLoChartLowValuesColor = color;
} else if( tagName == "PrintHighValues" ) {
bool printHighValues;
if( KDXML::readBoolNode( element, printHighValues ) )
_hiLoChartPrintHighValues = printHighValues;
} else if( tagName == "HighValuesFont" ) {
readChartFontNode( element,
_hiLoChartHighValuesFont,
_hiLoChartHighValuesUseFontRelSize,
_hiLoChartHighValuesFontRelSize );
} else if( tagName == "HighValuesColor" ) {
TQColor color;
if( KDXML::readColorNode( element, color ) )
_hiLoChartHighValuesColor = color;
} else if( tagName == "PrintOpenValues" ) {
bool printOpenValues;
if( KDXML::readBoolNode( element, printOpenValues ) )
_hiLoChartPrintOpenValues = printOpenValues;
} else if( tagName == "OpenValuesFont" ) {
readChartFontNode( element,
_hiLoChartOpenValuesFont,
_hiLoChartOpenValuesUseFontRelSize,
_hiLoChartOpenValuesFontRelSize );
} else if( tagName == "OpenValuesColor" ) {
TQColor color;
if( KDXML::readColorNode( element, color ) )
_hiLoChartOpenValuesColor = color;
} else if( tagName == "PrintCloseValues" ) {
bool printCloseValues;
if( KDXML::readBoolNode( element, printCloseValues ) )
_hiLoChartPrintCloseValues = printCloseValues;
} else if( tagName == "CloseValuesFont" ) {
readChartFontNode( element,
_hiLoChartCloseValuesFont,
_hiLoChartCloseValuesUseFontRelSize,
_hiLoChartCloseValuesFontRelSize );
} else if( tagName == "CloseValuesColor" ) {
TQColor color;
if( KDXML::readColorNode( element, color ) )
_hiLoChartCloseValuesColor = color;
} else {
tqDebug( "Unknown subelement of HiLoSettings found: %s", tagName.latin1() );
}
}
node = node.nextSibling();
}
} else if( tagName == "BoxAndWhiskerSettings" ) {
TQDomNode node = element.firstChild();
while( !node.isNull() ) {
TQDomElement element = node.toElement();
if( !element.isNull() ) { // was really an element
TQString tagName = element.tagName();
if( tagName == "SubType" ) {
TQString value;
if( KDXML::readStringNode( element, value ) )
_BWChartSubType = KDChartParams::stringToBWChartSubType( value );
} else if( tagName == "FenceUpperInner" ) {
double fence;
if( KDXML::readDoubleNode( element, fence ) )
_BWChartFenceUpperInner = fence;
} else if( tagName == "FenceLowerInner" ) {
double fence;
if( KDXML::readDoubleNode( element, fence ) )
_BWChartFenceUpperOuter = fence;
} else if( tagName == "FenceUpperOuter" ) {
double fence;
if( KDXML::readDoubleNode( element, fence ) )
_BWChartFenceUpperOuter = fence;
} else if( tagName == "FenceLowerOuter" ) {
double fence;
if( KDXML::readDoubleNode( element, fence ) )
_BWChartFenceUpperOuter = fence;
} else if( tagName == "Brush" ) {
TQBrush brush;
if( KDXML::readBrushNode( element, brush ) )
_BWChartBrush = brush;
} else if( tagName == "OutlierSize" ) {
int size;
if( KDXML::readIntNode( element, size ) )
_BWChartOutValMarkerSize = size;
} else if( tagName.startsWith("PrintStatistics") ) {
// 012345678901234
TQString statName(tagName.mid( 15 ));
BWStatVal i( stringToBWChartStatVal( statName ) );
if( BWStatValSTART <= i && i <= BWStatValEND ) {
TQDomNode node = element.firstChild();
while( !node.isNull() ) {
TQDomElement element = node.toElement();
if( !element.isNull() ) { // was really an element
TQString tagName = element.tagName();
if( tagName == "Active" ) {
bool active;
if( KDXML::readBoolNode( element, active ) )
_BWChartStatistics[ i ].active = active;
} else if( tagName == "Font" ) {
readChartFontNode( element,
_BWChartStatistics[ i ].font,
_BWChartStatistics[ i ].useRelSize,
_BWChartStatistics[ i ].relSize );
} else if( tagName == "Color" ) {
TQColor color;
if( KDXML::readColorNode( element, color ) )
_BWChartStatistics[ i ].color = color;
} else if( tagName == "Brush" ) {
TQBrush brush;
if( KDXML::readBrushNode( element, brush ) )
_BWChartStatistics[ i ].brush = brush;
} else {
tqDebug( "Unknown subelement of BoxAndWhiskerSettings found: %s", tagName.latin1() );
}
}
}
} else {
tqDebug( "Unknown subelement of BoxAndWhiskerSettings found: %s", tagName.latin1() );
}
} else {
tqDebug( "Unknown subelement of BoxAndWhiskerSettings found: %s", tagName.latin1() );
}
}
node = node.nextSibling();
}
} else if( tagName == "PolarSettings" ) {
TQDomNode node = element.firstChild();
while( !node.isNull() ) {
TQDomElement element = node.toElement();
if( !element.isNull() ) { // was really an element
TQString tagName = element.tagName();
if( tagName == "SubType" ) {
TQString value;
if( KDXML::readStringNode( element, value ) )
_polarChartSubType = KDChartParams::stringToPolarChartSubType( value );
} else if( tagName == "Marker" ) {
bool marker;
if( KDXML::readBoolNode( element, marker ) )
_polarMarker = marker;
} else if( tagName == "MarkerStyle" ) {
bool ok = true;
uint dataset;
KDChartParams::PolarMarkerStyle style = PolarMarkerCircle;
if( element.hasAttribute( "Dataset" ) &&
element.hasAttribute( "Style" ) ) {
dataset = element.attribute( "Dataset" ).toUInt( &ok );
if( ok )
style = KDChartParams::stringToPolarMarkerStyle( element.attribute( "Style" ) );
} else
ok = false;
if( ok )
_polarMarkerStyles[dataset] = style;
} else if( tagName == "MarkerSize" ) {
int width = 1;
int height= 1;
bool ok = true;
if( element.hasAttribute( "Width" ) &&
element.hasAttribute( "Height" ) ) {
width = element.attribute( "Width" ).toInt( &ok );
if( ok )
height = element.attribute( "Height" ).toInt( &ok );
} else
ok = false;
if( ok ) {
_polarMarkerSize.setWidth( width );
_polarMarkerSize.setHeight( height );
}
} else if( tagName == "PolarLineWidth" ) {
int polarLineWidth;
if( KDXML::readIntNode( element, polarLineWidth ) )
_polarLineWidth = polarLineWidth;
} else {
tqDebug( "Unknown subelement of PolarSettings found: %s", tagName.latin1() );
}
}
node = node.nextSibling();
}
} else if( tagName == "LegendSettings" ) {
TQDomNode node = element.firstChild();
while( !node.isNull() ) {
TQDomElement element = node.toElement();
if( !element.isNull() ) { // was really an element
TQString tagName = element.tagName();
if( tagName == "Position" ) {
TQString string;
if( KDXML::readStringNode( element, string ) )
_legendPosition = KDChartParams::stringToLegendPosition( string );
} else if( tagName == "Orientation" ) {
Qt::Orientation value=Qt::Vertical;
if( KDXML::readOrientationNode( element, value ) )
_legendOrientation = value;
} else if( tagName == "ShowLines" ) {
bool showLines;
if( KDXML::readBoolNode( element, showLines ) )
_legendShowLines = showLines;
} else if( tagName == "Source" ) {
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<uint,TQColor>::ConstIterator it = map.begin();
it != map.end(); ++it ) {
// Dataset element
TQDomElement datasetElement = doc.createElement( "Dataset" );
mapElement.appendChild( datasetElement );
TQDomText datasetContent =
doc.createTextNode( TQString::number( it.key() ) );
datasetElement.appendChild( datasetContent );
// Color element
KDXML::createColorNode( doc, mapElement, "Color", it.data() );
}
}
/**
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<int,double>::ConstIterator it = map.begin();
it != map.end(); ++it ) {
// Dataset element
TQDomElement valueElement = doc.createElement( "Value" );
mapElement.appendChild( valueElement );
TQDomText valueContent =
doc.createTextNode( TQString::number( it.key() ) );
valueElement.appendChild( valueContent );
// Color element
KDXML::createDoubleNode( doc, mapElement, "Factor", it.data() );
}
}
void dataCoordToElementAttr(const TQVariant& val, TQDomElement& element, const TQString& postfix)
{
if( TQVariant::Double == val.type() )
element.setAttribute( "DoubleValue"+postfix,
TQString::number( val.toDouble() ) );
else if( TQVariant::String == val.type() )
element.setAttribute( "StringValue"+postfix, val.toString() );
else if( TQVariant::DateTime == val.type() )
element.setAttribute( "DateTimeValue"+postfix,
val.toDateTime().toString( Qt::ISODate ) );
else
element.setAttribute( "NoValue"+postfix, "true" );
}
/**
Creates a DOM element node that represents a
chart value for use in a DOM document.
\param doc the DOM document to which the node will belong
\param parent the parent node to which the new node will be appended
\param elementName the name of the new node
\param data the chart value to be represented
*/
void KDChartParams::createChartValueNode( 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<uint,TQColor>* value )
{
TQDomNode node = element.firstChild();
int curDataset = -1;
while( !node.isNull() ) {
TQDomElement element = node.toElement();
if( !element.isNull() ) { // was really an element
TQString tagName = element.tagName();
if( tagName == "Dataset" ) {
KDXML::readIntNode( element, curDataset );
} else if( tagName == "Color" ) {
Q_ASSERT( curDataset != -1 ); // there was a Dataset tag before
TQColor color;
KDXML::readColorNode( element, color );
value->insert( curDataset, color );
} else {
tqDebug( "Unknown tag in color map" );
}
}
node = node.nextSibling();
}
return true;
}
/**
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<int,double>* value )
{
TQDomNode node = element.firstChild();
int curValue = -1;
while( !node.isNull() ) {
TQDomElement element = node.toElement();
if( !element.isNull() ) { // was really an element
TQString tagName = element.tagName();
if( tagName == "Value" ) {
KDXML::readIntNode( element, curValue );
} else if( tagName == "Factor" ) {
Q_ASSERT( curValue != -1 ); // there was a Value tag before
double doubleValue;
KDXML::readDoubleNode( element, doubleValue );
value->insert( curValue, doubleValue );
} else {
tqDebug( "Unknown tag in double map" );
}
}
node = node.nextSibling();
}
return true;
}
/**
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<KDChartParams::LineMarkerStyle>(stringToMarkerStyle( string ));
}
/**
Converts the specified localized string to a line marker style
value.
\param string the string to convert
\return the line marker style enum value
*/
KDChartParams::LineMarkerStyle KDChartParams::stringToLineMarkerStyleTr( const TQString& string )
{
return static_cast<KDChartParams::LineMarkerStyle>(stringToMarkerStyleTr( string ));
}
/**
Converts the specified area chart subtype enum to a string representation.
\param type the subtype enum to convert
\return the string representation of the type enum
*/
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<KDChartParams::PolarMarkerStyle>(stringToMarkerStyle( string ));
}
/**
Converts the specified localized string to a polar marker style
value.
\param string the string to convert
\return the polar marker style enum value
*/
KDChartParams::PolarMarkerStyle KDChartParams::stringToPolarMarkerStyleTr( const TQString& string )
{
return static_cast<KDChartParams::PolarMarkerStyle>(stringToMarkerStyle( string ));
}
/**
Converts the specified HiLo chart subtype enum to a string representation.
\param type the subtype enum to convert
\return the string representation of the type enum
*/
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";
}
}