You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
3319 lines
104 KiB
3319 lines
104 KiB
/* -*- Mode: C++ -*-
|
|
KDChart - a multi-platform charting engine
|
|
*/
|
|
|
|
/****************************************************************************
|
|
** Copyright (C) 2001-2003 Klarävdalens 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 <KDChartAxisParams.h>
|
|
#ifndef KDCHART_MASTER_CVS
|
|
#include "KDChartAxisParams.moc"
|
|
#endif
|
|
|
|
|
|
/**
|
|
\class KDChartAxisParams KDChartAxisParams.h
|
|
\brief access the chart axis parameters.
|
|
|
|
To be used in combination with the axis access methods in
|
|
class KDChartParams.
|
|
|
|
|
|
\see KDChartParams.h
|
|
\see KDChartParams.cpp
|
|
|
|
Bundles all parameters of one axis including the type except the
|
|
actual data displayed. Serializing an object of this type plus the
|
|
data displayed is enough to be able to recreate the chart later.
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
\c enum KDChartAxisParams::Axistype { AxisTypeUnknown,
|
|
AxisTypeEAST,
|
|
AxisTypeNORTH,
|
|
AxisUP };
|
|
|
|
The axis type - the kind of the axis (x-, y- or z-axis).
|
|
|
|
\li \c AxisTypeEAST axis of abscisses, the so-called \em X-axis.
|
|
In world coordinates this is the EAST axis as used
|
|
on topographical maps.
|
|
This axis normally is assigned to the 1st dimension
|
|
of the represented data, to change this use
|
|
KDChartAxesPainter::setAxisAssignment().
|
|
|
|
\li \c AxisTypeNORTH axis of ordinates, the so-called \em Y-axis.
|
|
when are represented by the chart.
|
|
In world coordinates this is the NORTH axis as used
|
|
on topographical maps for 2-dimensional data,
|
|
or the NORTH axis as used on bird's-eys views of
|
|
buildings etc for 3-dimensional data, resp..
|
|
This axis normally is assigned to the 2nd dimension
|
|
of the represented data.
|
|
|
|
\li \c AxisTypeUP axis of the 3rd dimension, the so-called \em Z-axis.
|
|
In world coordinates this is the UP axis as used
|
|
on bird's-eys views of buildings etc.
|
|
This axis normally is assigned to the 3rd dimension
|
|
of the represented data.
|
|
|
|
The following picture shows the default positions of the
|
|
different axes:
|
|
\verbatim
|
|
|
|
+-----------+
|
|
/| |
|
|
n +------------+ / | |
|
|
. | | / | |
|
|
NORTH, y . | 2-dim. | / | |
|
|
. | | / +-----------+
|
|
. | chart | / / / n
|
|
. | | n + / 3-dim. / .
|
|
. | | . | / / . NORTH, y
|
|
. | | UP, z . | / chart / .
|
|
. | | . | / / .
|
|
. | | . |/ / .
|
|
0 +------------+ 0 +-----------+ .
|
|
0
|
|
0............n 0...........n
|
|
EAST, x EAST, x
|
|
\endverbatim
|
|
|
|
\note Normally you will not have to specify the AxisType since it
|
|
will be set automatically in KDChartAxesPainter::setDefaultAxesTypes()
|
|
called by c'tor of class KDChartAxesPainter
|
|
|
|
\sa setAxisType, axisType, KDChartAxesPainter::setAxisAssignment()
|
|
*/
|
|
|
|
|
|
/**
|
|
Constructor. Define default values:
|
|
|
|
- do not show this axis at all,
|
|
- use circa 100 per thousand of the printable area
|
|
size for drawing this axis,
|
|
- calc mode linear,
|
|
- line is visible,
|
|
- line width: 3 per mille of the printable area size
|
|
- line color: black,
|
|
- labels are visible,
|
|
- labels font: helvetica
|
|
- labels font size: 20 / 1000 of the printable area size
|
|
- labels color: black,
|
|
- this axis will be used for an ordinate
|
|
- label value limits will be calculated automatically,
|
|
*/
|
|
KDChartAxisParams::KDChartAxisParams()
|
|
{
|
|
_axisType = AxisTypeUnknown;
|
|
_axisVisible = false;
|
|
_axisAreaMode = AxisAreaModeAutoSize;
|
|
_axisUseAvailableSpaceFrom = 0;
|
|
_axisUseAvailableSpaceTo = -1000;
|
|
_axisAreaMin = -100;
|
|
_axisAreaMax = 0;
|
|
_axisCalcMode = AxisCalcLinear;
|
|
_axisIsoRefAxis = UINT_MAX; // == KDCHART_NO_AXIS, see KDChartParams.cpp
|
|
_axisTrueAreaSize = 0;
|
|
_axisZeroLineStartX = 0.0;
|
|
_axisZeroLineStartY = 0.0;
|
|
_axisDtLowPosX = 0.0;
|
|
_axisDtLowPosY = 0.0;
|
|
_axisDtHighPosX = 0.0;
|
|
_axisDtHighPosY = 0.0;
|
|
|
|
_axisLineWidth = -3; // == 3/1000
|
|
_axisTrueLineWidth = 1;
|
|
_axisLineVisible = true;
|
|
_axisLineColor = TQColor( 0, 0, 0 );
|
|
|
|
_axisShowFractionalValuesDelimiters = true;
|
|
_axisShowGrid = false;
|
|
_axisGridColor = KDCHART_DEFAULT_AXIS_GRID_COLOR;
|
|
_axisGridLineWidth = KDCHART_AXIS_GRID_AUTO_LINEWIDTH;
|
|
_axisGridStyle = Qt::SolidLine;
|
|
|
|
_axisShowSubDelimiters = true;
|
|
_axisGridSubColor = KDCHART_DEFAULT_AXIS_GRID_COLOR;
|
|
_axisGridSubLineWidth = KDCHART_AXIS_GRID_AUTO_LINEWIDTH;
|
|
_axisGridSubStyle = Qt::DotLine;
|
|
|
|
_axisZeroLineColor = TQColor( 0x00, 0x00, 0x80 );
|
|
|
|
_axisLabelsVisible = true;
|
|
_axisLabelsFont = TQFont( "helvetica", 12,
|
|
TQFont::Normal, false );
|
|
_axisLabelsFontUseRelSize = true;
|
|
_axisLabelsFontRelSize = 32;
|
|
_axisLabelsFontMinSize = 6;
|
|
_axisLabelsDontShrinkFont = false;
|
|
_axisLabelsDontAutoRotate = false;
|
|
_axisLabelsRotation = 0;
|
|
_axisLabelsColor = TQColor( 0, 0, 0 );
|
|
|
|
_axisSteadyValueCalc = true;
|
|
_axisValueStartIsExact = true;
|
|
_axisValueStart = KDCHART_AXIS_LABELS_AUTO_LIMIT;
|
|
_axisValueEnd = KDCHART_AXIS_LABELS_AUTO_LIMIT;
|
|
_axisValueDelta = KDCHART_AXIS_LABELS_AUTO_DELTA;
|
|
_axisValueDeltaScale = ValueScaleNumerical;
|
|
_axisValueLeaveOut = KDCHART_AXIS_LABELS_AUTO_LEAVEOUT;
|
|
_axisValuesDecreasing = false;
|
|
|
|
// First we used "h:mm:ss\nd.MM.yyyy" but now we calculate the
|
|
// format automatically - based on the time span to be displayed.
|
|
_axisLabelsDateTimeFormat = KDCHART_AXIS_LABELS_AUTO_DATETIME_FORMAT;
|
|
|
|
_axisMaxEmptyInnerSpan = 90;
|
|
_takeLabelsFromDataRow = LabelsFromDataRowNo;
|
|
_labelTextsDataRow = 0;
|
|
_axisLabelStringList.clear();
|
|
_axisShortLabelsStringList.clear();
|
|
|
|
setAxisLabelTexts( 0 );
|
|
setAxisFirstLabelText();
|
|
setAxisLastLabelText();
|
|
setTrueAxisDeltaPixels( 0.0 );
|
|
setTrueAxisLowHighDelta( 0.0, 0.0, 0.0 );
|
|
setTrueAxisDtLowHighDeltaScale( TQDateTime(), TQDateTime(), ValueScaleDay );
|
|
|
|
_axisLabelsDivPow10 = 0;
|
|
_axisDigitsBehindComma = KDCHART_AXIS_LABELS_AUTO_DIGITS;
|
|
_axisLabelsNotation = KDChartEnums::NumberNotationDecimal;
|
|
_axisLabelsDecimalPoint = ".";
|
|
_axisLabelsThousandsPoint = ",";
|
|
_axisLabelsPrefix = "";
|
|
_axisLabelsPostfix = "";
|
|
_axisLabelsTotalLen = 0;
|
|
_axisLabelsPadFill = ' ';
|
|
_axisLabelsBlockAlign = true;
|
|
}
|
|
|
|
/**
|
|
Destructor. Only defined to have it virtual.
|
|
|
|
*/
|
|
|
|
KDChartAxisParams::~KDChartAxisParams()
|
|
{
|
|
// Intentionally left blank for now.
|
|
}
|
|
|
|
|
|
/**
|
|
Specifies the axis type. The default is unknown (AxisTypeUnknown).
|
|
|
|
\note Normally you will not have to specify the AxisType since it
|
|
will be set automatically in KDChartAxesPainter::setDefaultAxesTypes()
|
|
called by c'tor of class KDChartAxesPainter
|
|
|
|
\param axisType the axis type to use
|
|
\sa axisType, AxisType
|
|
*/
|
|
void KDChartAxisParams::setAxisType( AxisType axisType )
|
|
{
|
|
_axisType = axisType;
|
|
emit changed();
|
|
}
|
|
|
|
/**
|
|
\fn AxisType KDChartAxisParams::axisType() const
|
|
|
|
\return the axis type configured in this params object.
|
|
|
|
\sa setAxisType, AxisType
|
|
*/
|
|
|
|
|
|
/**
|
|
|
|
\c enum KDChartAxisParams::AxisPos { AxisPosSTART = 0,
|
|
|
|
AxisPosBottom = 0,
|
|
AxisPosSagittal = 0, // <-- for POLAR charts
|
|
AxisPosLeft = 1,
|
|
AxisPosCircular = 1, // <-- for POLAR charts
|
|
AxisPosLowerRightEdge = 2,
|
|
|
|
AxisPosTop = 3,
|
|
AxisPosRight = 4,
|
|
AxisPosLowerLeftEdge = 5,
|
|
|
|
// diese Markierung muss jeweils mitgepflegt werden,
|
|
// wenn AxisPos erweitert werden sollte.
|
|
AxisPosAdditionalsSTART = 6,
|
|
|
|
AxisPosBottom2 = 6,
|
|
AxisPosLeft2 = 7,
|
|
AxisPosLowerRightEdge2 = 8,
|
|
|
|
AxisPosTop2 = 9,
|
|
AxisPosRight2 = 10,
|
|
AxisPosLowerLeftEdge2 = 11,
|
|
|
|
// auch diese Markierung muss jeweils mitgepflegt werden,
|
|
// wenn AxisPos erweitert werden sollte.
|
|
AxisPosEND = 11 };
|
|
|
|
Since the chart area is defined by subtracting the space consumed by
|
|
the axes from the printable area there are two options that are
|
|
mutually exclusive.
|
|
|
|
- Define the chart by precisely specifying (in absolute or in
|
|
relative numbers) how much space may be used by each axis.
|
|
and/or define start and end values for the axes' labels.
|
|
|
|
-> This produces results that are comparable to each other
|
|
since the chart will have an exactly fixed size and its position
|
|
on the paper will remain the same even if the labels of its axes
|
|
become wider or more narrow.
|
|
Also the graphical representation of the date will be comparable
|
|
since all your charts will use the same scale if you wish this.
|
|
|
|
- Let the program calculate the chart tqlayout based upon the kind
|
|
of and width of the labels to be drawn at the axes.
|
|
Also the program can calculate the labels for you and find the
|
|
boundary values for start and end of the scale automatically.
|
|
-> This will produce good looking results without you having
|
|
to fiddle around with the settings.
|
|
Unfortunately these charts will not allways be comparable to
|
|
each other if the axes' labels change since both the size of
|
|
the area reserved for the chart and the scaling of the
|
|
scales will vary if the data values do so.
|
|
|
|
With KDChart both ways are possible, see hints given with
|
|
setAxisAreaMode(), setAxisAreaMin() and setAxisAreaMax().
|
|
|
|
To optimize your results you might want to use setAxisLineWidth() and
|
|
setAxisLabelsFontPointSize(): negative values will specify it
|
|
in per thousand of the printable area size - producing a result
|
|
looking fine even if the chart is
|
|
printed at very large dimensions.
|
|
|
|
\sa setAxisAreaMode, setAxisAreaMin, setAxisAreaMax
|
|
\sa setAxisLineWidth(), setAxisLabelsFontPointSize()
|
|
\sa setAxisLabelsLimitsAuto(), setAxisLabelsLimitsLow()
|
|
\sa setAxisLabelsLimitsHeigh()
|
|
*/
|
|
|
|
/**
|
|
The axis position.
|
|
Use AxisPosBottom for X-axis and AxisPosLeft for traditional Y-axis.
|
|
When showing 3-dimensional charts you may use AxisPosLowerRightEdge
|
|
to have an Y-axis on the lower right side going into the 'depth' of
|
|
the picture and a z-axis going 'upwards' at the left edge.
|
|
The other, optional values (AxisPosRight, AxisPosTop and
|
|
AxisPosLowerLeftEdge, resp.) could be used to show a second
|
|
axis on the other side of the picture - useful in case you want
|
|
to show two data sets in one chart, like two curves showing data sets
|
|
sharing the same abscissa axis but having differently scaled ordinates.
|
|
The additional values (AxisPosBottom2, AxisPosTop2 ..) may be used
|
|
to specify composed charts having two ordinates at the same side of
|
|
the drawing and the like...
|
|
|
|
These AxisPos values are used to specify which axis' settings are
|
|
to be modified or retrieved, resp.
|
|
|
|
\note Use special values \c AxisPossagittal and \c AxisPosCircular
|
|
to set delimiter/label/grid parameters for polar charts.
|
|
|
|
\sa setAxisAreaMode, axisAreaMode, setAxisCalcMode, axisCalcMode
|
|
\sa KDChartParams::setAxisParams, KDChartParams::axisParams
|
|
*/
|
|
|
|
|
|
/**
|
|
The basic axis type.
|
|
|
|
\param pos the axis type to be analyzed
|
|
\return the basic axis type (Bottom, Left, Top or Right)
|
|
*/
|
|
KDChartAxisParams::AxisPos KDChartAxisParams::basicAxisPos( uint pos )
|
|
{
|
|
AxisPos ret = AxisPos( pos );
|
|
switch ( pos ) {
|
|
case AxisPosBottom:
|
|
case AxisPosLeft:
|
|
case AxisPosTop:
|
|
case AxisPosRight:
|
|
break;
|
|
case AxisPosLowerRightEdge:
|
|
ret = AxisPosRight;
|
|
break;
|
|
case AxisPosLowerLeftEdge:
|
|
ret = AxisPosLeft;
|
|
break;
|
|
case AxisPosBottom2:
|
|
ret = AxisPosBottom;
|
|
break;
|
|
case AxisPosLeft2:
|
|
ret = AxisPosLeft;
|
|
break;
|
|
case AxisPosTop2:
|
|
ret = AxisPosTop;
|
|
break;
|
|
case AxisPosRight2:
|
|
ret = AxisPosRight;
|
|
break;
|
|
case AxisPosLowerRightEdge2:
|
|
ret = AxisPosRight;
|
|
break;
|
|
case AxisPosLowerLeftEdge2:
|
|
ret = AxisPosLeft;
|
|
break;
|
|
default: {
|
|
qDebug( "IMPLEMENTATION ERROR: type missing in KDChartAxisParams::basicAxisPos()" );
|
|
Q_ASSERT( ret != AxisPos( pos ) );
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
Specifies if the axis will be drawn. The default is false.
|
|
|
|
\param axisVisible set true to make visible the respective axis.
|
|
\sa axisVisible, AxisVisible
|
|
*/
|
|
void KDChartAxisParams::setAxisVisible( bool axisVisible )
|
|
{
|
|
_axisVisible = axisVisible;
|
|
emit changed();
|
|
}
|
|
|
|
/**
|
|
Returns weither the axis will be drawn or not.
|
|
|
|
\return if the axis is visible or not.
|
|
\sa setAxisVisible, AxisVisible
|
|
*/
|
|
bool KDChartAxisParams::axisVisible() const
|
|
{
|
|
return _axisVisible;
|
|
}
|
|
|
|
|
|
/**
|
|
\c enum AxisAreaMode { AxisAreaModeFixedSize,
|
|
AxisAreaModeAutoSize,
|
|
AxisAreaModeMinMaxSize };
|
|
|
|
The axis size, determines how to calculate the size of area used
|
|
by the axis - i.e. the width of left axis area (or the right
|
|
one, resp.) or the height of the top axis area (or the bottom one,
|
|
resp.).
|
|
\li \c AxisAreaModeFixedSize (default) value will be taken
|
|
from \c AxisAreaMinSize() or \c AxisAreaMaxSize() - whichever
|
|
returns the smaller value
|
|
\li \c AxisAreaModeAutoSize (default) will be calculated
|
|
automatically based on the size of the labels to be drawn
|
|
\li \c AxisAreaModeMinMaxSize will be calculated automatically but
|
|
bearing user defined limits in mind (this is not implemented yet)
|
|
|
|
\sa setAxisAreaMode, axisAreaMode, AxisAreaMode
|
|
\sa setAxisAreaMin, setAxisAreaMax, setAxisArea
|
|
*/
|
|
|
|
/**
|
|
Specifies the axis size mode.
|
|
The default is auto size (AxisAreaModeAutoSize).
|
|
|
|
\param axisAreaMode the way how to find out the
|
|
size of the area where the axis shall be drawn.
|
|
\sa axisAreaMode, AxisAreaMode
|
|
\sa setAxisAreaMin, setAxisAreaMax, setAxisArea
|
|
*/
|
|
void KDChartAxisParams::setAxisAreaMode( AxisAreaMode axisAreaMode )
|
|
{
|
|
_axisAreaMode = axisAreaMode;
|
|
emit changed();
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
Returns the axis size mode configured in this params object.
|
|
|
|
\return the axis size mode configured in this params object.
|
|
\sa setAxisAreaMode, AxisAreaMode, setAxisAreaMin, setAxisAreaMax
|
|
\sa setAxisArea
|
|
*/
|
|
KDChartAxisParams::AxisAreaMode KDChartAxisParams::axisAreaMode() const
|
|
{
|
|
return _axisAreaMode;
|
|
}
|
|
|
|
/**
|
|
Converts the specified axis area mode enum to a string representation.
|
|
|
|
\param mode the axis area mode enum to convert
|
|
\return the string representation of the mode enum
|
|
*/
|
|
TQString KDChartAxisParams::axisAreaModeToString( AxisAreaMode mode ) {
|
|
switch( mode ) {
|
|
case AxisAreaModeFixedSize:
|
|
return "FixedSize";
|
|
case AxisAreaModeAutoSize:
|
|
return "AutoSize";
|
|
case AxisAreaModeMinMaxSize:
|
|
return "MinMaxSize";
|
|
default: // should not happen
|
|
qDebug( "Unknown axis area mode" );
|
|
return "AxisAreaMode";
|
|
}
|
|
}
|
|
|
|
/**
|
|
Converts the specified string to an axis area mode enum value.
|
|
|
|
\param string the string to convert
|
|
\return the axis area mode enum value
|
|
*/
|
|
KDChartAxisParams::AxisAreaMode KDChartAxisParams::stringToAxisAreaMode( const TQString& type ) {
|
|
if( type == "FixedSize" )
|
|
return AxisAreaModeFixedSize;
|
|
else if( type == "AutoSize" )
|
|
return AxisAreaModeAutoSize;
|
|
else if( type == "MinMaxSize" )
|
|
return AxisAreaModeMinMaxSize;
|
|
else // should not happen
|
|
return AxisAreaModeAutoSize;
|
|
}
|
|
|
|
/**
|
|
Specifies the axis area minimum width (or height, resp.).
|
|
|
|
\param axisAreaMin the axis area minimum width (or height, resp.)
|
|
If value is negative, the absolute value is per thousand
|
|
of the size of the printable area to
|
|
be used. This will make the axis look the same even if scaled
|
|
to very different size.
|
|
|
|
Note: It AxisAreaModeFixedSize is set the smaller value of
|
|
axisAreaMax and axisAreaMin is used for the area size.
|
|
|
|
\sa axisAreaMin, axisAreaMax, setAxisAreaMode, setAxisAreaMax
|
|
\sa setAxisArea
|
|
*/
|
|
void KDChartAxisParams::setAxisAreaMin( int axisAreaMin )
|
|
{
|
|
_axisAreaMin = axisAreaMin;
|
|
emit changed();
|
|
}
|
|
|
|
/**
|
|
\fn int KDChartAxisParams::axisAreaMin() const
|
|
Returns the axis area minimum width (or height, resp.).
|
|
|
|
\return the axis area minimum width (or height, resp.).
|
|
\sa setAxisAreaMin, setAxisAreaMax, setAxisArea
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
Specifies how the axis will make use of the available space.
|
|
|
|
Use this function to specify how large the area of the axis
|
|
will be and where it will be positioned.
|
|
|
|
\note This function is to be used for (vertical) ordinate axes <b>only</b>,
|
|
available space usage specified for abscissa axes will be ignored.
|
|
|
|
example: setAxisUseAvailableSpace( 0, -499 ) will make the
|
|
axis occupy the first half of the available space,
|
|
so there could be a second axis (for chart #2 having the same
|
|
x-axis as chart #1) using the remaining
|
|
part of the available space, this one would be specified
|
|
by setAxisUseAvailableSpace( -500, -1000 ).
|
|
|
|
See also the examples given with \c KDChartParams::setAdditionalChartType().
|
|
|
|
\param axisUseAvailableSpaceFrom the beginning offset
|
|
of the space to be covered by this axis.
|
|
Set this to 0 to have your axis start at the very beginning
|
|
of the avaliable space - this is the default setting.
|
|
Use negative values to specify an offset in per mil
|
|
of the available space, or use positive values to specify
|
|
it in pixels.
|
|
|
|
\param axisUseAvailableSpaceTo the ending offset
|
|
of the space to be covered by this axis.
|
|
Set this to -1000 (== 1000 per mille) to let the axis
|
|
end at the very end of the available space, this is the default setting.
|
|
to a smaller negative value to specify the percantage
|
|
Use negative values to specify an offset in per mil
|
|
of the available space, or use positive values to specify
|
|
it in pixels.
|
|
|
|
\sa axisUseAvailableSpaceFrom, axisUseAvailableSpaceTo
|
|
*/
|
|
void KDChartAxisParams::setAxisUseAvailableSpace( int axisUseAvailableSpaceFrom,
|
|
int axisUseAvailableSpaceTo )
|
|
{
|
|
_axisUseAvailableSpaceFrom = axisUseAvailableSpaceFrom;
|
|
_axisUseAvailableSpaceTo = axisUseAvailableSpaceTo;
|
|
emit changed();
|
|
}
|
|
|
|
|
|
/**
|
|
\fn int KDChartAxisParams::axisUseAvailableSpaceFrom() const
|
|
Returns the beginning offset of the space used by this
|
|
axis in comparison to the available space that could
|
|
be used by this axis.
|
|
|
|
\sa setAxisUseAvailableSpace, axisUseAvailableSpaceTo
|
|
*/
|
|
|
|
|
|
/**
|
|
\fn int KDChartAxisParams::axisUseAvailableSpaceTo() const
|
|
Returns the ending offset of the space used by this
|
|
axis in comparison to the available space that could
|
|
be used by this axis.
|
|
|
|
\sa setAxisUseAvailableSpace, axisUseAvailableSpaceFrom
|
|
*/
|
|
|
|
/**
|
|
Specifies the axis area maximum width (or height, resp.).
|
|
|
|
\param axisAreaMax the axis area maximum width (or height, resp.)
|
|
If value is negative, the absolute value is per thousand
|
|
of the size of the printable area to
|
|
be used. This will make the axis look the same even if scaled
|
|
to very different size.
|
|
|
|
Note: If AxisAreaModeFixedSize is set the smaller value of
|
|
axisAreaMax and axisAreaMin is used for the area size.
|
|
|
|
\sa axisAreaMax, axisAreaMin, setAxisAreaMode, setAxisAreaMin
|
|
\sa setAxisArea
|
|
*/
|
|
void KDChartAxisParams::setAxisAreaMax( int axisAreaMax )
|
|
{
|
|
_axisAreaMax = axisAreaMax;
|
|
emit changed();
|
|
}
|
|
/**
|
|
\fn int KDChartAxisParams::axisAreaMax() const
|
|
Returns the axis area maximum width (or height, resp.).
|
|
|
|
\return the axis area maximum width (or height, resp.).
|
|
\sa setAxisAreaMax, setAxisAreaMin, setAxisArea
|
|
*/
|
|
|
|
/**
|
|
Specifies the axis area size mode and the
|
|
minimum and maximum width (or height, resp.) of the area.
|
|
This method is here for convenience, see \c setAxisAreaMode,
|
|
\c setAreaMin and \c setAreaMax for details.
|
|
|
|
Note: Is AxisAreaModeFixedSize is set the smaller value of
|
|
axisAreaMax and axisAreaMin is used for the area size.
|
|
|
|
\param axisAreaMode the way how to find out the
|
|
size of the area where the axis shall be drawn.
|
|
\param axisAreaMin the axis area minimum width (or height, resp.)
|
|
\param axisAreaMax the axis area maximum width (or height, resp.)
|
|
|
|
\sa setAxisAreaMode, setAxisAreaMin, setAxisAreaMax
|
|
*/
|
|
void KDChartAxisParams::setAxisArea( AxisAreaMode axisAreaMode,
|
|
int axisAreaMin,
|
|
int axisAreaMax )
|
|
{
|
|
_axisAreaMode = axisAreaMode;
|
|
_axisAreaMin = axisAreaMin;
|
|
_axisAreaMax = axisAreaMax;
|
|
emit changed();
|
|
}
|
|
|
|
/**
|
|
\c enum AxisCalcMode { AxisCalcLinear, AxisCalcLogarithmic };
|
|
The axis calculation mode.
|
|
|
|
\sa setAxisCalcMode, axisCalcMode, AxisCalcMode
|
|
*/
|
|
|
|
/**
|
|
Specifies the axis calculation mode.
|
|
The default is linear calculation (AxisCalcLinear).
|
|
|
|
\note Specifying an AxisCalcLogarithmic calculation mode
|
|
also results in the axis's label parameters being adjusted,
|
|
in detail these settings will become valid:
|
|
|
|
\li steady-value-calculation mode is activated
|
|
\li automatic limit calculation will be set for the begin and the end of the axis
|
|
\li logarithmical step width will be calculated automatically: 0.001, 0.01, 0.1, 1, 10, ..
|
|
\li number of Digits shown behind the comma will be calculated automatically.
|
|
|
|
This is done by implicitely calling setAxisValues(),
|
|
so you don't need to explicitely call that function,
|
|
actually the following is what happens inside:
|
|
|
|
\verbatim
|
|
if( AxisCalcLogarithmic == axisCalcMode )
|
|
setAxisValues( true,
|
|
KDCHART_AXIS_LABELS_AUTO_LIMIT,
|
|
KDCHART_AXIS_LABELS_AUTO_LIMIT,
|
|
1.0,
|
|
KDCHART_AXIS_LABELS_AUTO_DIGITS );
|
|
\endverbatim
|
|
|
|
You may override these setting by making an extra setAxisValues()
|
|
call AFTER calling setAxisCalcMode( AxisCalcLogarithmic ).
|
|
|
|
\param axisCalcMode the axis calculation mode to be used.
|
|
\sa axisCalcMode, AxisCalcMode
|
|
\sa setAxisSteadyValueCalc
|
|
*/
|
|
void KDChartAxisParams::setAxisCalcMode( AxisCalcMode axisCalcMode )
|
|
{
|
|
_axisCalcMode = axisCalcMode;
|
|
if( AxisCalcLogarithmic == axisCalcMode ){
|
|
setAxisValues( true,
|
|
KDCHART_AXIS_LABELS_AUTO_LIMIT,
|
|
KDCHART_AXIS_LABELS_AUTO_LIMIT,
|
|
1.0,
|
|
KDCHART_AXIS_LABELS_AUTO_DIGITS );
|
|
}
|
|
emit changed();
|
|
}
|
|
/**
|
|
\fn AxisCalcMode KDChartAxisParams::axisCalcMode() const
|
|
Returns the axis calculation mode configured in this params object.
|
|
|
|
\return the axis calculation mode configured in this params object.
|
|
\sa setAxisCalcMode, AxisCalcMode
|
|
*/
|
|
|
|
/**
|
|
Converts the specified axis calc mode enum to a string representation.
|
|
|
|
\param mode the axis calc mode enum to convert
|
|
\return the string representation of the mode enum
|
|
*/
|
|
TQString KDChartAxisParams::axisCalcModeToString( AxisCalcMode mode ) {
|
|
switch( mode ) {
|
|
case AxisCalcLinear:
|
|
return "Linear";
|
|
case AxisCalcLogarithmic:
|
|
return "Logarithmic";
|
|
default: // should not happen
|
|
qDebug( "Unknown axis calc mode" );
|
|
return "Linear";
|
|
}
|
|
}
|
|
|
|
/**
|
|
Converts the specified string to an axis calc mode enum value.
|
|
|
|
\param string the string to convert
|
|
\return the axis calc mode enum value
|
|
*/
|
|
KDChartAxisParams::AxisCalcMode KDChartAxisParams::stringToAxisCalcMode( const TQString& type ) {
|
|
if( type == "Linear" )
|
|
return AxisCalcLinear;
|
|
else if( type == "Logarithmic" )
|
|
return AxisCalcLogarithmic;
|
|
else // should not happen
|
|
return AxisCalcLinear;
|
|
}
|
|
|
|
/**
|
|
Specifies another axis which this axis shall be isometric with.
|
|
|
|
\param isoRefAxis axis which this axis shall be isometric with.
|
|
|
|
Normally all axes' step widths are calculated independently from
|
|
each other. By specifying a reference axis for one axis you make
|
|
KDChart use the same scale for both axes.
|
|
|
|
For example to have the left axis using the same scale as the
|
|
right axis you could invoke this:
|
|
|
|
\verbatim
|
|
KDChartAxisParams pa(
|
|
_p->axisParams( KDChartAxisParams::AxisPosLeft ) );
|
|
pa.setIsometricReferenceAxis( KDChartAxisParams::AxisPosBottom );
|
|
_p->setAxisParams( KDChartAxisParams::AxisPosLeft, pa );
|
|
\endverbatim
|
|
|
|
These commands are equivalent to the following ones:
|
|
|
|
\verbatim
|
|
KDChartAxisParams pa(
|
|
_p->axisParams( KDChartAxisParams::AxisPosBottom ) );
|
|
pa.setIsometricReferenceAxis( KDChartAxisParams::AxisPosLeft );
|
|
_p->setAxisParams( KDChartAxisParams::AxisPosBottom, pa );
|
|
\endverbatim
|
|
|
|
In any case both axes will use the same scale so - unless you are
|
|
using more axes than these two ones - the resulting chart will be true
|
|
to scale.
|
|
|
|
\note Use special value KDCHART_ALL_AXES if your chart
|
|
has got more than two axes and all of them shall use the same scale, specifying
|
|
this for one of the axes is enough, there is no need to set it several times.
|
|
|
|
Use special value KDCHART_NO_AXIS to undo any previous setting
|
|
that was specified for this axis, this has to be called for any axis that was
|
|
modified by previous calls.
|
|
|
|
\sa isometricReferenceAxis
|
|
*/
|
|
void KDChartAxisParams::setIsometricReferenceAxis( uint isoRefAxis )
|
|
{
|
|
_axisIsoRefAxis = isoRefAxis;
|
|
emit changed();
|
|
}
|
|
|
|
/**
|
|
\fn uint KDChartAxisParams::isometricReferenceAxis() const
|
|
Returns which axis this axis shall be isometric with, this will
|
|
be either the axis position - see KDChartAxisParams::AxisPos - or one of the special
|
|
values KDCHART_ALL_AXES and KDCHART_NO_AXIS.
|
|
|
|
\return which axis this axis shall be isometric with.
|
|
|
|
\sa setIsometricReferenceAxis
|
|
*/
|
|
|
|
|
|
/**
|
|
\fn void KDChartAxisParams::setAxisTrueAreaSize( int axisTrueAreaSize )
|
|
Specifies the true axis area width (or height, resp.).
|
|
|
|
\param axisAreaMax the true axis area width (or height, resp.)
|
|
as it was calculated and drawn.
|
|
This is allways an absolute value.
|
|
|
|
\note Do <b>not call</b> this function unless you are knowing
|
|
exactly what you are doing. \c setAxisTrueAreaSize is normally
|
|
reserved for internal usage by methods calculating the area
|
|
size based upon \c axisAreaMin and \c axisAreaMax. Thus the
|
|
signal \c changed() is not sended here.
|
|
|
|
\sa axisAreaMax, axisAreaMin, setAxisAreaMode, setAxisAreaMin
|
|
\sa setAxisArea
|
|
*/
|
|
|
|
/**
|
|
\fn int KDChartAxisParams::axisTrueAreaSize() const
|
|
Returns the true axis area width (or height, resp.)
|
|
as calculated and drawn.
|
|
|
|
\return the true axis area width (or height, resp.).
|
|
\sa setAxisAreaMax, setAxisAreaMin, setAxisArea
|
|
*/
|
|
|
|
/**
|
|
\fn void KDChartAxisParams::setAxisTrueAreaRect( const TQRect& axisTrueAreaRect )
|
|
Specifies the true axis area rectangle.
|
|
|
|
\param axisAreaMax the true axis area rectangle
|
|
as it was calculated and drawn.
|
|
|
|
\note Do <b>not call</b> this function unless you are knowing
|
|
exactly what you are doing. \c setAxisTrueAreaRect is normally
|
|
reserved for internal usage by methods calculating the area
|
|
size based upon \c axisAreaMin and \c axisAreaMax. Thus the
|
|
signal \c changed() is not sended here.
|
|
|
|
\sa axisAreaMax, axisAreaMin, setAxisAreaMode, setAxisAreaMin
|
|
\sa setAxisArea
|
|
*/
|
|
|
|
/**
|
|
\fn TQRect KDChartAxisParams::axisTrueAreaRect() const
|
|
Returns the true axis area rectangle
|
|
as calculated and drawn.
|
|
|
|
\return the true axis area rectangle
|
|
\sa setAxisAreaMax, setAxisAreaMin, setAxisArea
|
|
*/
|
|
|
|
/**
|
|
Specifies whether the axis sub-delimiters should be drawn.
|
|
|
|
\note If true and axisShowGrid is also true the grid on the
|
|
chart data area will show a thin dotted line for each sub-delimiter
|
|
(or a line with a pattern defined by \c setAxisGridSubStyle, resp.)
|
|
|
|
\param axisShowSubDelimiters if true sub-delimiters will be drawn at this axis.
|
|
\sa axisShowSubDelimiters, setAxisShowGrid, setAxisGridSubStyle
|
|
*/
|
|
void KDChartAxisParams::setAxisShowSubDelimiters( bool axisShowSubDelimiters )
|
|
{
|
|
_axisShowSubDelimiters = axisShowSubDelimiters;
|
|
emit changed();
|
|
}
|
|
|
|
/**
|
|
Specifies whether the delimiters should be drawn at the position for the fractional values.
|
|
|
|
\note This can be useful if you want to force only painting non fractional values on the axis and
|
|
do not want the delimiters and grid lines to be drawn at the position where some fractional values
|
|
(auto calculation) were meant to be displayed. It will have no effect in case fractional values labels
|
|
are painted.
|
|
In order to force painting only non fractional values you need to call setAxisBehindDigitsComma(0).
|
|
\param axisShowFracValDelim if false delimiters and grid line will not be drawn on this axis at the positon
|
|
where fractional values were meant to be drawn.
|
|
\sa setAxisDigitBehindComma
|
|
*/
|
|
|
|
void KDChartAxisParams::setAxisShowFractionalValuesDelimiters( bool axisShowFracValDelim )
|
|
{
|
|
_axisShowFractionalValuesDelimiters = axisShowFracValDelim;
|
|
emit changed();
|
|
}
|
|
|
|
|
|
/**
|
|
\fn bool KDChartAxisParams::axisShowSubDelimiters() const
|
|
Returns whether the axis sub-delimiters will be drawn.
|
|
|
|
\return whether the axis sub-delimiters will be drawn.
|
|
\sa setAxisShowSubDelimiters
|
|
*/
|
|
|
|
/**
|
|
Specifies whether the axis line should be drawn.
|
|
|
|
\param axisLineVisible if true the line of this axis will be drawn.
|
|
\sa axisLineVisible
|
|
*/
|
|
void KDChartAxisParams::setAxisLineVisible( bool axisLineVisible )
|
|
{
|
|
_axisLineVisible = axisLineVisible;
|
|
emit changed();
|
|
}
|
|
|
|
|
|
/**
|
|
\fn bool KDChartAxisParams::axisLineVisible() const
|
|
Returns whether the axis line should be drawn.
|
|
|
|
\return whether the axis line should be drawn.
|
|
\sa setAxisLineVisible
|
|
*/
|
|
|
|
/**
|
|
Specifies the axis line width.
|
|
|
|
\param axisLineWidth the axis line width.
|
|
If value is negative, the absolute value is per thousand
|
|
of the printable area size to be used. This will make the
|
|
axis look the same even if scaled to very different size.
|
|
|
|
\sa axisLineWidth
|
|
*/
|
|
void KDChartAxisParams::setAxisLineWidth( int axisLineWidth )
|
|
{
|
|
_axisLineWidth = axisLineWidth;
|
|
emit changed();
|
|
}
|
|
|
|
|
|
/**
|
|
\fn int KDChartAxisParams::axisLineWidth() const
|
|
Returns the axis line width.
|
|
|
|
\return the axis line width.
|
|
\sa setAxisLineWidth
|
|
*/
|
|
|
|
|
|
/**
|
|
\fn void s KDChartAxisParams::setAxisTrueLineWidth( int axisTrueLineWidth )
|
|
Specifies the actual axis line width, as calculated and drawn.
|
|
|
|
\Note You may not use this internal function.
|
|
|
|
\param axisTrueLineWidth the actual axis line width,
|
|
as calculated and drawn.
|
|
|
|
\sa axisTrueLineWidth
|
|
*/
|
|
|
|
/**
|
|
\fn int KDChartAxisParams::axisTrueLineWidth() const
|
|
Returns the axis true line width, as calculated and drawn.
|
|
|
|
\return the axis true line width, as calculated and drawn.
|
|
\sa setAxisTrueLineWidth
|
|
*/
|
|
|
|
|
|
/**
|
|
Specifies the axis line colour.
|
|
|
|
\param axisLineColor the axis line colour.
|
|
\sa axisLineColor
|
|
*/
|
|
void KDChartAxisParams::setAxisLineColor( TQColor axisLineColor )
|
|
{
|
|
_axisLineColor = axisLineColor;
|
|
emit changed();
|
|
}
|
|
|
|
/**
|
|
\fn TQColor KDChartAxisParams::axisLineColor() const
|
|
Returns the axis line colour.
|
|
|
|
\return the axis line colour.
|
|
\sa setAxisLineColor
|
|
*/
|
|
|
|
|
|
/**
|
|
Specifies whether a grid should be drawn at the chart data area.
|
|
By default the grid will be drawn based on the left
|
|
ordinate axis and on the bottom abscissa axis.
|
|
|
|
The grid will show a solid line for each delimiter.
|
|
(or a line with a pattern defined by \c setAxisGridStyle, resp.)
|
|
|
|
\note If true and axisShowSubDelimiters is also true the grid
|
|
will show a thin dotted line for each sub-delimiter.
|
|
(or a line with a pattern defined by \c setAxisGridSubStyle, resp.)
|
|
|
|
\param axisShowGrid if true a grid will be drawn on the chart data area.
|
|
\sa axisShowGrid, setAxisGridStyle, setAxisGridSubStyle
|
|
*/
|
|
void KDChartAxisParams::setAxisShowGrid( bool axisShowGrid )
|
|
{
|
|
_axisShowGrid = axisShowGrid;
|
|
emit changed();
|
|
}
|
|
|
|
/**
|
|
\fn bool KDChartAxisParams::axisShowGrid() const
|
|
Returns whether a grid should be drawn at the chart data area.
|
|
|
|
\return whether a grid should be drawn at the chart data area.
|
|
\sa setAxisShowGrid, setAxisShowSubDelimiters
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
Specifies the axis grid colour.
|
|
|
|
To reset the color to the built-in default value
|
|
please call \c setAxisGridColor( KDCHART_DEFAULT_AXIS_GRID_COLOR )
|
|
|
|
\param axisGridColor the axis grid color.
|
|
\sa axisGridColor, setAxisShowGrid
|
|
*/
|
|
void KDChartAxisParams::setAxisGridColor( TQColor axisGridColor )
|
|
{
|
|
_axisGridColor = axisGridColor;
|
|
emit changed();
|
|
}
|
|
|
|
/**
|
|
\fn TQColor KDChartAxisParams::axisGridColor() const
|
|
Returns the axis grid color.
|
|
|
|
\return the axis grid color.
|
|
\sa setAxisGridColor, setAxisShowGrid
|
|
*/
|
|
|
|
|
|
/**
|
|
Specifies the colour to be used for the thin lines between the
|
|
normal axis grid lines.
|
|
|
|
To reset the color to the built-in default value
|
|
please call \c setAxisGridSubColor( KDCHART_DEFAULT_AXIS_GRID_COLOR )
|
|
|
|
\param axisGridSubColor the axis grid sub color.
|
|
\sa axisGridSubColor, setAxisGridColor, setAxisShowGrid, setAxisShowSubDelimiters
|
|
*/
|
|
void KDChartAxisParams::setAxisGridSubColor( TQColor axisGridSubColor )
|
|
{
|
|
_axisGridSubColor = axisGridSubColor;
|
|
emit changed();
|
|
}
|
|
|
|
|
|
/**
|
|
\fn TQColor KDChartAxisParams::axisGridSubColor() const
|
|
Returns the axis grid sub color.
|
|
|
|
\return the axis grid sub color.
|
|
\sa setAxisGridSubColor
|
|
*/
|
|
|
|
/**
|
|
Specifies the width of the axis grid lines.
|
|
|
|
\note Normally you would <b>not</b> call this function since
|
|
grid lines in most cases look best in their default line
|
|
width: the same width as the axis line they belong to.
|
|
However when combining multiple datasets or multiple charts
|
|
sharing the same abscissa axes but having their ordinates
|
|
differently scaled you might want to reduce the line width
|
|
of the respective grid lines and use different grid colours
|
|
to show two grids at the same time. In such cases it might
|
|
also be a good idea to deactivate \c setAxisShowSubDelimiters
|
|
thus avoiding the dotted sub-grid lines or to set their
|
|
style to TQt::NoPen to get sub-delimiters on the axis
|
|
but no sub-grid lines.
|
|
|
|
You may use setAxisGridLineWidth( KDCHART_AXIS_GRID_AUTO_LINEWIDTH )
|
|
to reset the value to its default: being automatically
|
|
adjusted to the width of the axis line.
|
|
|
|
\param axisGridLineWidth the width of the axis grid lines.
|
|
If value is negative, the absolute value is per thousand
|
|
of the printable area size to be used. This will make the
|
|
grid look the same even if scaled to very different size.
|
|
\sa axisGridLineWidth, setAxisGridColor, setAxisGridStyle
|
|
\sa setAxisShowGrid, setAxisShowSubDelimiters
|
|
*/
|
|
void KDChartAxisParams::setAxisGridLineWidth( int axisGridLineWidth )
|
|
{
|
|
_axisGridLineWidth = axisGridLineWidth;
|
|
emit changed();
|
|
}
|
|
|
|
/**
|
|
\fn int KDChartAxisParams::axisGridLineWidth() const
|
|
Returns the width of the axis grid lines.
|
|
(see explanation given with \c setAxisGridLineWidth )
|
|
|
|
\return the width of the axis grid lines.
|
|
\sa setAxisGridLineWidth, setAxisShowGrid
|
|
*/
|
|
|
|
/**
|
|
Specifies the width of the thin lines between the
|
|
normal axis grid lines.
|
|
|
|
You may use setAxisGridSubLineWidth( KDCHART_AXIS_GRID_AUTO_LINEWIDTH )
|
|
to reset the value to its default: being automatically
|
|
adjusted to the width of the axis line.
|
|
|
|
\param axisGridSubLineWidth the axis grid sub line width.
|
|
\sa axisGridSubLineWidth, setAxisGridLineWidth, setAxisShowGrid, setAxisShowSubDelimiters
|
|
*/
|
|
void KDChartAxisParams::setAxisGridSubLineWidth( int axisGridSubLineWidth )
|
|
{
|
|
_axisGridSubLineWidth = axisGridSubLineWidth;
|
|
emit changed();
|
|
}
|
|
|
|
|
|
/**
|
|
\fn TQColor KDChartAxisParams::axisGridSubLineWidth() const
|
|
Returns the axis grid sub line width.
|
|
|
|
\return the axis grid sub line width.
|
|
\sa setAxisGridSubLineWidth
|
|
*/
|
|
|
|
|
|
/**
|
|
Specifies the axis grid line pattern.
|
|
|
|
\param axisGridStyle the axis grid line pattern.
|
|
\sa axisGridStyle, setAxisShowGrid
|
|
*/
|
|
void KDChartAxisParams::setAxisGridStyle( Qt::PenStyle axisGridStyle )
|
|
{
|
|
_axisGridStyle = axisGridStyle;
|
|
emit changed();
|
|
}
|
|
|
|
/**
|
|
\fn Qt::PenStyle KDChartAxisParams::axisGridStyle() const
|
|
Returns the axis grid line pattern.
|
|
|
|
\return the axis grid line pattern.
|
|
\sa setAxisGridStyle, setAxisShowGrid
|
|
*/
|
|
|
|
|
|
/**
|
|
Specifies the axis grid line pattern for the thin lines
|
|
showing the sub-delimiter values.
|
|
|
|
\param axisGridStyle the axis grid line pattern for the thin lines
|
|
showing the sub-delimiter values.
|
|
\sa axisGridSubStyle, setAxisGridStyle, axisGridStyle
|
|
\sa setAxisShowGrid
|
|
*/
|
|
void KDChartAxisParams::setAxisGridSubStyle( Qt::PenStyle axisGridSubStyle )
|
|
{
|
|
_axisGridSubStyle = axisGridSubStyle;
|
|
emit changed();
|
|
}
|
|
|
|
/**
|
|
\fn Qt::PenStyle KDChartAxisParams::axisGridSubStyle() const
|
|
Returns the axis grid line pattern for the thin lines
|
|
showing the sub-delimiter values.
|
|
|
|
\return the axis grid line pattern for the thin lines
|
|
showing the sub-delimiter values.
|
|
\sa setAxisGridSubStyle
|
|
\sa setAxisGridStyle, axisGridStyle, setAxisShowGrid
|
|
*/
|
|
|
|
/**
|
|
Specifies the colour of the zero-line
|
|
that is drawn if zero is not at the lower
|
|
edge of the chart.
|
|
|
|
\param axisZeroLineColor the zero-line colour.
|
|
\sa axisZeroLineColor
|
|
*/
|
|
void KDChartAxisParams::setAxisZeroLineColor( TQColor axisZeroLineColor )
|
|
{
|
|
_axisZeroLineColor = axisZeroLineColor;
|
|
emit changed();
|
|
}
|
|
|
|
/**
|
|
\fn TQColor KDChartAxisParams::axisZeroLineColor() const
|
|
Returns the colour used for the zero-value line
|
|
that is drawn if zero is not at the lower
|
|
edge of the chart.
|
|
|
|
\return the zero-line colour.
|
|
\sa setAxisZeroLineColor
|
|
*/
|
|
|
|
/**
|
|
Specifies whether the axis labels should be drawn.
|
|
|
|
\param axisLabelsVisible if true the labels of this axis will be
|
|
drawn.
|
|
\sa axisLabelsVisible
|
|
*/
|
|
void KDChartAxisParams::setAxisLabelsVisible( bool axisLabelsVisible )
|
|
{
|
|
_axisLabelsVisible = axisLabelsVisible;
|
|
emit changed();
|
|
}
|
|
|
|
|
|
/**
|
|
\fn bool KDChartAxisParams::axisLabelsVisible() const
|
|
Returns whether the axis labels should be drawn.
|
|
|
|
\return whether the axis labels should be drawn.
|
|
\sa setAxisLabelsVisible
|
|
*/
|
|
|
|
|
|
/**
|
|
\fn void KDChartAxisParams::setAxisLabelsFontMinSize( int axisLabelsFontMinSize )
|
|
|
|
Specifies the minimal font size to be used for displaying the axis labels.
|
|
|
|
Use this to specify the minimal font size to be used for axis labels,
|
|
in case KD Chart is calculating the axis labels fonts dynamically. Default value is 10 points.
|
|
|
|
\sa setAxisLabelsFont, setAxisLabelsFontUseRelSize, setAxisLabelsFontRelSize
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
Specifies whether the axis labels start and end at the
|
|
edges of the charts instead being positioned in the
|
|
middle of the first data point (or the last one, resp.)
|
|
|
|
\param axisLabelsTouchEdges if the axis labels start and end at the
|
|
edges of the charts instead being positioned in the
|
|
middle of the first data point (or the last one, resp.)
|
|
|
|
\sa axisLabelsTouchEdges
|
|
*/
|
|
void KDChartAxisParams::setAxisLabelsTouchEdges( bool axisLabelsTouchEdges )
|
|
{
|
|
_axisLabelsTouchEdges = axisLabelsTouchEdges;
|
|
emit changed();
|
|
}
|
|
|
|
/**
|
|
\fn bool KDChartAxisParams::axisLabelsTouchEdges() const
|
|
Returns whether the axis labels start and end at the
|
|
edges of the charts instead being positioned in the
|
|
middle of the first data point (or the last one, resp.)
|
|
|
|
\return whether the axis labels start and end at the
|
|
edges of the charts instead being positioned in the
|
|
middle of the first data point (or the last one, resp.)
|
|
\sa setAxisLabelsTouchEdges
|
|
*/
|
|
|
|
/**
|
|
Specifies the axis labels font.
|
|
|
|
\note The font size will be ignored if \c useFontSize is false,
|
|
in this case the font size will be calculated dynamically using
|
|
the value stored by you calling setAxisLabelsFontRelSize().
|
|
|
|
\param axisLabelsFont the font to be used for the axis' labels.
|
|
\param useFontSize set ti true if the fixed font size of
|
|
the \c axisLabelsFont is to be used, otherwise the font size
|
|
will be calculated dynamically.
|
|
|
|
\sa setAxisLabelsFontRelSize, setAxisLabelsFontUseRelSize
|
|
\sa axisLabelsFont, axisLabelsFontRelSize
|
|
*/
|
|
void KDChartAxisParams::setAxisLabelsFont( TQFont axisLabelsFont, bool useFontSize )
|
|
{
|
|
_axisLabelsFont = axisLabelsFont;
|
|
_axisLabelsFontUseRelSize = ! useFontSize;
|
|
emit changed();
|
|
}
|
|
/**
|
|
\fn TQFont KDChartAxisParams::axisLabelsFont() const
|
|
Returns the axis labels font.
|
|
|
|
\return the axis labels font.
|
|
\sa setAxisLabelsFont, setAxisLabelsFontRelSize
|
|
\sa axisLabelsFontRelSize
|
|
*/
|
|
|
|
/**
|
|
Specifies whether axis labels shall be drawn
|
|
using relative font size.
|
|
|
|
\param axisLabelsFontUseRelSize whether axis labels shall be drawn
|
|
using relative font size.
|
|
If true the absolute value of the value set by \c
|
|
setAxisLabelsFontRelSize is per thousand
|
|
of of the printable area size
|
|
to be used. This will make the axis look the same even if scaled
|
|
to very different size.
|
|
|
|
\sa setAxisLabelsFontRelSize, setAxisLabelsFont
|
|
*/
|
|
void KDChartAxisParams::setAxisLabelsFontUseRelSize( bool axisLabelsFontUseRelSize )
|
|
{
|
|
_axisLabelsFontUseRelSize = axisLabelsFontUseRelSize;
|
|
emit changed();
|
|
}
|
|
|
|
/**
|
|
\fn bool KDChartAxisParams::axisLabelsFontUseRelSize() const
|
|
Returns whether the fix axis font size is used.
|
|
|
|
\return whether the fix axis labels font size is used.
|
|
\sa setAxisLabelsFontRelSize, setAxisLabelsFont
|
|
*/
|
|
|
|
|
|
/**
|
|
Specifies the axis labels relative font size.
|
|
|
|
\param axisLabelsFontRelSize the relative axis font size.
|
|
If this value unequals zero the absolute value is per thousand
|
|
of the printable area width size
|
|
to be used. This will make the axis look the same even if scaled
|
|
to very different size.
|
|
|
|
\sa setAxisLabelsFontUseRelSize, setAxisLabelsFont
|
|
*/
|
|
void KDChartAxisParams::setAxisLabelsFontRelSize( int axisLabelsFontRelSize )
|
|
{
|
|
_axisLabelsFontRelSize = axisLabelsFontRelSize;
|
|
emit changed();
|
|
}
|
|
|
|
|
|
/**
|
|
\fn int KDChartAxisParams::axisLabelsFontRelSize() const
|
|
Returns the axis labels relative font size.
|
|
|
|
\return the axis labels relative font size.
|
|
\sa setAxisLabelsFontRelSize, setAxisLabelsFontUseRelSize
|
|
*/
|
|
|
|
/**
|
|
\fn bool KDChartAxisParams::axisLabelsDontShrinkFont() const
|
|
Specifies whether the axis labels' font size may be shrinked
|
|
to avoid overwriting neighboring areas.
|
|
|
|
\sa axisLabelsDontShrinkFont
|
|
\sa setAxisLabelsDontAutoRotate, setAxisLabelsRotation
|
|
\sa setAxisLabelsFontUseRelSize, setAxisLabelsFont
|
|
*/
|
|
|
|
|
|
/**
|
|
\fn void KDChartAxisParams::setAxisLabelsDontAutoRotate( bool labelsDontAutoRotate )
|
|
|
|
Specifies whether the axis labels may be rotated
|
|
to avoid overwriting neighboring areas.
|
|
|
|
\sa axisLabelsDontAutoRotate
|
|
\sa setAxisLabelsDontShrinkFont, setAxisLabelsRotation
|
|
\sa setAxisLabelsFontUseRelSize, setAxisLabelsFont
|
|
*/
|
|
|
|
/**
|
|
\fn bool KDChartAxisParams::axisLabelsDontAutoRotate() const
|
|
Returns whether the axis labels may not be rotated
|
|
to avoid overwriting neighboring areas.
|
|
|
|
\return whether the axis labels may not be rotated
|
|
to avoid overwriting neighboring areas.
|
|
\sa setAxisLabelsDontAutoRotate
|
|
\sa axisLabelsDontShrinkFont, setAxisLabelsRotation
|
|
\sa setAxisLabelsFontRelSize, setAxisLabelsFont
|
|
*/
|
|
|
|
/**
|
|
\fn void KDChartAxisParams::setAxisLabelsRotation( int rotation )
|
|
Specifies by how many degrees the axis labels shall be rotated.
|
|
|
|
\param rotation The rotation of the labels - value must be either
|
|
zero or between 360 and 270. 360 degrees means don't rotate.
|
|
|
|
\note This setting specifies the <b>minimum</b> rotation of
|
|
the labels. Rotation may be increased to fit labels into
|
|
available space unless you explicitely called the
|
|
setAxisLabelsDontAutoRotate() function.
|
|
|
|
\sa axisLabelsDontAutoRotate
|
|
\sa setAxisLabelsDontShrinkFont, setAxisLabelsRotation
|
|
\sa setAxisLabelsFontUseRelSize, setAxisLabelsFont
|
|
*/
|
|
|
|
|
|
/**
|
|
\fn int KDChartAxisParams::axisLabelsRotation() const
|
|
Returns by how many degrees the axis labels will be rotated.
|
|
|
|
\sa setAxisLabelsDontAutoRotate
|
|
\sa axisLabelsDontShrinkFont, setAxisLabelsRotation
|
|
\sa setAxisLabelsFontRelSize, setAxisLabelsFont
|
|
*/
|
|
|
|
|
|
/**
|
|
Specifies the axis labels colour.
|
|
|
|
\param axisLabelsColor the axis labels colour.
|
|
\sa axisLabelsColor
|
|
*/
|
|
void KDChartAxisParams::setAxisLabelsColor( TQColor axisLabelsColor )
|
|
{
|
|
_axisLabelsColor = axisLabelsColor;
|
|
emit changed();
|
|
}
|
|
|
|
/**
|
|
\fn TQColor KDChartAxisParams::axisLabelsColor() const
|
|
Returns the axis labels colour.
|
|
|
|
\return the axis labels colour.
|
|
\sa setAxisLabelsColor
|
|
*/
|
|
|
|
/**
|
|
Specifies the calculations to be applied to the axis labels.
|
|
|
|
\param divPow10 The power of 10 which the data value is to be divided by.
|
|
A value of 2 means divide by 100, a value of -3 means multiply by 1000,
|
|
and 0 (by definition) would result in multiplying by 1.
|
|
\param digitsBehindComma The number of digits to show behind the comma,
|
|
to have this calculated automatically just use the default value
|
|
KDCHART_DATA_VALUE_AUTO_DIGITS.
|
|
\sa setAxisLabelsFormat
|
|
\sa setAxisLabelsNotation
|
|
\sa axisLabelsDivPow10, axisLabelsDigitsBehindComma
|
|
*/
|
|
void KDChartAxisParams::setAxisLabelsCalc( int divPow10,
|
|
int digitsBehindComma )
|
|
{
|
|
_axisLabelsDivPow10 = divPow10;
|
|
_axisDigitsBehindComma = digitsBehindComma;
|
|
emit changed();
|
|
}
|
|
|
|
/**
|
|
Specifies the way how the axis label strings will be formatted. Will be ignored for non-numerical axis labels.
|
|
|
|
\param decimalPoint The 'radix character' (or text, resp.) to be inserted
|
|
into the string (default is '.').
|
|
\param thousandsPoint The character (or text, resp.) to be used as delimiter
|
|
between the hundred digit and the thousand digit and between the
|
|
100.000 and the 1.000.000 digit (default is ',').
|
|
|
|
\sa setAxisLabelsFormat, setAxisLabelsCalc
|
|
\sa setAxisLabelsNotation
|
|
\sa axisLabelsDecimalPoint, axisLabelsThousandsPoint
|
|
*/
|
|
void KDChartAxisParams::setAxisLabelsRadix( const TQString& decimalPoint,
|
|
const TQString& thousandsPoint )
|
|
{
|
|
_axisLabelsDecimalPoint = decimalPoint;
|
|
_axisLabelsThousandsPoint = thousandsPoint;
|
|
}
|
|
|
|
|
|
/**
|
|
Specifies the way how the number part of the axis label strings will be formatted.
|
|
Will be ignored for non-numerical axis labels.
|
|
|
|
\param notation The way of notation to be used for the number part.
|
|
|
|
\note If you need exponential notation with a common magnitude, just use
|
|
setAxisLabelsCalc to declare the divisor, and then add a KDChartCustomBox
|
|
to the end of your axis's area, informing the user about the magnitude to
|
|
be added to each of the values, e.g. by saying "x 1e3".
|
|
|
|
\sa KDChartEnums::NumberNotation, setAxisLabelsCalc, setAxisLabelsRadix, setAxisLabelsFormat
|
|
*/
|
|
void KDChartAxisParams::setAxisLabelsNotation( KDChartEnums::NumberNotation notation )
|
|
{
|
|
_axisLabelsNotation = notation;
|
|
}
|
|
|
|
/**
|
|
Specifies the way how the axis label strings will be formatted. Will be ignored for non-numerical axis labels.
|
|
|
|
\param prefix The character (or text, resp.) to be prepended before the string
|
|
after inserting the decimalPoint and the thousandsPoint.
|
|
\param postfix The character (or text, resp.) to be appended to the string
|
|
after adding decimalPoint, thousandsPoint, prefix.
|
|
\param totalLen The forced size of the string after adding decimalPoint,
|
|
thousandsPoint, prefix, postfix. If this parameter is set to zero
|
|
(default) no padding will be performed.
|
|
If the string has more characters than the (non-zero) value of totalLen,
|
|
the respective number of characters will be cut off at the right side.
|
|
\param padFill The padding character to be prepended before the string
|
|
(or inserted into the string, resp.) when increasing its length until
|
|
the totalLen is reached.
|
|
\param blockAlign If set to true (default) the padFill character(s) will be
|
|
inserted between the number and the prefix, if set to false they will be
|
|
prepended before the prefix.
|
|
|
|
\sa setAxisLabelsRadix, setAxisLabelsCalc
|
|
\sa setAxisLabelsNotation
|
|
\sa axisLabelsPrefix, axisLabelsPostfix, axisLabelsTotalLen
|
|
\sa axisLabelsPadFill, axisLabelsBlockAlign
|
|
*/
|
|
void KDChartAxisParams::setAxisLabelsFormat( const TQString& prefix,
|
|
const TQString& postfix,
|
|
const int& totalLen,
|
|
const TQChar& padFill,
|
|
const bool& blockAlign )
|
|
{
|
|
_axisLabelsPrefix = prefix;
|
|
_axisLabelsPostfix = postfix;
|
|
_axisLabelsTotalLen = totalLen;
|
|
_axisLabelsPadFill = padFill;
|
|
_axisLabelsBlockAlign = blockAlign;
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
\c enum LabelsFromDataRow { LabelsFromDataRowYes,
|
|
LabelsFromDataRowNo,
|
|
LabelsFromDataRowGuess };
|
|
|
|
Are the axis labels stored in a data row?
|
|
If \c LabelsFromDataRowGuess we assume yes only if
|
|
all the entries of that data row contain strings - no numbers.
|
|
|
|
\li \c LabelsFromDataRowYes = label texts are to be taken from data row
|
|
\li \c LabelsFromDataRowNo = do not take label texts from data row
|
|
\li \c LabelsFromDataRowGuess = take label texts from data row if all
|
|
entries in that row are strings (no numerical values!)
|
|
|
|
\sa setAxisValues, setAxisValueStart, setAxisValueEnd, setAxisValueDelta
|
|
\sa setLabelTextsFormDataRow
|
|
\sa axisLabelTextsFormDataRow
|
|
*/
|
|
|
|
|
|
/**
|
|
Converts the specified labels from data row enum to a string
|
|
representation.
|
|
|
|
\param mode the enum to convert
|
|
\return the string representation of the mode enum
|
|
*/
|
|
TQString KDChartAxisParams::labelsFromDataRowToString( LabelsFromDataRow mode ) {
|
|
switch( mode ) {
|
|
case LabelsFromDataRowYes:
|
|
return "Yes";
|
|
case LabelsFromDataRowNo:
|
|
return "No";
|
|
case LabelsFromDataRowGuess:
|
|
return "Guess";
|
|
default: // should not happen
|
|
qDebug( "Unknown labels from data row mode" );
|
|
return "Guess";
|
|
}
|
|
}
|
|
|
|
/**
|
|
Converts the specified string to a data row enum value.
|
|
|
|
\param string the string to convert
|
|
\return the data row mode enum value
|
|
*/
|
|
KDChartAxisParams::LabelsFromDataRow KDChartAxisParams::stringToLabelsFromDataRow( const TQString& type ) {
|
|
if( type == "Yes" )
|
|
return LabelsFromDataRowYes;
|
|
else if( type == "No" )
|
|
return LabelsFromDataRowNo;
|
|
else if( type == "Guess" )
|
|
return LabelsFromDataRowGuess;
|
|
else // should not happen
|
|
return LabelsFromDataRowGuess;
|
|
}
|
|
|
|
/**
|
|
|
|
\c enum ValueScale { ValueScaleNumerical = 0, ( have gaps here to allow specifying of additional scaling steps in between )
|
|
ValueScaleSecond = 20,
|
|
ValueScaleMinute = 30,
|
|
ValueScaleHour = 40,
|
|
ValueScaleDay = 50,
|
|
ValueScaleWeek = 60,
|
|
ValueScaleMonth = 70,
|
|
ValueScaleQuarter = 80,
|
|
ValueScaleYear = 90 };
|
|
|
|
Are axis labels scaled mumerically or fixing a time period?
|
|
If \c ValueScaleNumerical axis labels are just numbers like "item 1", "item 2"...
|
|
|
|
\li \c ValueScaleSecond = seconds
|
|
\li \c ValueScaleMinute = minutes
|
|
..
|
|
\li \c ValueScaleYear = years
|
|
|
|
\sa setAxisValues, setAxisValueStart, setAxisValueEnd, setAxisValueDelta
|
|
\sa setLabelTextsFormDataRow
|
|
\sa axisLabelTextsFormDataRow
|
|
*/
|
|
|
|
|
|
/**
|
|
|
|
Note: The following text is to become part of the setAxisValues() doku
|
|
you see below.
|
|
It shall be added once the automatic string support has been added!
|
|
|
|
|
|
Currently the following strings are supported by the automatical
|
|
numbering feature. (These strings are implemented for your convenience,
|
|
you may specify any other set of label texts by passing a \c TQStringList
|
|
pointer to \c axisLabelStringList.)
|
|
|
|
\li Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday
|
|
\li January, February, March, May, June, July, August, September, October, November, December
|
|
\li Spring, Summer, Autumn, Winter
|
|
|
|
...
|
|
|
|
To specify the start value and the way the label values
|
|
are calculated you may
|
|
|
|
\li \b either pass one of the <b>above strings</b> as start value
|
|
<br>
|
|
In this case the label texts will be taken from the respective
|
|
list restarting at the beginnig whenever the end is reached.
|
|
<br>
|
|
In case you specify a non-zero integer value for
|
|
\c axisValueDelta the width and direction
|
|
of steps will be performed accordingly:
|
|
<br>
|
|
A value of <b>1.0</b>
|
|
(specifying a step-length of 1 ) will cause every entry to be
|
|
taken.
|
|
<br>
|
|
A <b>4.0</b> would take the start entry, skip 3 entries, take
|
|
the 4th entry and so forth...
|
|
<br>
|
|
By using negative numbers you can specify backward stepping.
|
|
<br>
|
|
(Of course all non-integer values will be ignored here.)
|
|
*/
|
|
|
|
/**
|
|
<B>General axis texts setup routine.</B><BR>
|
|
Specifies how the axis limits shall be calculated
|
|
and specifies the lower and the upper limit,
|
|
the step-width and the list of strings
|
|
(if such is to be used).
|
|
|
|
\note Start and end values are \c KDChartData so you may either
|
|
specify numerical data or pass a string. <br>
|
|
However if passing a string make sure to also specify a
|
|
valid TQStringList* for \c axisLabelStringList.
|
|
In that case it could be wise to also also specify a second
|
|
TQStringList* for \c axisShortLabelsStringsList to be used in
|
|
case the axes area is not wide enough to display the
|
|
label texts in their full length.
|
|
|
|
<P>
|
|
|
|
To specify the start value and the way the label values
|
|
are calculated you may
|
|
|
|
\li \b either pass a <b>string</b> as start value
|
|
<br>
|
|
In this case the label texts will be taken from the string
|
|
list passed to the function via \c axisLabelStringList
|
|
starting with the string you specified as start value and
|
|
restarting at the beginnig whenever the end is reached.
|
|
In case the start value is not contained in the
|
|
\c axisLabelStringList list it will be ignored and labelling
|
|
will be done as if you had specified
|
|
KDCHART_AXIS_LABELS_AUTO_LIMIT as start value (see below).
|
|
<br>
|
|
In case you specify a non-zero integer value for
|
|
\c axisValueDelta the width and direction
|
|
of steps will be performed accordingly:
|
|
<br>
|
|
A value of <b>1.0</b>
|
|
(specifying a step-length of 1 ) will cause every entry
|
|
of the list to be taken.
|
|
<br>
|
|
A <b>4.0</b> would take the start entry, skip 3 entries, take
|
|
the 4th entry and so forth...
|
|
<br>
|
|
By using negative numbers you can specify backward stepping.
|
|
<br>
|
|
(Of course all non-integer values will be ignored here.)
|
|
\li \b or pass <b>KDCHART_AXIS_LABELS_AUTO_LIMIT</b> as start value
|
|
<br>
|
|
In this case the first label text <br>
|
|
<i>either</i> will be calculated
|
|
based upon the lowest value of the associated
|
|
datasets row number \c labelTextsDataRow if
|
|
\c axisLabelsFromDataRow is set to true, <br>
|
|
<i>or</i> the first entry of the texts list will be taken
|
|
if \c axisLabelStringList is set properly, <br>
|
|
<i>otherwise</i> it will be set to "1".
|
|
|
|
\li \b or pass a <b>numerical value</b> as start value
|
|
<br>
|
|
In this case the first label text will be set to that value.
|
|
<br>
|
|
<b>In either case</b> (KDCHART_AXIS_LABELS_AUTO_LIMIT or numerical value)
|
|
the \c axisValueDelta may be used to specify the value to be
|
|
added to obtain the next values:
|
|
<br>
|
|
A value of <b>1.0</b> will cause 1.0 to be added to the current
|
|
value to make the next value.
|
|
<br>
|
|
A <b>-0.25</b> would cause 0.25 to be subtracted from the current value.
|
|
<br>
|
|
(Negative or non-integer numbers are allowed here.)
|
|
|
|
<P>
|
|
|
|
Examples:
|
|
|
|
\verbatim
|
|
setAxisValues();
|
|
\endverbatim
|
|
This would specify a default ordinate-axis obtaining its values from the
|
|
attached dataset. Looks nice but it is difficult to compare it to another
|
|
chart representing slightly different min/max values since it neither starts
|
|
at zero nor ends at an allways same value.
|
|
|
|
\verbatim
|
|
setAxisValues( true, KDChartData( 0.0 ) );
|
|
\endverbatim
|
|
This would specify a half-automatical ordinate-axis obtaining its values from
|
|
the attached dataset. Looks nice and can be slightly easier compared to
|
|
another chart since it allways starts at zero, causing negative values to be
|
|
ignored completely.
|
|
|
|
\verbatim
|
|
setAxisValues( true, KDChartData( -2.0 ),
|
|
KDChartData( 7.5 ),
|
|
0.5, 1 );
|
|
\endverbatim
|
|
This would specify an ordinate-axis \not obtaining its values
|
|
from the attached dataset.
|
|
<b>Since both the start value and the end value are specified the range
|
|
of the dataset values are ignored completely.</b>
|
|
It will show one digit behind the comma.
|
|
The resulting chart can be perfectly compared to
|
|
another chart since it allways starts and ends at the very same level - no
|
|
matter what the dataset values are about actually.
|
|
|
|
\verbatim
|
|
setAxisValues( false, KDChartData( 0.0 ),
|
|
KDChartData( 3.5),
|
|
0.25, 2 );
|
|
\endverbatim
|
|
This would specify a default abscissa-axis starting with value 0.0 and
|
|
adding 0.25 to get the next value, will count until 3.5.
|
|
It will show two digits behind the comma.
|
|
|
|
\verbatim
|
|
setAxisValues( false,
|
|
KDChartData( 1964.0 ), KDCHART_AXIS_LABELS_AUTO_LIMIT, 1, 0 );
|
|
\endverbatim
|
|
This would specify a default abscissa-axis starting with value 1964 and
|
|
adding 1 to get the next value.
|
|
It will show no digits behind the comma.
|
|
|
|
\verbatim
|
|
KDChartParams p;
|
|
KDChartAxisParams pa( p.axisParams( KDChartAxisParams::AxisPosBottom ) );
|
|
|
|
TQStringList abscissaNames;
|
|
abscissaNames << "Sunday" << "Monday" << "Tuesday" << "Wednesday"
|
|
<< "Thursday" << "Friday" << "Saturday";
|
|
|
|
TQStringList abscissaShortNames;
|
|
abscissaShortNames << "Sun" << "Mon" << "Tue" << "Wed"
|
|
<< "Thu" << "Fri" << "Sat";
|
|
|
|
pa.setAxisValues( false,
|
|
KDChartData( "Monday" ),
|
|
KDCHART_AXIS_LABELS_AUTO_LIMIT,
|
|
KDCHART_AXIS_LABELS_AUTO_DELTA,
|
|
KDCHART_AXIS_LABELS_AUTO_DIGITS,
|
|
KDChartAxisParams::LabelsFromDataRowNo,
|
|
0,
|
|
&abscissaNames,
|
|
&abscissaShortNames );
|
|
p.setAxisParams( KDChartAxisParams::AxisPosBottom, pa );
|
|
\endverbatim
|
|
This would specify a default abscissa-axis starting with 'Monday' and
|
|
counting the days of the week as far as neccessary to represent
|
|
all the entries in the associated dataset.
|
|
Note this \c LabelsFromDataRowNo indicating that the texts are <b>not</b> to
|
|
be taken from a data row and note \c &abscissaNames indicating the
|
|
\c TQStringList where to take the texts from instead. (In case the axis area
|
|
is not wide enough to display the strings in their full length their
|
|
counterparts stored in abscissaShortNames will be displayed instead.)
|
|
<b>Note also:</b> The strings in those two TQStringList are <b>not</b>
|
|
copied into the \c KDChartAxisParams nor into the \c KDChartParams
|
|
so please make sure the Lists are alive and valid till the end of
|
|
the param objects. Otherwise you will not be able to display the
|
|
texts.
|
|
<P>
|
|
|
|
\param axisSteadyValueCalc specifies whether label values shall be calculataed based upon the associated dataset values (normally this is true for ordinate axes) or based upon some string list (as you might expect it for abscissa labels).
|
|
\param axisValueStart specifies first label value to be written.
|
|
\param axisValueEnd specifies the last label value to be written.
|
|
\param axisValueDelta specifies the length of the steps to be taken from one label text to the next one.
|
|
\param axisDigitsBehindComma specifies how many digits are to be shown behind the axis label texts comma.
|
|
\param axisMaxEmptyInnerSpan specifies the percentage of the y-axis range that may to contain NO data entries, if - and only if - axisValueStart (or axisValueEnd, resp.) is set to KDCHART_AXIS_LABELS_AUTO_LIMIT. To prevent \c setAxisValues from changing the current setting you may specify KDCHART_DONT_CHANGE_EMPTY_INNER_SPAN_NOW here, to deactivate taking into account the inner span entirely just use KDCHART_AXIS_IGNORE_EMPTY_INNER_SPAN.
|
|
\param takeLabelsFromDataRow specifies whether the labels texts shall be taken from a special row (reserved for this in each dataset) or not.
|
|
\param axisLabelStringList points to a \c TQStringList containing the label texts to be used.
|
|
\param axisShortLabelsStringList points to a \c TQStringList containing the label texts to be used in case their full-size counterparts cannot be shown due to limited axis area size.
|
|
\param axisValueLeaveOut is used for horizontal (top or bottom) axes only; it specifies whether some of the axis labels are to be skipped if there is not enough room for drawing them all without overlapping - this parameter may be set to KDCHART_AXIS_LABELS_AUTO_LEAVEOUT or to zero or to another positive value.
|
|
\param axisValueDeltaScale is used to specify the scaling mode of \c axisValueDelta - either just ValueScaleNumbers of a special time scale indicator.
|
|
\sa setAxisValueStart, setAxisValueEnd, setAxisValueDelta, setAxisValuesDecreasing
|
|
\sa axisValueStart axisValueEnd, axisValueDelta, ValueScale
|
|
\sa LabelsFromDataRow, axisLabelTextsFormDataRow, axisLabelTexts
|
|
\sa axisSteadyValueCalc, setAxisValueLeaveOut
|
|
*/
|
|
void KDChartAxisParams::setAxisValues( bool axisSteadyValueCalc,
|
|
const TQVariant& axisValueStart,
|
|
const TQVariant& axisValueEnd,
|
|
double axisValueDelta,
|
|
int axisDigitsBehindComma,
|
|
int axisMaxEmptyInnerSpan,
|
|
LabelsFromDataRow takeLabelsFromDataRow,
|
|
int labelTextsDataRow,
|
|
TQStringList* axisLabelStringList,
|
|
TQStringList* axisShortLabelsStringList,
|
|
int axisValueLeaveOut,
|
|
ValueScale axisValueDeltaScale )
|
|
{
|
|
_axisSteadyValueCalc = axisSteadyValueCalc;
|
|
_axisValueStart = axisValueStart;
|
|
_axisValueEnd = axisValueEnd;
|
|
_axisValueLeaveOut = axisValueLeaveOut;
|
|
_axisValueDelta = axisValueDelta;
|
|
_axisValueDeltaScale = axisValueDeltaScale;
|
|
_axisDigitsBehindComma = axisDigitsBehindComma;
|
|
if ( KDCHART_DONT_CHANGE_EMPTY_INNER_SPAN_NOW != axisMaxEmptyInnerSpan ) {
|
|
if ( 100 < axisMaxEmptyInnerSpan
|
|
|| 1 > axisMaxEmptyInnerSpan )
|
|
_axisMaxEmptyInnerSpan = KDCHART_AXIS_IGNORE_EMPTY_INNER_SPAN;
|
|
else
|
|
_axisMaxEmptyInnerSpan = axisMaxEmptyInnerSpan;
|
|
}
|
|
_takeLabelsFromDataRow = takeLabelsFromDataRow;
|
|
_labelTextsDataRow = labelTextsDataRow;
|
|
if( axisLabelStringList )
|
|
_axisLabelStringList = *axisLabelStringList;
|
|
else
|
|
_axisLabelStringList.clear();
|
|
if( axisShortLabelsStringList )
|
|
_axisShortLabelsStringList = *axisShortLabelsStringList;
|
|
else
|
|
_axisShortLabelsStringList.clear();
|
|
// label texts must be recalculated?
|
|
setAxisLabelTexts( 0 );
|
|
setTrueAxisDeltaPixels( 0.0 );
|
|
setTrueAxisLowHighDelta( 0.0, 0.0, 0.0 );
|
|
setTrueAxisDtLowHighDeltaScale( TQDateTime(), TQDateTime(), ValueScaleDay );
|
|
emit changed();
|
|
}
|
|
|
|
/**
|
|
\fn void KDChartAxisParams::setAxisValueStart( const KDChartData axisValueStart )
|
|
Specifies the lower limit for the axis labels: the start value.
|
|
|
|
\param axisValueStart the lower limit for the axis labels: the start
|
|
value.
|
|
\sa setAxisValues, setAxisValueStartIsExact
|
|
\sa setAxisValueEnd, setAxisValueDelta
|
|
\sa axisValueStart, axisValueEnd, axisValueDelta
|
|
\sa axisLabelsFromDataRow, axisLabelTexts
|
|
\sa axisLabelStringList, axisShortLabelsStringList
|
|
*/
|
|
|
|
/**
|
|
\fn KDChartData KDChartAxisParams::axisValueStart() const
|
|
Returns the lower limit for the axis labels: the start value.
|
|
|
|
\return the lower limit for the axis labels: the start value.
|
|
\sa setAxisValues, setAxisValueStart, setAxisValueStartIsExact
|
|
\sa setAxisValueEnd, setAxisValueDelta
|
|
\sa axisValueEnd, axisValueDelta
|
|
\sa axisLabelsFromDataRow, axisLabelTexts
|
|
\sa axisLabelStringList, axisShortLabelsStringList
|
|
*/
|
|
|
|
/**
|
|
\fn void setAxisValueStartIsExact( bool isExactValue )
|
|
Specifies whether the lower limit for the axis labels that
|
|
is specified via setAxisValueStart() is to be used as the
|
|
axis start value even if this will not look very nice: this is
|
|
the default, KD Chart just takes the value specified by you, e.g.
|
|
if you specify 75003.00 as start value you will get exactly this.
|
|
|
|
By setting this flag to FALSE you let KD Chart find a better
|
|
value for you: if your value is not Zero the axis will start
|
|
with the next value lower than your start value that can be
|
|
divided by the delta factor.
|
|
|
|
\param isExactValue set this to FALSE if KD Chart shall tqfind
|
|
a better value than the one you have specified by setAxisValueStart()
|
|
\sa setAxisValues, setAxisValueEnd, setAxisValueDelta
|
|
\sa axisValueStartIsExact, axisValueStart
|
|
\sa axisValueEnd, axisValueDelta
|
|
\sa axisLabelsFromDataRow, axisLabelTexts
|
|
\sa axisLabelStringList, axisShortLabelsStringList
|
|
*/
|
|
|
|
/**
|
|
\fn bool axisValueStartIsExact() const
|
|
Returns whether the lower limit for the axis labels that
|
|
is specified via setAxisValueStart() is to be used as the
|
|
axis start value even if this will not look very nice: this is
|
|
the default, KD Chart just takes the value specified by you, e.g.
|
|
if you specify 75003.00 as start value you will get exactly this.
|
|
|
|
\return whether the lower limit for the axis labels that
|
|
is specified via setAxisValueStart() is to be used as the
|
|
axis start value even if this will not look very nice.
|
|
\sa setAxisValues, setAxisValueStartIsExact, setAxisValueStart
|
|
\sa setAxisValueEnd, setAxisValueDelta
|
|
\sa axisValueEnd, axisValueDelta
|
|
\sa axisLabelsFromDataRow, axisLabelTexts
|
|
\sa axisLabelStringList, axisShortLabelsStringList
|
|
*/
|
|
|
|
|
|
/**
|
|
\fn void KDChartAxisParams::setAxisValueEnd( const KDChartData axisValueEnd )
|
|
Specifies the upper limit for the axis labels: the end value.
|
|
|
|
\param axisValueStart the upper limit for the axis labels: the end
|
|
value.
|
|
\sa setAxisValues, setAxisValueStart, setAxisValueStartIsExact
|
|
\sa setAxisValueDelta
|
|
\sa axisValueStart, axisValueEnd, axisValueDelta
|
|
\sa axisLabelsFromDataRow, axisLabelTexts
|
|
\sa axisLabelStringList, axisShortLabelsStringList
|
|
*/
|
|
|
|
/**
|
|
\fn KDChartData KDChartAxisParams::axisValueEnd() const
|
|
Returns the upper limit for the axis labels: the end value.
|
|
|
|
\return the upper limit for the axis labels: the end value.
|
|
\sa setAxisValues, setAxisValueStart, setAxisValueStartIsExact
|
|
\sa setAxisValueEnd, setAxisValueDelta
|
|
\sa axisValueStart, axisValueDelta
|
|
\sa axisLabelsFromDataRow, axisLabelTexts
|
|
\sa axisLabelStringList, axisShortLabelsStringList
|
|
*/
|
|
|
|
|
|
/**
|
|
Specifies the DELTA value for the axis labels: the distance
|
|
between two labels.
|
|
|
|
\param axisValueDelta the DELTA value for the axis labels: the distance
|
|
between two labels.
|
|
\param scale the scaling of the DELTA value
|
|
\sa ValueScale
|
|
\sa setAxisValues
|
|
\sa setAxisValueStart, setAxisValueStartIsExact
|
|
\sa setAxisValueEnd, setAxisValueDelta
|
|
\sa axisValueStart, axisValueEnd, axisValueDelta
|
|
\sa axisLabelsFromDataRow, axisLabelTexts
|
|
\sa axisLabelStringList, axisShortLabelsStringList
|
|
*/
|
|
void KDChartAxisParams::setAxisValueDelta( const double axisValueDelta,
|
|
ValueScale scale )
|
|
{
|
|
_axisValueDelta = axisValueDelta;
|
|
_axisValueDeltaScale = scale;
|
|
}
|
|
|
|
/**
|
|
\fn double KDChartAxisParams::axisValueDelta() const
|
|
Returns the DELTA value for the axis labels: the distance
|
|
between two labels.
|
|
|
|
\return the DELTA value for the axis labels: the distance
|
|
between two labels.
|
|
\sa setAxisValueDelta
|
|
*/
|
|
|
|
|
|
/**
|
|
\fn ValueScale KDChartAxisParams::axisValueDeltaScale() const
|
|
Returns the DELTA value scaling mode for the axis labels
|
|
|
|
\sa setAxisValueDelta
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
\fn void KDChartAxisParams::setAxisValueLeaveOut( const int leaveOut )
|
|
Specifies how many axis labels are to be skipped
|
|
if there is not enough space for displaying all of them.
|
|
This is usefull in case you have lots of entries in one dataset.
|
|
|
|
\sa setAxisValues
|
|
*/
|
|
/**
|
|
\fn int KDChartAxisParams::axisValueLeaveOut() const
|
|
Returns how many axis labels are to be skipped
|
|
if there is not enough space for displaying all of them.
|
|
|
|
\sa setAxisValueLeaveOut
|
|
*/
|
|
|
|
/**
|
|
\fn void KDChartAxisParams::setAxisValuesDecreasing( bool valuesDecreasing )
|
|
Specifies whether axis values should be printed in reverted order: starting
|
|
with the highest label and decreasing until the lowest label is reached.
|
|
|
|
\note This feature is supported for LINE charts only.
|
|
|
|
\sa setAxisValues
|
|
*/
|
|
|
|
/**
|
|
\fn bool KDChartAxisParams::axisValuesDecreasing() const
|
|
Returns whether axis values should be printed in reverted order: starting
|
|
with the highest label and decreasing until the lowest label is reached.
|
|
|
|
\note This feature is supported for LINE charts only.
|
|
|
|
\sa setAxisValuesDecreasing
|
|
*/
|
|
|
|
/**
|
|
\fn void KDChartAxisParams::setTrueAxisDeltaPixels( double nDeltaPixels )
|
|
Specifies the true axis pixel distance between two label delimiters.
|
|
|
|
\param nDeltaPixels the true value as it was calculated.
|
|
|
|
\note Do <b>not call</b> this function unless you are knowing
|
|
exactly what you are doing. \c setTrueAxisDeltaPixels is normally
|
|
reserved for internal usage by methods calculating the axis
|
|
label texts. Thus the signal \c changed() is not sended here.
|
|
|
|
\sa trueAxisDeltaPixels, trueAxisLow, trueAxisHigh, trueAxisDelta
|
|
\sa setAxisArea
|
|
*/
|
|
|
|
/**
|
|
\fn double KDChartAxisParams::trueAxisDeltaPixels() const
|
|
Returns the <b>true</b> delimiter delta pixel value of the axis labels
|
|
as is was calculated and set by \c setTrueAxisDeltaPixels.
|
|
|
|
\return the true delimiter delta pixel value of the axis labels
|
|
\sa setAxisValues
|
|
\sa trueAxisLow, trueAxisHigh, trueAxisDelta
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
Specifies the true axis lower and upper limit values of the axis
|
|
and the exact Delta value between the axis delimiters.
|
|
|
|
\param nLow/nHigh/nDelta the true values as they were calculated.
|
|
|
|
\note Do <b>not call</b> this function unless you are knowing
|
|
exactly what you are doing. \c setAxisTrueAreaSize is normally
|
|
reserved for internal usage by methods calculating the axis
|
|
label texts. Thus the signal \c changed() is not sended here.
|
|
|
|
\sa trueAxisLow, trueAxisHigh, trueAxisDelta, trueAxisDeltaPixels
|
|
\sa setAxisArea
|
|
*/
|
|
void KDChartAxisParams::setTrueAxisLowHighDelta( double nLow, double nHigh, double nDelta )
|
|
{
|
|
_trueLow = nLow;
|
|
_trueHigh = nHigh;
|
|
_trueDelta = nDelta;
|
|
|
|
}
|
|
|
|
|
|
/**
|
|
\fn double KDChartAxisParams::trueAxisLow() const
|
|
Returns the <b>true</b> start value of the ordinate axis labels
|
|
as is was calculated and set by \c setTrueAxisLowHighDelta.
|
|
|
|
\return the true lower limit of the axis labels
|
|
\sa setAxisValues
|
|
\sa trueAxisHigh, trueAxisDelta, trueAxisDeltaPixels
|
|
*/
|
|
|
|
/**
|
|
\fn double KDChartAxisParams::trueAxisHigh() const
|
|
Returns the <b>true</b> end value of the ordinate axis labels
|
|
as is was calculated and set by \c setTrueAxisLowHighDelta.
|
|
|
|
\return the true upper limit of the axis labels
|
|
\sa setAxisValues
|
|
\sa trueAxisLow, trueAxisDelta, trueAxisDeltaPixels
|
|
*/
|
|
|
|
/**
|
|
\fn double KDChartAxisParams::trueAxisDelta() const
|
|
Returns the <b>true</b> delta value of the ordinate axis labels
|
|
as is was calculated and set by \c setTrueAxisLowHighDelta.
|
|
|
|
\return the true delta value of the axis labels
|
|
\sa setAxisValues
|
|
\sa trueAxisLow, trueAxisHigh, trueAxisDeltaPixels
|
|
*/
|
|
|
|
|
|
|
|
void KDChartAxisParams::setTrueAxisDtLowHighDeltaScale( TQDateTime dtLow, TQDateTime dtHigh,
|
|
ValueScale dtDeltaScale )
|
|
{
|
|
_trueDtLow = dtLow;
|
|
_trueDtHigh = dtHigh;
|
|
_trueDtDeltaScale = dtDeltaScale;
|
|
}
|
|
|
|
/**
|
|
\fn void KDChartAxisParams::setTrueAxisDtLow( TQDateTime dtLow )
|
|
|
|
*/
|
|
|
|
/**
|
|
\fn void KDChartAxisParams::void setTrueAxisDtHigh( TQDateTime dtHigh )
|
|
|
|
*/
|
|
|
|
/**
|
|
\fn void KDChartAxisParams::void setTrueAxisDtScale( ValueScale scale )
|
|
|
|
*/
|
|
|
|
/**
|
|
\fn void KDChartAxisParams::TQDateTime trueAxisDtLow() const
|
|
|
|
*/
|
|
|
|
/**
|
|
\fn void KDChartAxisParams::TQDateTime trueAxisDtHigh() const
|
|
|
|
*/
|
|
|
|
/**
|
|
\fn void KDChartAxisParams::ValueScale trueAxisDtDeltaScale() const
|
|
|
|
*/
|
|
|
|
|
|
/**
|
|
Specifies the not-rounded screen positions where drawing of
|
|
this axis zero line started.
|
|
|
|
\Note You may not call this internal function - it is reserved for
|
|
internal usage of methodes needing to know the zero-line offsets
|
|
|
|
\param Pt the not-rounded screen positions where drawing of
|
|
this axis zero line started.
|
|
|
|
\sa axisZeroLineStartX, axisZeroLineStartY
|
|
*/
|
|
void KDChartAxisParams::setAxisZeroLineStart( double x, double y )
|
|
{
|
|
_axisZeroLineStartX = x;
|
|
_axisZeroLineStartY = y;
|
|
}
|
|
|
|
/**
|
|
\fn double KDChartAxisParams::axisZeroLineStartX() const
|
|
Returns the not-rounded x-position where drawing of
|
|
this axis zero line started. This function needed
|
|
when painting the data of isometric axes (bars, lines, dots...).
|
|
|
|
\return the unrounded x-position where drawing of
|
|
this axis zero line started.
|
|
|
|
\sa setAxisZeroLineStart, axisZeroLineStartY
|
|
*/
|
|
|
|
/**
|
|
\fn double KDChartAxisParams::axisZeroLineStartY() const
|
|
Returns the not-rounded y-position where drawing of
|
|
this axis zero line started. This function needed
|
|
when painting the data of isometric axes (bars, lines, dots...).
|
|
|
|
\return the unrounded y-position where drawing of
|
|
this axis zero line started.
|
|
|
|
\sa setAxisZeroLineStart, axisZeroLineStartX
|
|
*/
|
|
|
|
/**
|
|
Specifies the not-rounded screen positions where drawing of
|
|
this axis low date/time value could be done.
|
|
|
|
\Note You may not call this internal function - it is reserved for
|
|
internal usage of methodes needing to know the zero-line offsets
|
|
|
|
\param Pt the not-rounded screen positions where drawing of
|
|
this axis low date/time value could be done.
|
|
|
|
\sa axisDtLowPosX, axisDtLowPosY
|
|
*/
|
|
void KDChartAxisParams::setAxisDtLowPos( double x, double y )
|
|
{
|
|
_axisDtLowPosX = x;
|
|
_axisDtLowPosY = y;
|
|
}
|
|
|
|
/**
|
|
\fn double void KDChartAxisParams::axisDtLowPosX() const
|
|
Returns the not-rounded x-position where drawing of
|
|
this axis low date/time value could be done. This function needed
|
|
when painting the data of isometric axes (bars, lines, dots...).
|
|
|
|
\return the unrounded x-position where drawing of
|
|
this axis low date/time value could be done.
|
|
|
|
\sa setAxisDtLowPos, axisDtLowPosY
|
|
*/
|
|
|
|
/**
|
|
\fn double KDChartAxisParams::axisDtLowPosY() const
|
|
Returns the not-rounded y-position where drawing of
|
|
this axis low date/time value could be done. This function needed
|
|
when painting the data of isometric axes (bars, lines, dots...).
|
|
|
|
\return the unrounded y-position where drawing of
|
|
this axis low date/time value could be done.
|
|
|
|
\sa setAxisDtLowPos, axisDtLowPosX
|
|
*/
|
|
|
|
|
|
/**
|
|
Specifies the not-rounded screen positions where drawing of
|
|
this axis high date/time value could be done.
|
|
|
|
\Note You may not call this internal function - it is reserved for
|
|
internal usage of methodes needing to know the zero-line offsets
|
|
|
|
\param Pt the not-rounded screen positions where drawing of
|
|
this axis high date/time value could be done.
|
|
|
|
\sa axisDtHighPosX, axisDtHighPosY
|
|
*/
|
|
void KDChartAxisParams::setAxisDtHighPos( double x, double y )
|
|
{
|
|
_axisDtHighPosX = x;
|
|
_axisDtHighPosY = y;
|
|
}
|
|
|
|
/**
|
|
\fn double KDChartAxisParams::axisDtHighPosX() const
|
|
Returns the not-rounded x-position where drawing of
|
|
this axis high date/time value could be done. This function needed
|
|
when painting the data of isometric axes (bars, lines, dots...).
|
|
|
|
\return the unrounded x-position where drawing of
|
|
this axis high date/time value could be done.
|
|
|
|
\sa setAxisDtHighPos, axisDtHighPosY
|
|
*/
|
|
|
|
/**
|
|
\fn double KDChartAxisParams::axisDtHighPosY() const
|
|
Returns the not-rounded y-position where drawing of
|
|
this axis high date/time value could be done. This function needed
|
|
when painting the data of isometric axes (bars, lines, dots...).
|
|
|
|
\return the unrounded y-position where drawing of
|
|
this axis high date/time value could be done.
|
|
|
|
\sa setAxisDtHighPos, axisDtHighPosX
|
|
*/
|
|
|
|
|
|
/**
|
|
\fn void KDChartAxisParams::setAxisDigitsBehindComma( const int digits )
|
|
Specifies the number of digits to be printed behind the comma
|
|
on the axis labels.
|
|
|
|
\param digits the number of digits to be printed behind the comma
|
|
on the axis labels.
|
|
|
|
\sa axisDigitsBehindComma
|
|
*/
|
|
|
|
/**
|
|
\fn int KDChartAxisParams::axisDigitsBehindComma() const
|
|
Returns the number of digits to be printed behind the comma
|
|
on the axis labels.
|
|
|
|
\return the number of digits to be printed behind the comma
|
|
on the axis labels.
|
|
\sa setAxisValues
|
|
\sa axisValueStart
|
|
\sa axisLabelsFromDataRow, axisLabelTexts
|
|
\sa axisLabelStringList, axisShortLabelsStringList
|
|
\sa setAxisLabelStringLists
|
|
*/
|
|
|
|
/**
|
|
\fn void KDChartAxisParams::setAxisLabelsDateTimeFormat( const TQString& format )
|
|
Specifies the format to be used for displaying abscissa axis
|
|
TQDateTime item labels.
|
|
|
|
\note This feature is only available when using TQt 3.0 or newer,
|
|
previous versions use a non changable format.
|
|
|
|
To calculate the format automatically (based on the
|
|
time span to be displayed) use the special value
|
|
\c KDCHART_AXIS_LABELS_AUTO_DATETIME_FORMAT - this is the default setting.
|
|
|
|
See TQt documentation on the format to be used here:
|
|
|
|
$TQTDIR/doc/html/qdatetime.html#toString-2
|
|
|
|
\note Insert a '\n' character if you want to print the labels in two rows, e.g. "h:mm:ss\nd.MM.yyyy" would do that.
|
|
|
|
\sa axisLabelsDateTimeFormat
|
|
*/
|
|
|
|
/**
|
|
\fn TQString KDChartAxisParams::axisLabelsDateTimeFormat() const
|
|
Returns the format to be used for displaying abscissa axis
|
|
TQDateTime item labels.
|
|
|
|
\sa setAxisLabelsDateTimeFormat
|
|
*/
|
|
|
|
|
|
/**
|
|
\fn void KDChartAxisParams::setAxisMaxEmptyInnerSpan( const int maxEmpty )
|
|
Specifies the percentage of the y-axis range that may to contain NO
|
|
data entries, if - and only if - axisValueStart (or axisValueEnd,
|
|
resp.) is set to KDCHART_AXIS_LABELS_AUTO_LIMIT.
|
|
|
|
\param maxEmpty the percentage of the y-axis range that may to contain NO
|
|
data entries, if - and only if - axisValueStart (or axisValueEnd,
|
|
resp.) is set to KDCHART_AXIS_LABELS_AUTO_LIMIT.
|
|
|
|
\sa axisMaxEmptyInnerSpan
|
|
*/
|
|
|
|
/**
|
|
\fn int KDChartAxisParams::axisMaxEmptyInnerSpan() const
|
|
Returns the percentage of the y-axis range that may to contain NO
|
|
data entries, if - and only if - axisValueStart (or axisValueEnd,
|
|
resp.) is set to KDCHART_AXIS_LABELS_AUTO_LIMIT.
|
|
|
|
\note If more space is empty the zero-line will not be included info the chart but the lowest (or highest, resp.) entry of the axis will be shifted accordingly.
|
|
\sa setAxisValues
|
|
*/
|
|
|
|
|
|
/**
|
|
Specifies whether the axis labels are stored in a data row.
|
|
If \c LabelsFromDataRowGuess we assume yes only if
|
|
all the entries of that data row contain strings - no numbers.
|
|
|
|
\note Calling this function results in overwriting the information
|
|
that you might have set by previous calls of that function.
|
|
Only <b>one</b> data row can be specified as containing label texts.
|
|
To specify a data row that tqcontains (or might contain) axis label texts just
|
|
call this function with \c LabelsFromDataRowYes (or \c LabelsFromDataRowGuess,
|
|
resp.) specifying this row but do <b>not</b> call the function n times with
|
|
the \c LabelsFromDataRowNo parameter to 'deactivate' the other rows.
|
|
The \c LabelsFromDataRowNo should be used to specify that <b>none</b> of
|
|
the data rows is containing the axis label texts (this is the default
|
|
setting).
|
|
|
|
\param row the data row number that tqcontains (or might contain, resp.) the labels
|
|
\param mode the state of our information concerning that row (see: \c LabelsFromDataRow)
|
|
|
|
\sa LabelsFromDataRow, axisLabelTextsFormDataRow, setAxisValues
|
|
*/
|
|
void KDChartAxisParams::setLabelTextsFormDataRow( int row, LabelsFromDataRow mode )
|
|
{
|
|
_labelTextsDataRow = row;
|
|
_takeLabelsFromDataRow = mode;
|
|
}
|
|
|
|
|
|
/**
|
|
\fn void void KDChartAxisParams::setLabelTextsFormDataRow( int row, LabelsFromDataRow mode );
|
|
Returns whether the axis labels will be taken from the associated dataset.
|
|
|
|
\return whether the axis limits will be taken from the associated dataset.
|
|
\sa setAxisValues
|
|
\sa axisValueStart, axisValueEnd
|
|
\sa axisLabelsFromDataRow, axisLabelTexts
|
|
*/
|
|
|
|
|
|
/**
|
|
\fn int KDChartAxisParams::labelTextsDataRow() const
|
|
Returns the number of the data row that tqcontains (or might contain,
|
|
resp.) the texts to be taken for the axis labels.
|
|
<br>
|
|
Use \c axisLabelTextsFormDataRow to make sure the texts are
|
|
to be taken from that row.
|
|
<br>
|
|
Use \c axisLabelStringList to get a TQStringList* of texts from
|
|
which the texts to be drawn will be taken.
|
|
|
|
Use \c axisShortLabelsStringList to get a TQStringList* of texts from
|
|
which the texts to be drawn will be taken in case the axis area size
|
|
is too small to display their full-size counterparts stored in
|
|
\c axisLabelStringList.
|
|
|
|
Use \c axisLabelTexts to get a TQStringList* containing the label
|
|
texts that are <b>actually</b> drawn at the axis.
|
|
|
|
\return the number of the data row that tqcontains (or might contain,
|
|
resp.) the texts to be taken for the axis labels.
|
|
\sa setAxisValues
|
|
\sa axisValueStart, axisValueEnd
|
|
\sa axisLabelsFromDataRow, axisLabelTexts
|
|
\sa axisLabelStringList, axisShortLabelsStringList
|
|
*/
|
|
|
|
|
|
/**
|
|
Specifies a \c TQStringList which the axis label texts are to
|
|
be taken from, the second parameter (if not zero) specifies an
|
|
alternative list of strings that are to be displayed in case
|
|
the axis area size is too small for showing the full-length names.
|
|
|
|
\note Normally axis labeling starts with the list's first string
|
|
and end with its last string, but by specifying a start and an
|
|
end value as additional parameters you can make KDChart repeat
|
|
the strings between these two values only, as shown here:
|
|
|
|
\verbatim
|
|
TQStringList abscissaNames;
|
|
abscissaNames << "Sunday" << "Monday" << "Tuesday" << "Wednesday"
|
|
<< "Thursday" << "Friday" << "Saturday";
|
|
TQStringList abscissaShortNames;
|
|
abscissaShortNames << "Sun" << "Mon" << "Tue" << "Wed"
|
|
<< "Thu" << "Fri" << "Sat";
|
|
|
|
KDChartAxisParams pa( _p->axisParams(
|
|
KDChartAxisParams::AxisPosBottom ) );
|
|
|
|
setAxisLabelStringParams( &abscissaNames,
|
|
&abscissaShortNames,
|
|
"Monday",
|
|
"Friday")
|
|
|
|
_p->setAxisParams( KDChartAxisParams::AxisPosBottom, pa );
|
|
\endverbatim
|
|
|
|
|
|
\param TQStringList* axisLabelStringList points to the list of labels to be displayed
|
|
\param TQStringList* axisShortLabelStringList points to
|
|
an alternative list of short names to be displayed if the long labels take too much place
|
|
\param TQString valueStart ( default null ) the label to begin with
|
|
\param TQString valueEnd ( default null ) the label to end with
|
|
|
|
\sa KDChartParams::setAxisLabelStringParams
|
|
\sa axisLabelStringList, axisShortLabelsStringList
|
|
\sa setAxisValues, setLabelTextsFormDataRow
|
|
\sa axisLabelTexts
|
|
*/
|
|
void KDChartAxisParams::setAxisLabelStringLists( TQStringList* axisLabelStringList,
|
|
TQStringList* axisShortLabelStringList,
|
|
const TQString& valueStart,
|
|
const TQString& valueEnd )
|
|
{
|
|
TQVariant axisValueStart, axisValueEnd;
|
|
|
|
if( valueStart.isNull() )
|
|
axisValueStart = KDCHART_AXIS_LABELS_AUTO_LIMIT;
|
|
else
|
|
axisValueStart = valueStart;
|
|
|
|
if( valueEnd.isNull() )
|
|
axisValueEnd = KDCHART_AXIS_LABELS_AUTO_LIMIT;
|
|
else
|
|
axisValueEnd = valueEnd;
|
|
|
|
setAxisValues( false,
|
|
axisValueStart,
|
|
axisValueEnd,
|
|
KDCHART_AXIS_LABELS_AUTO_DELTA,
|
|
KDCHART_AXIS_LABELS_AUTO_DIGITS,
|
|
KDCHART_AXIS_IGNORE_EMPTY_INNER_SPAN,
|
|
LabelsFromDataRowNo,
|
|
0,
|
|
axisLabelStringList,
|
|
axisShortLabelStringList,
|
|
KDCHART_AXIS_LABELS_AUTO_LEAVEOUT );
|
|
|
|
}
|
|
|
|
|
|
/**
|
|
\fn TQStringList KDChartAxisParams::axisLabelStringList() const
|
|
Returns a \c TQStringList containing the label texts to be used.
|
|
|
|
Calling \c axisShortLabelsStringList() instead will return
|
|
another \c TQStringList containing the label texts to be displayed
|
|
in case the axis area size is too small to show the full-size names.
|
|
|
|
\note This is the list of texts you specified by \c setAxisValues
|
|
or by \c setAxisLabelStringLists.
|
|
The texts <b>actually</b> drawn at the axis are <b>not neccessarily</b> the
|
|
same as the ones in this list since (regarding Start and/or End and/or
|
|
Delta value) they might be only a subset of this list. Whenever label texts
|
|
are calculated automatically the resulting labels are also stored in a
|
|
second list that you may access via \c axisLabelTexts().
|
|
|
|
\return a \c TQStringList containing the label texts to be used.
|
|
\sa axisShortLabelsStringList
|
|
\sa setAxisLabelStringLists
|
|
\sa setAxisValues
|
|
\sa axisValueStart, axisValueEnd, axisLabelTexts
|
|
\sa axisLabelsFromDataRow, setLabelTextsFormDataRow
|
|
*/
|
|
|
|
/**
|
|
\fn uint KDChartAxisParams::axisLabelStringCount() const
|
|
Returns the number of strings stored as label texts,
|
|
the texts can be retrieved by calling \c axisLabelStringList().
|
|
|
|
\sa axisShortLabelsStringCount
|
|
\sa axisLabelStringList, axisShortLabelsStringList
|
|
*/
|
|
|
|
/**
|
|
\fn TQStringList KDChartAxisParams::axisShortLabelsStringList() const
|
|
Returns a \c TQStringList containing the label texts to be used
|
|
in case the axis area size is too small to show the full-size
|
|
label texts.
|
|
|
|
Calling \c axisLabelStringList() instead will return
|
|
another \c TQStringList containing their full-size counterparts.
|
|
|
|
\note This is the list of texts you specified by \c setAxisValues
|
|
or by \c setAxisShortLabelsStringList.
|
|
The texts <b>actually</b> drawn at the axis are <b>not neccessarily</b> the
|
|
same as the ones in this list since (regarding Start and/or End and/or
|
|
Delta value) they might be only a subset of this list. Whenever label texts
|
|
are calculated automatically the resulting labels are also stored in a
|
|
second list that you may access via \c axisLabelTexts().
|
|
|
|
\return a \c TQStringList containing the label texts to be used
|
|
in case the axis area size is too small to show the full-size
|
|
label texts.
|
|
\sa axisLabelStringList
|
|
\sa setAxisLabelStringLists
|
|
\sa setAxisValues
|
|
\sa axisValueStart, axisValueEnd, axisLabelTexts
|
|
\sa axisLabelsFromDataRow, setLabelTextsFormDataRow
|
|
*/
|
|
|
|
/**
|
|
\fn uint KDChartAxisParamsaxisShortLabelsStringCount() const
|
|
Returns the number of strings stored as label texts,
|
|
the texts can be retrieved by calling \c axisLabelStringList().
|
|
|
|
\sa axisLabelStringCount
|
|
\sa axisLabelStringList, axisShortLabelsStringList
|
|
*/
|
|
|
|
|
|
/**
|
|
\fn const TQStringList* KDChartAxisParamsaxisLabelTexts() const
|
|
Returns a \c TQStringList containing the label texts
|
|
that are <b>actually</b> drawn at the axis.
|
|
|
|
In case the texts are unknown returns zero.
|
|
|
|
\note This is the list of texts <b>actually</b> drawn at the axis.
|
|
This strings are not neccessarily the same as the ones in the list given by
|
|
\c setAxisValues since (regarding Start and/or End and/or Delta value) it
|
|
might be only a subset of that list. Whenever labels text are calculated
|
|
automatically the resulting labels also stored in this list - it will
|
|
allways be a true copy of the texts painted at the axis.
|
|
|
|
\return a \c TQStringList containing the label texts actually being used.
|
|
\sa setAxisValues
|
|
\sa axisValueStart, axisValueEnd, axisLabelStringList
|
|
\sa axisLabelsFromDataRow, setLabelTextsFormDataRow
|
|
\sa setAxisLabelStringLists, setAxisValues
|
|
*/
|
|
|
|
|
|
|
|
/**
|
|
Specifies the label texts that are <b>actually</b> drawn
|
|
at the axis labels.
|
|
|
|
\note Do not call this function unless you know what you are
|
|
doing. It is used internally whenever the texts to be drawn
|
|
have been re-calculated or the charts parameters have changed.
|
|
For specifying another list of strings to be used as label texts
|
|
you might rather want to call \c setAxisLabelStringLists() or
|
|
\c setLabelTextsFormDataRow() depending from whether your texts
|
|
are stored in a \c TQStringList or in a data row.
|
|
|
|
\param axisLabelTexts specifies the texts that are
|
|
<b>actually</b> drawn at the axis labels are unknown.
|
|
|
|
\sa setAxisLabelStringLists, setLabelTextsFormDataRow, setAxisValues
|
|
\sa setAxisFirstLabelText, setAxisLastLabelText
|
|
*/
|
|
void KDChartAxisParams::setAxisLabelTexts( const TQStringList* axisLabelTexts )
|
|
{
|
|
_axisLabelTexts.clear();
|
|
_axisLabelTextsDirty = ( 0 == axisLabelTexts );
|
|
if ( !_axisLabelTextsDirty )
|
|
_axisLabelTexts = *axisLabelTexts;
|
|
}
|
|
|
|
/**
|
|
\fn void KDChartAxisParamssetAxisLabelTextsDirty( bool axisLabelTextsDirty )
|
|
Specifies whether the label texts are <b>actually</b> drawn
|
|
at the axis labels are unknown. If \c false, they could
|
|
successfully be retrieved by \c axisLabelTexts().
|
|
|
|
\note Do not call this function unless you know what you are
|
|
doing. It is used internally whenever the texts to be drawn
|
|
have been re-calculated or the charts parameters have changed.
|
|
For specifying another list of strings to be used as label texts
|
|
you might rather want to call \c setAxisLabelStringLists() or
|
|
\c setLabelTextsFormDataRow() depending from whether your texts
|
|
are stored in a \c TQStringList or in a data row.
|
|
|
|
\param axisLabelTextsDirty specifies whether the texts are
|
|
<b>actually</b> drawn at the axis labels are unknown.
|
|
|
|
\sa setAxisLabelStringLists, setLabelTextsFormDataRow, setAxisValues
|
|
*/
|
|
|
|
/**
|
|
\fn bool KDChartAxisParams::axisLabelTextsDirty() const
|
|
Returns whether the label texts that are <b>actually</b> drawn
|
|
at the axis labels are unknown. If \c false, they could
|
|
successfully be retrieved by \c axisLabelTexts().
|
|
|
|
\return whether the texts that are <b>actually</b> drawn at
|
|
the axis labels are unknown.
|
|
|
|
\sa setAxisLabelStringLists, setLabelTextsFormDataRow, setAxisValues
|
|
*/
|
|
|
|
|
|
/**
|
|
Sets a special text that is to be displayed _instead_of_
|
|
the first axis label IF the parameter is not a NULL string.
|
|
|
|
\note This function does not affect axis label and axis range
|
|
calculation but it replaces the first label after all calculation
|
|
is done. This may be used in case you want to replace the first
|
|
label by some special text string, e.g. you might want to display
|
|
the text "origo" instead of the start value.
|
|
|
|
To remove a first label string that was set by a previous call of this
|
|
function just call it again, with no parameter.
|
|
|
|
\param axisFirstLabelText specifies the text that is
|
|
<b>actually</b> drawn as the first label: a NULL string
|
|
( as produced by TQString() ) will be ignored, to suppress
|
|
the first label please specify an EMPTY but NOT NULL string
|
|
by passing "" as parameter.
|
|
|
|
|
|
\sa setAxisLastLabelText
|
|
\sa setAxisLabelStringLists, setLabelTextsFormDataRow, setAxisValues
|
|
*/
|
|
void KDChartAxisParams::setAxisFirstLabelText( const TQString& axisFirstLabelText )
|
|
{
|
|
_axisFirstLabelText = axisFirstLabelText;
|
|
}
|
|
|
|
/**
|
|
Sets a special text that is to be displayed _instead_of_
|
|
the last axis label IF the parameter is not a NULL string.
|
|
|
|
\note This function does not affect axis label and axis range
|
|
calculation but it replaces the last label after all calculation
|
|
is done. This may be used in case you want to replace the last
|
|
label by some special text string, e.g. you might want to display
|
|
the text "maximum" instead of the end value.
|
|
|
|
To remove a last label string that was set by a previous call of this
|
|
function just call it again, with no parameter.
|
|
|
|
\param axisFirstLabelText specifies the text that is
|
|
<b>actually</b> drawn as the last label: a NULL string
|
|
( as produced by TQString() ) will be ignored, to suppress
|
|
the first label please specify an EMPTY but NOT NULL string
|
|
by passing "" as parameter.
|
|
|
|
\sa setAxisFirstLabelText
|
|
\sa setAxisLabelStringLists, setLabelTextsFormDataRow, setAxisValues
|
|
*/
|
|
void KDChartAxisParams::setAxisLastLabelText( const TQString& axisLastLabelText )
|
|
{
|
|
_axisLastLabelText = axisLastLabelText;
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
\fn void KDChartAxisParams::setAxisSteadyValueCalc( bool axisSteadyValueCalc )
|
|
Specifies whether label values shall be calculated based upon the
|
|
associated dataset values (normally this is true for ordinate axes)
|
|
or based upon some string list (as you might expect it for abscissa
|
|
labels).
|
|
|
|
\sa setAxisValues
|
|
*/
|
|
|
|
/**
|
|
\fn bool KDChartAxisParams::axisSteadyValueCalc() const
|
|
Returns whether label values shall be calculataed based upon the associated
|
|
dataset values (normally this is true for ordinate axes) or based upon some
|
|
string list (as you might expect it for abscissa labels).
|
|
|
|
\sa setAxisValues
|
|
*/
|
|
|
|
/**
|
|
\fn KDChartAxisParams::KDChartAxisParams( const KDChartAxisParams& R ) : TQObject()
|
|
Copy-constructor: By calling the copy method,
|
|
see also the assignment operator.
|
|
*/
|
|
|
|
|
|
/**
|
|
Assignment operator: By calling the copy method,
|
|
see also the copy constructor.
|
|
*/
|
|
|
|
KDChartAxisParams& KDChartAxisParams::operator=( const KDChartAxisParams& R )
|
|
{
|
|
if ( this != &R )
|
|
deepCopy( *this, R );
|
|
return *this;
|
|
}
|
|
|
|
void KDChartAxisParams::deepCopy( KDChartAxisParams& D, const KDChartAxisParams& R )
|
|
{
|
|
D._axisType = R._axisType;
|
|
D._axisVisible = R._axisVisible;
|
|
D._axisAreaMode = R._axisAreaMode;
|
|
D._axisUseAvailableSpaceFrom = R._axisUseAvailableSpaceFrom;
|
|
D._axisUseAvailableSpaceTo = R._axisUseAvailableSpaceTo;
|
|
D._axisAreaMin = R._axisAreaMin;
|
|
D._axisAreaMax = R._axisAreaMax;
|
|
D._axisCalcMode = R._axisCalcMode;
|
|
D._axisIsoRefAxis = R._axisIsoRefAxis;
|
|
D._axisTrueAreaSize = R._axisTrueAreaSize;
|
|
D._axisTrueAreaRect = R._axisTrueAreaRect;
|
|
D._axisZeroLineStartX = R._axisZeroLineStartX;
|
|
D._axisZeroLineStartY = R._axisZeroLineStartY;
|
|
D._axisDtLowPosX = R._axisDtLowPosX;
|
|
D._axisDtLowPosY = R._axisDtLowPosY;
|
|
D._axisDtHighPosX = R._axisDtHighPosX;
|
|
D._axisDtHighPosY = R._axisDtHighPosY;
|
|
D._axisLineVisible = R._axisLineVisible;
|
|
D._axisLineWidth = R._axisLineWidth;
|
|
D._axisTrueLineWidth = R._axisTrueLineWidth;
|
|
D._axisLineColor = R._axisLineColor;
|
|
// main grid:
|
|
D._axisShowFractionalValuesDelimiters = R._axisShowFractionalValuesDelimiters;
|
|
D._axisShowGrid = R._axisShowGrid;
|
|
D._axisGridColor = R._axisGridColor;
|
|
D._axisGridLineWidth = R._axisGridLineWidth;
|
|
D._axisGridStyle = R._axisGridStyle;
|
|
// sub grid:
|
|
D._axisShowSubDelimiters = R._axisShowSubDelimiters;
|
|
D._axisGridSubColor = R._axisGridSubColor;
|
|
D._axisGridSubLineWidth = R._axisGridSubLineWidth;
|
|
D._axisGridSubStyle = R._axisGridSubStyle;
|
|
|
|
D._axisZeroLineColor = R._axisZeroLineColor;
|
|
D._axisLabelsVisible = R._axisLabelsVisible;
|
|
D._axisLabelsFont = R._axisLabelsFont;
|
|
D._axisLabelsFontUseRelSize = R._axisLabelsFontUseRelSize;
|
|
D._axisLabelsDontShrinkFont = R._axisLabelsDontShrinkFont;
|
|
D._axisLabelsDontAutoRotate = R._axisLabelsDontAutoRotate;
|
|
D._axisLabelsRotation = R._axisLabelsRotation;
|
|
D._axisLabelsFontRelSize = R._axisLabelsFontRelSize;
|
|
D._axisLabelsFontMinSize = R._axisLabelsFontMinSize;
|
|
D._axisLabelsColor = R._axisLabelsColor;
|
|
|
|
D._axisSteadyValueCalc = R._axisSteadyValueCalc;
|
|
D._axisValueStartIsExact = R._axisValueStartIsExact;
|
|
D._axisValueStart = R._axisValueStart;
|
|
D._axisValueEnd = R._axisValueEnd;
|
|
D._axisValueDelta = R._axisValueDelta;
|
|
D._axisValueDeltaScale = R._axisValueDeltaScale;
|
|
D._axisValueLeaveOut = R._axisValueLeaveOut;
|
|
D._axisValuesDecreasing = R._axisValuesDecreasing;
|
|
D._axisDigitsBehindComma = R._axisDigitsBehindComma;
|
|
D._axisLabelsDateTimeFormat = R._axisLabelsDateTimeFormat;
|
|
D._axisMaxEmptyInnerSpan = R._axisMaxEmptyInnerSpan;
|
|
D._takeLabelsFromDataRow = R._takeLabelsFromDataRow;
|
|
D._labelTextsDataRow = R._labelTextsDataRow;
|
|
D._axisLabelStringList = R._axisLabelStringList;
|
|
D._axisShortLabelsStringList = R._axisShortLabelsStringList;
|
|
D._axisLabelTextsDirty = R._axisLabelTextsDirty;
|
|
|
|
D._axisLabelsDivPow10 = R._axisLabelsDivPow10;
|
|
D._axisLabelsDecimalPoint = R._axisLabelsDecimalPoint;
|
|
D._axisLabelsNotation = R._axisLabelsNotation;
|
|
D._axisLabelsThousandsPoint= R._axisLabelsThousandsPoint;
|
|
D._axisLabelsPrefix = R._axisLabelsPrefix;
|
|
D._axisLabelsPostfix = R._axisLabelsPostfix;
|
|
D._axisLabelsTotalLen = R._axisLabelsTotalLen;
|
|
D._axisLabelsPadFill = R._axisLabelsPadFill;
|
|
D._axisLabelsBlockAlign = R._axisLabelsBlockAlign;
|
|
|
|
D._axisFirstLabelText = R._axisFirstLabelText;
|
|
D._axisLastLabelText = R._axisLastLabelText;
|
|
|
|
D._axisLabelTexts = R._axisLabelTexts;
|
|
D._trueAxisDeltaPixels = R._trueAxisDeltaPixels;
|
|
D._trueHigh = R._trueHigh;
|
|
D._trueLow = R._trueLow;
|
|
D._trueDelta = R._trueDelta;
|
|
D._trueDtLow = R._trueDtLow;
|
|
D._trueDtHigh = R._trueDtHigh;
|
|
D._trueDtDeltaScale = R._trueDtDeltaScale;
|
|
}
|
|
|
|
|
|
/**
|
|
Converts the specified axis type enum to a string representation.
|
|
|
|
\param type the axis type enum to convert
|
|
\return the string representation of the axis type enum
|
|
*/
|
|
TQString KDChartAxisParams::axisTypeToString( AxisType type ) {
|
|
switch( type ) {
|
|
case AxisTypeUnknown:
|
|
return "Unknown";
|
|
case AxisTypeEAST:
|
|
return "East";
|
|
case AxisTypeNORTH:
|
|
return "North";
|
|
case AxisUP:
|
|
return "Up";
|
|
default: // should not happen
|
|
qDebug( "Unknown axis type" );
|
|
return "Unknown";
|
|
}
|
|
}
|
|
|
|
/**
|
|
Converts the specified string to an axis type enum value.
|
|
|
|
\param string the string to convert
|
|
\return the axis type enum value
|
|
*/
|
|
KDChartAxisParams::AxisType KDChartAxisParams::stringToAxisType( const TQString& type ) {
|
|
if( type == "Unknown" )
|
|
return AxisTypeUnknown;
|
|
else if( type == "East" )
|
|
return AxisTypeEAST;
|
|
else if( type == "North" )
|
|
return AxisTypeNORTH;
|
|
else if( type == "Up" )
|
|
return AxisUP;
|
|
else // should not happen
|
|
return AxisTypeUnknown;
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
\fn void KDChartAxisParams::changed()
|
|
\c Signals:
|
|
This signal is emitted when any of the chart axis
|
|
parameters have changed.
|
|
*/
|
|
|
|
/**
|
|
\var AxisType _axisType
|
|
\c private:
|
|
|
|
Specifies the axis type.
|
|
|
|
\sa setAxisType
|
|
*/
|
|
|
|
/**
|
|
\var bool _axisVisible
|
|
\c private:
|
|
Specifies whether this axis is to be drawn. False by default.
|
|
|
|
\sa setAxisVisible
|
|
*/
|
|
|
|
|
|
/**
|
|
\var bool _axisLabelsTouchEdges
|
|
\private:
|
|
Specifies whether the axis labels start and end at the
|
|
edges of the charts instead being positioned in the
|
|
middle of the first data point (or the last one, resp.)
|
|
|
|
\sa axisLabelsTouchEdges
|
|
*/
|
|
|
|
|
|
/**
|
|
\var AxisAreaMode _axisAreaMode
|
|
\private:
|
|
Specifies how to find out the size of the area to be
|
|
used by this axis.
|
|
|
|
\sa setAxisAreaMode, setAxisAreaMin, setAxisAreaMax, setAxisArea
|
|
*/
|
|
|
|
/**
|
|
\var int _axisUseAvailableSpaceFrom
|
|
\private:
|
|
Specifies the beginning offset of the space used by this axis
|
|
in comparison to the space that could be used by this axis.
|
|
|
|
\sa setAxisUseAvailableSpace
|
|
*/
|
|
|
|
/**
|
|
\var int _axisUseAvailableSpaceTo
|
|
\private:
|
|
Specifies the ending offset of the space used by this axis
|
|
in comparison to the space that could be used by this axis.
|
|
|
|
\sa setAxisUseAvailableSpace
|
|
*/
|
|
|
|
/**
|
|
\var int _axisAreaMin
|
|
Specifies the minimum axis area width (or height, resp.).
|
|
\sa setAxisAreaMin, setAxisAreaMode, setAxisAreaMax, setAxisArea
|
|
*/
|
|
|
|
/**
|
|
\var int _axisAreaMax
|
|
Specifies the maximum axis area width (or height, resp.).
|
|
|
|
\sa setAxisAreaMax, setAxisAreaMode, setAxisAreaMin, setAxisArea
|
|
*/
|
|
|
|
/**
|
|
\var AxisCalcMode _axisCalcMode
|
|
Specifies the axis calculation mode.
|
|
|
|
\sa setAxisCalcMode
|
|
*/
|
|
/**
|
|
\var uint _axisIsoRefAxis
|
|
Specifies which axis this axis shall be isometric with.
|
|
|
|
\sa setIsometricReferenceAxis
|
|
*/
|
|
|
|
/**
|
|
\var int _axisTrueAreaSize
|
|
Specifies the axis area width (or height, resp.)
|
|
as it was calculated and drawn.
|
|
|
|
\sa setAxisAreaMax, setAxisAreaMode, setAxisAreaMin, setAxisArea
|
|
*/
|
|
|
|
/**
|
|
\var TQRect _axisTrueAreaRect
|
|
Specifies the true axis area rectangle
|
|
as it was calculated and drawn.
|
|
|
|
\sa setAxisAreaMax, setAxisAreaMin, setAxisArea
|
|
*/
|
|
|
|
/**
|
|
\var bool _axisShowSubDelimiters
|
|
Specifies whether the axis sub-delimiters will be drawn.
|
|
|
|
\sa setAxisShowSubDelimiters
|
|
*/
|
|
/**
|
|
\var bool _axisLineVisible
|
|
Specifies whether the axis line is visible or not.
|
|
|
|
\sa setAxisLineVisible
|
|
*/
|
|
|
|
/**
|
|
\var int _axisLineWidth
|
|
Specifies the axis line width.
|
|
|
|
\sa setAxisLineWidth
|
|
*/
|
|
/**
|
|
\var int _axisTrueLineWidth
|
|
Specifies the actual axis line width, as calculated and drawn.
|
|
|
|
\sa setAxisTrueLineWidth
|
|
*/
|
|
|
|
/**
|
|
\var TQColor _axisLineColor
|
|
Specifies the axis line colour.
|
|
|
|
\sa setAxisLineColor
|
|
*/
|
|
|
|
/**
|
|
\var bool _axisShowGrid
|
|
Specifies whether a grid will be drawn at the chart data area.
|
|
|
|
\sa setAxisShowGrid
|
|
*/
|
|
|
|
/**
|
|
\var TQColor _axisGridColor
|
|
Specifies the axis grid colour.
|
|
|
|
\sa setAxisGridColor, setAxisShowGrid
|
|
*/
|
|
|
|
|
|
/**
|
|
\var int _axisGridLineWidth
|
|
Specifies the width of the axis grid lines.
|
|
|
|
\sa setAxisGridLineWidth
|
|
*/
|
|
|
|
/**
|
|
\var TQColor _axisGridSubColor
|
|
Specifies the axis grid sub colour.
|
|
|
|
\sa setAxisGridSubColor, setAxisShowGrid, setAxisShowSubDelimiters
|
|
*/
|
|
|
|
|
|
/**
|
|
\var int _axisGridSubLineWidth
|
|
Specifies the width of the axis grid sub lines.
|
|
|
|
\sa setAxisGridSubLineWidth, setAxisShowGrid, setAxisShowSubDelimiters
|
|
*/
|
|
|
|
/**
|
|
\var Qt::PenStyle _axisGridStyle
|
|
Specifies the axis grid line pattern for main grid lines.
|
|
|
|
\sa setAxisGridStyle, setAxisShowGrid
|
|
*/
|
|
|
|
/**
|
|
\var Qt::PenStyle _axisGridSubStyle
|
|
Specifies the axis grid line pattern for sub-delimiter grid lines.
|
|
|
|
\sa setAxisGridSubStyle, setAxisGridStyle, setAxisShowGrid
|
|
*/
|
|
|
|
/**
|
|
\var TQColor _axisZeroLineColor
|
|
Specifies the zero-line colour.
|
|
|
|
\sa setAxisZeroLineColor
|
|
*/
|
|
|
|
/**
|
|
\var bool _axisLabelsVisible
|
|
Specifies whether the axis' labels are visible or not.
|
|
|
|
\sa setAxisLabelsVisible
|
|
*/
|
|
|
|
/**
|
|
\var TQFont _axisLabelsFont
|
|
Specifies the axis labels font.
|
|
|
|
\sa setAxisLabelsFont
|
|
\sa setAxisLabelsFontUseRelSize, setAxisLabelsFontRelSize
|
|
*/
|
|
|
|
/**
|
|
\var bool _axisLabelsFontUseRelSize
|
|
Specifies whether the size of the label font is to be calculated
|
|
on a relative basis.
|
|
|
|
\sa setAxisLabelsFontUseRelSize, setAxisLabelsFontRelSize
|
|
\sa setAxisLabelsFont
|
|
*/
|
|
|
|
/**
|
|
\var int _axisLabelsFontRelSize
|
|
Specifies the per mille basis for calculating the relative
|
|
axis labels font size.
|
|
|
|
\sa setAxisLabelsFontRelSize, setAxisLabelsFontUseRelSize
|
|
\sa setAxisLabelsFont
|
|
*/
|
|
|
|
/**
|
|
\var TQColor _axisLabelsColor
|
|
Specifies the axis labels color.
|
|
|
|
\sa setAxisLabelsColor
|
|
*/
|
|
|
|
/**
|
|
\var bool _axisSteadyValueCalc
|
|
Specifies whether label values shall be calculataed based upon the associated dataset values (normally this is true for ordinate axes) or based upon some string list (as you might expect it for abscissa labels).
|
|
|
|
\sa setAxisValues
|
|
*/
|
|
|
|
/**
|
|
\var KDChartData _axisValueStart;
|
|
Specifies the lower limit for the axis labels: the start value.
|
|
|
|
\sa setAxisValues
|
|
*/
|
|
|
|
/**
|
|
\var bool _axisValueStartIsExact;
|
|
Specifies whether the lower limit for the axis labels is
|
|
to be used the start value even if this might not look good.
|
|
|
|
\sa setAxisValueStartIsExact
|
|
*/
|
|
|
|
/**
|
|
\var KDChartData _axisValueEnd
|
|
Specifies the higher limit for the axis labels: the end value.
|
|
|
|
\sa setAxisValues
|
|
*/
|
|
|
|
/**
|
|
\var double _axisValueDelta
|
|
Stores the DELTA value for the axis labels: the distance
|
|
between two labels.
|
|
|
|
\sa setAxisValues
|
|
*/
|
|
|
|
/**
|
|
\var ValueScale _axisValueDeltaScale
|
|
Stores the scaling mode for axis labels: either just numbers
|
|
or a specified time scale (e.g. milliseconds or hours or months...)
|
|
*/
|
|
|
|
/**
|
|
\var int _axisValueLeaveOut
|
|
Stores how many axis labels are to be skipped after drawing one.
|
|
This is usefull in case you have lots of entries in one dataset.
|
|
|
|
\sa setAxisValues
|
|
*/
|
|
|
|
/**
|
|
\var bool _axisValuesDecreasing;
|
|
Stores whether the axis labels are printed in reverted order.
|
|
|
|
\sa setAxisValuesDecreasing
|
|
*/
|
|
|
|
/**
|
|
\var double _trueAxisDeltaPixels
|
|
Stores the <b>true</b> delimiter delta pixel value of the axis labels
|
|
as is was calculated and set by \c setTrueAxisDeltaPixels.
|
|
|
|
\sa setAxisValues
|
|
\sa trueAxisDeltaPixels
|
|
*/
|
|
|
|
/**
|
|
\var double _trueLow
|
|
Specifies the <b>true</b> start value of the axis labels
|
|
as is was calculated and set by \c setTrueAxisLowHighDelta.
|
|
|
|
\sa setAxisValues
|
|
\sa trueAxisLow, trueAxisHigh, trueAxisDelta
|
|
*/
|
|
|
|
/**
|
|
\var double _trueHigh
|
|
Specifies the <b>true</b> end value of the axis labels
|
|
as is was calculated and set by \c setTrueAxisLowHighDelta.
|
|
|
|
\sa setAxisValues
|
|
\sa trueAxisLow, trueAxisHigh, trueAxisDelta
|
|
*/
|
|
|
|
/**
|
|
\var double _trueDelta
|
|
Specifies the <b>true</b> delta value of the axis labels
|
|
as is was calculated and set by \c setTrueAxisLowHighDelta.
|
|
|
|
\sa setAxisValues
|
|
\sa trueAxisLow, trueAxisHigh, trueAxisDelta
|
|
*/
|
|
/**
|
|
\var double _axisZeroLineStartX
|
|
Specifies the not-rounded screen x-position where drawing of
|
|
this axis zero line started.
|
|
*/
|
|
|
|
/**
|
|
\var double _axisZeroLineStartY
|
|
Specifies the not-rounded screen y-position where drawing of
|
|
this axis zero line started.
|
|
*/
|
|
|
|
/**
|
|
\var int _axisDigitsBehindComma
|
|
Specifies the number of digits to be printed behind the comma
|
|
on the axis labels.
|
|
|
|
\sa setAxisValues
|
|
*/
|
|
|
|
/**
|
|
\var int _axisMaxEmptyInnerSpan
|
|
Specifies the percentage of the y-axis range that may to contain NO
|
|
data entries, if - and only if - axisValueStart (or axisValueEnd,
|
|
resp.) is set to KDCHART_AXIS_LABELS_AUTO_LIMIT.
|
|
|
|
\sa setAxisValues
|
|
*/
|
|
/**
|
|
\var LabelsFromDataRow _takeLabelsFromDataRow
|
|
Specifies whether the axis labels shall be taken directly
|
|
from the entries of a data row.
|
|
|
|
\sa setAxisValues
|
|
*/
|
|
|
|
|
|
/**
|
|
\var int _labelTextsDataRow
|
|
Specifies a data row which the axis labels shall be taken from.
|
|
|
|
\sa setAxisValues
|
|
*/
|
|
|
|
/**
|
|
\var TQStringList _axisLabelStringList
|
|
Specifies a TQStringList containing the label texts to be used.
|
|
|
|
\sa _axisShortLabelsStringList
|
|
\sa setAxisValues, _axisLabelTexts, _axisLabelTextsDirty
|
|
*/
|
|
|
|
|
|
/**
|
|
\var TQStringList _axisShortLabelsStringList
|
|
Specifies a TQStringList containing the label texts to be used
|
|
in case the axis area is not wide enough to show their full-size
|
|
counterparts.
|
|
|
|
\sa _axisLabelStringList
|
|
\sa setAxisValues, _axisLabelTexts, _axisLabelTextsDirty
|
|
*/
|
|
|
|
/**
|
|
\var TQStringList _axisLabelTexts
|
|
Contains the label texts <b>actually</b> being used.
|
|
|
|
\sa setAxisValues, _axisLabelStringList, _axisLabelTextsDirty
|
|
*/
|
|
|
|
/**
|
|
\var bool _axisLabelTextsDirty
|
|
Specifies whether the TQStringList _axisLabelTexts content is invalid.
|
|
|
|
\sa setAxisValues, _axisLabelTexts
|
|
*/
|