|
|
|
|
|
/*
|
|
|
|
|
|
KDChart - a multi-platform charting engine
|
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
|
|
** Copyright (C) 2001-2003 Klar<EFBFBD>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.
|
|
|
|
|
|
**
|
|
|
|
|
|
**********************************************************************/
|
|
|
|
|
|
|
|
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
|
|
|
|
#include <config.h>
|
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
#include <tqpainter.h>
|
|
|
|
|
|
#include <tqlabel.h>
|
|
|
|
|
|
|
|
|
|
|
|
#include <KDDrawText.h>
|
|
|
|
|
|
#include "KDChartAxesPainter.h"
|
|
|
|
|
|
#include "KDChartAxisParams.h"
|
|
|
|
|
|
#include "KDChartParams.h"
|
|
|
|
|
|
|
|
|
|
|
|
#include <stdlib.h>
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
|
Little helper function returning the number of seconds
|
|
|
|
|
|
between UTC start date 1970/01/01 00:00 and a given date \c dt.
|
|
|
|
|
|
The return value is negative for \c dt < 1970/01/01.
|
|
|
|
|
|
*/
|
|
|
|
|
|
int secondsSinceUTCStart( const TQDateTime& dt )
|
|
|
|
|
|
{
|
|
|
|
|
|
TQDateTime dtStart( TQDate( 1970, 1, 1 ) );
|
|
|
|
|
|
return dtStart.secsTo( dt );
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
|
\class KDChartAxesPainter KDChartAxesPainter.h
|
|
|
|
|
|
|
|
|
|
|
|
\brief A common base class for classes that implement chart
|
|
|
|
|
|
painters for chart types ith axes.
|
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
|
Constructor. Sets up internal data structures as necessary.
|
|
|
|
|
|
|
|
|
|
|
|
\param params the KDChartParams structure that defines the chart
|
|
|
|
|
|
*/
|
|
|
|
|
|
KDChartAxesPainter::KDChartAxesPainter( KDChartParams* params ) :
|
|
|
|
|
|
KDChartPainter( params )
|
|
|
|
|
|
{
|
|
|
|
|
|
// Intentionally left blank.
|
|
|
|
|
|
// We cannot setup the geometry yet
|
|
|
|
|
|
// since we do not know the size of the painter.
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
|
Destructor.
|
|
|
|
|
|
*/
|
|
|
|
|
|
KDChartAxesPainter::~KDChartAxesPainter()
|
|
|
|
|
|
{
|
|
|
|
|
|
// intentionally left blank
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
|
ReCalculate the labels based upon given nDelta and nDeltaPix.
|
|
|
|
|
|
|
|
|
|
|
|
This is necessary to build isometric axes.
|
|
|
|
|
|
*/
|
|
|
|
|
|
void reCalculateLabelTexts(
|
|
|
|
|
|
TQPainter* painter,
|
|
|
|
|
|
const KDChartTableDataBase& data,
|
|
|
|
|
|
const KDChartParams& params,
|
|
|
|
|
|
uint axisNumber,
|
|
|
|
|
|
double averageValueP1000,
|
|
|
|
|
|
double delimLen,
|
|
|
|
|
|
internal__KDChart__CalcValues& cv )
|
|
|
|
|
|
{
|
|
|
|
|
|
KDChartAxesPainter::calculateLabelTexts(
|
|
|
|
|
|
painter,
|
|
|
|
|
|
data,
|
|
|
|
|
|
params,
|
|
|
|
|
|
axisNumber,
|
|
|
|
|
|
averageValueP1000,
|
|
|
|
|
|
delimLen,
|
|
|
|
|
|
// start of reference parameters
|
|
|
|
|
|
cv.basicPos,
|
|
|
|
|
|
cv.orig,
|
|
|
|
|
|
cv.dest,
|
|
|
|
|
|
cv.pXDeltaFactor,
|
|
|
|
|
|
cv.pYDeltaFactor,
|
|
|
|
|
|
cv.pXDelimDeltaFaktor,
|
|
|
|
|
|
cv.pYDelimDeltaFaktor,
|
|
|
|
|
|
cv.nSubDelimFactor,
|
|
|
|
|
|
cv.pDelimDelta,
|
|
|
|
|
|
cv.nTxtHeight,
|
|
|
|
|
|
cv.pTextsX,
|
|
|
|
|
|
cv.pTextsY,
|
|
|
|
|
|
cv.pTextsW,
|
|
|
|
|
|
cv.pTextsH,
|
|
|
|
|
|
cv.textAlign,
|
|
|
|
|
|
cv.bLogarithmic,
|
|
|
|
|
|
cv.isDateTime,
|
|
|
|
|
|
cv.autoDtLabels,
|
|
|
|
|
|
cv.dtLow,
|
|
|
|
|
|
cv.dtHigh,
|
|
|
|
|
|
cv.dtDeltaScale,
|
|
|
|
|
|
true,
|
|
|
|
|
|
cv.nDelta,
|
|
|
|
|
|
cv.nDeltaPix );
|
|
|
|
|
|
const KDChartAxisParams & para = params.axisParams( axisNumber );
|
|
|
|
|
|
cv.bSteadyCalc = para.axisSteadyValueCalc();
|
|
|
|
|
|
cv.bDecreasing = para.axisValuesDecreasing();
|
|
|
|
|
|
cv.nLow = para.trueAxisLow();
|
|
|
|
|
|
cv.nHigh = para.trueAxisHigh();
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
bool KDChartAxesPainter::calculateAllAxesLabelTextsAndCalcValues(
|
|
|
|
|
|
TQPainter* painter,
|
|
|
|
|
|
KDChartTableDataBase* data,
|
|
|
|
|
|
double areaWidthP1000,
|
|
|
|
|
|
double areaHeightP1000,
|
|
|
|
|
|
double& delimLen)
|
|
|
|
|
|
{
|
|
|
|
|
|
uint iAxis;
|
|
|
|
|
|
double averageValueP1000 = TQMIN(areaWidthP1000, areaHeightP1000);//( areaWidthP1000 + areaHeightP1000 ) / 2.0;
|
|
|
|
|
|
//tqDebug("KChart::KDChartAxesPainter::calculateAllAxesLabelTextsAndCalcValues() averageValueP1000: %f", averageValueP1000);
|
|
|
|
|
|
// length of little delimiter-marks indicating axis scaling
|
|
|
|
|
|
delimLen = 20.0 * averageValueP1000; // per mille of area
|
|
|
|
|
|
|
|
|
|
|
|
// Determine axes calculation values and labels before drawing the axes.
|
|
|
|
|
|
|
|
|
|
|
|
// step #1: calculate all values independendly from the other axes' values
|
|
|
|
|
|
for( iAxis = 0; iAxis < KDCHART_MAX_AXES; ++iAxis )
|
|
|
|
|
|
{
|
|
|
|
|
|
internal__KDChart__CalcValues& cv = calcVal[iAxis];
|
|
|
|
|
|
cv.processThisAxis = ( params()->axisParams( iAxis ).axisVisible()
|
|
|
|
|
|
&& KDChartAxisParams::AxisTypeUnknown
|
|
|
|
|
|
!= params()->axisParams( iAxis ).axisType() );
|
|
|
|
|
|
if( cv.processThisAxis ){
|
|
|
|
|
|
cv.nSubDelimFactor = 0.0;
|
|
|
|
|
|
cv.pDelimDelta = 0.0;
|
|
|
|
|
|
cv.nTxtHeight = 0.0;
|
|
|
|
|
|
cv.pTextsX = 0.0;
|
|
|
|
|
|
cv.pTextsY = 0.0;
|
|
|
|
|
|
cv.pTextsW = 0.0;
|
|
|
|
|
|
cv.pTextsH = 0.0;
|
|
|
|
|
|
cv.textAlign = TQt::AlignHCenter | TQt::AlignVCenter;
|
|
|
|
|
|
cv.isDateTime = false;
|
|
|
|
|
|
cv.autoDtLabels = false;
|
|
|
|
|
|
calculateLabelTexts( painter,
|
|
|
|
|
|
*data,
|
|
|
|
|
|
*params(),
|
|
|
|
|
|
iAxis,
|
|
|
|
|
|
averageValueP1000,
|
|
|
|
|
|
delimLen,
|
|
|
|
|
|
// start of reference parameters
|
|
|
|
|
|
cv.basicPos,
|
|
|
|
|
|
cv.orig,
|
|
|
|
|
|
cv.dest,
|
|
|
|
|
|
cv.pXDeltaFactor,
|
|
|
|
|
|
cv.pYDeltaFactor,
|
|
|
|
|
|
cv.pXDelimDeltaFaktor,
|
|
|
|
|
|
cv.pYDelimDeltaFaktor,
|
|
|
|
|
|
cv.nSubDelimFactor,
|
|
|
|
|
|
cv.pDelimDelta,
|
|
|
|
|
|
cv.nTxtHeight,
|
|
|
|
|
|
cv.pTextsX,
|
|
|
|
|
|
cv.pTextsY,
|
|
|
|
|
|
cv.pTextsW,
|
|
|
|
|
|
cv.pTextsH,
|
|
|
|
|
|
cv.textAlign,
|
|
|
|
|
|
cv.bLogarithmic,
|
|
|
|
|
|
cv.isDateTime,
|
|
|
|
|
|
cv.autoDtLabels,
|
|
|
|
|
|
cv.dtLow,
|
|
|
|
|
|
cv.dtHigh,
|
|
|
|
|
|
cv.dtDeltaScale );
|
|
|
|
|
|
const KDChartAxisParams & para = params()->axisParams( iAxis );
|
|
|
|
|
|
cv.bSteadyCalc = para.axisSteadyValueCalc();
|
|
|
|
|
|
cv.bDecreasing = para.axisValuesDecreasing();
|
|
|
|
|
|
cv.nLow = para.trueAxisLow();
|
|
|
|
|
|
cv.nHigh = para.trueAxisHigh();
|
|
|
|
|
|
cv.nDelta = para.trueAxisDelta();
|
|
|
|
|
|
cv.nDeltaPix = para.trueAxisDeltaPixels();
|
|
|
|
|
|
cv.pLastX = cv.dest.x();
|
|
|
|
|
|
cv.pLastY = cv.dest.y();
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// step #2: if isometric axes are desired adjust/re-calculate some values
|
|
|
|
|
|
for ( iAxis = 0; iAxis < KDCHART_MAX_AXES; ++iAxis ){
|
|
|
|
|
|
internal__KDChart__CalcValues& cv = calcVal[iAxis];
|
|
|
|
|
|
if( cv.processThisAxis
|
|
|
|
|
|
&& cv.bSteadyCalc ){
|
|
|
|
|
|
const KDChartAxisParams & para = params()->axisParams( iAxis );
|
|
|
|
|
|
const uint isoRef = para.isometricReferenceAxis();
|
|
|
|
|
|
if( KDCHART_NO_AXIS != isoRef
|
|
|
|
|
|
&& iAxis != isoRef
|
|
|
|
|
|
&& ( KDCHART_MAX_AXES > isoRef
|
|
|
|
|
|
|| KDCHART_ALL_AXES == isoRef ) ){
|
|
|
|
|
|
if( KDCHART_ALL_AXES == isoRef ){
|
|
|
|
|
|
uint iAxis2;
|
|
|
|
|
|
// first find the axis values to be taken as reference
|
|
|
|
|
|
double nDelta = cv.nDelta;
|
|
|
|
|
|
double nDeltaPix = cv.nDeltaPix;
|
|
|
|
|
|
double nSubDelimFactor = cv.nSubDelimFactor;
|
|
|
|
|
|
for ( iAxis2 = 0;
|
|
|
|
|
|
iAxis2 < KDCHART_MAX_AXES;
|
|
|
|
|
|
++iAxis2 ){
|
|
|
|
|
|
internal__KDChart__CalcValues& cv2 = calcVal[iAxis2];
|
|
|
|
|
|
if( cv2.processThisAxis
|
|
|
|
|
|
&& cv2.bSteadyCalc
|
|
|
|
|
|
&& (0.0 != cv2.nDelta)
|
|
|
|
|
|
&& (fabs(cv2.nDeltaPix / cv2.nDelta) < fabs(nDeltaPix / nDelta)) ){
|
|
|
|
|
|
if( (nDelta >= 0.0) == (cv2.nDelta >= 0.0) )
|
|
|
|
|
|
nDelta = cv2.nDelta;
|
|
|
|
|
|
else
|
|
|
|
|
|
nDelta = cv2.nDelta * -1.0;
|
|
|
|
|
|
if( (nDeltaPix >= 0.0) == (cv2.nDeltaPix >= 0.0) )
|
|
|
|
|
|
nDeltaPix = cv2.nDeltaPix;
|
|
|
|
|
|
else
|
|
|
|
|
|
nDeltaPix = cv2.nDeltaPix * -1.0;
|
|
|
|
|
|
if( (nSubDelimFactor >= 0.0) == (cv2.nSubDelimFactor >= 0.0) )
|
|
|
|
|
|
nSubDelimFactor = cv2.nSubDelimFactor;
|
|
|
|
|
|
else
|
|
|
|
|
|
nSubDelimFactor = cv2.nSubDelimFactor * -1.0;
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
// now adjust all axes (if necessary)
|
|
|
|
|
|
for ( iAxis2 = 0;
|
|
|
|
|
|
iAxis2 < KDCHART_MAX_AXES;
|
|
|
|
|
|
++iAxis2 ){
|
|
|
|
|
|
internal__KDChart__CalcValues& cv2 = calcVal[iAxis2];
|
|
|
|
|
|
if( cv2.processThisAxis
|
|
|
|
|
|
&& cv2.bSteadyCalc
|
|
|
|
|
|
&& ( fabs(cv2.nDelta) != fabs(nDelta)
|
|
|
|
|
|
|| fabs(cv2.nDeltaPix) != fabs(nDeltaPix) ) ){
|
|
|
|
|
|
//tqDebug("\nrecalculating scale for axis %x", iAxis2);
|
|
|
|
|
|
//tqDebug("cv2.nDelta %f cv2.nDeltaPix %f nDelta %f nDeltaPix %f\n",
|
|
|
|
|
|
// cv2.nDelta,cv2.nDeltaPix,nDelta,nDeltaPix);
|
|
|
|
|
|
if( (cv2.nDelta >= 0.0) == (nDelta >= 0.0) )
|
|
|
|
|
|
cv2.nDelta = nDelta;
|
|
|
|
|
|
else
|
|
|
|
|
|
cv2.nDelta = nDelta * -1.0;
|
|
|
|
|
|
if( (cv2.nDeltaPix >= 0.0) == (nDeltaPix >= 0.0) )
|
|
|
|
|
|
cv2.nDeltaPix = nDeltaPix;
|
|
|
|
|
|
else
|
|
|
|
|
|
cv2.nDeltaPix = nDeltaPix * -1.0;
|
|
|
|
|
|
reCalculateLabelTexts( painter,
|
|
|
|
|
|
*data,
|
|
|
|
|
|
*params(),
|
|
|
|
|
|
iAxis2,
|
|
|
|
|
|
averageValueP1000,
|
|
|
|
|
|
delimLen,
|
|
|
|
|
|
cv2 );
|
|
|
|
|
|
if( (cv2.nSubDelimFactor >= 0.0) == (nSubDelimFactor >= 0.0) )
|
|
|
|
|
|
cv2.nSubDelimFactor = nSubDelimFactor;
|
|
|
|
|
|
else
|
|
|
|
|
|
cv2.nSubDelimFactor = nSubDelimFactor * -1.0;
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
}else{
|
|
|
|
|
|
internal__KDChart__CalcValues& cv2 = calcVal[isoRef];
|
|
|
|
|
|
// adjust this axis or the other axis (if necessary)
|
|
|
|
|
|
if( cv2.processThisAxis
|
|
|
|
|
|
&& cv2.bSteadyCalc
|
|
|
|
|
|
&& ( cv2.nDelta != cv.nDelta
|
|
|
|
|
|
|| cv2.nDeltaPix != cv.nDeltaPix ) ){
|
|
|
|
|
|
if( cv2.nDelta > cv.nDelta
|
|
|
|
|
|
|| ( cv2.nDelta == cv.nDelta
|
|
|
|
|
|
&& cv2.nDeltaPix < cv.nDeltaPix ) ){
|
|
|
|
|
|
// adjust this axis
|
|
|
|
|
|
//tqDebug("recalculating scale for this axis %x", iAxis);
|
|
|
|
|
|
cv.nDelta = cv2.nDelta;
|
|
|
|
|
|
cv.nDeltaPix = cv2.nDeltaPix;
|
|
|
|
|
|
reCalculateLabelTexts(
|
|
|
|
|
|
painter,
|
|
|
|
|
|
*data,
|
|
|
|
|
|
*params(),
|
|
|
|
|
|
iAxis,
|
|
|
|
|
|
averageValueP1000,
|
|
|
|
|
|
delimLen,
|
|
|
|
|
|
cv );
|
|
|
|
|
|
cv.nSubDelimFactor = cv2.nSubDelimFactor;
|
|
|
|
|
|
}else{
|
|
|
|
|
|
// adjust the other axis
|
|
|
|
|
|
//tqDebug("\nrecalculating scale for other axis %x", isoRef);
|
|
|
|
|
|
//tqDebug("cv2.nDelta %f cv2.nDeltaPix %f cv.nDelta %f cv.nDeltaPix %f",
|
|
|
|
|
|
// cv2.nDelta,cv2.nDeltaPix,cv.nDelta,cv.nDeltaPix);
|
|
|
|
|
|
cv2.nDelta = cv.nDelta;
|
|
|
|
|
|
cv2.nDeltaPix = cv.nDeltaPix;
|
|
|
|
|
|
reCalculateLabelTexts(
|
|
|
|
|
|
painter,
|
|
|
|
|
|
*data,
|
|
|
|
|
|
*params(),
|
|
|
|
|
|
isoRef,
|
|
|
|
|
|
averageValueP1000,
|
|
|
|
|
|
delimLen,
|
|
|
|
|
|
cv2 );
|
|
|
|
|
|
cv2.nSubDelimFactor = cv.nSubDelimFactor;
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
return true;
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
|
Paints the actual axes areas.
|
|
|
|
|
|
|
|
|
|
|
|
\param painter the TQPainter onto which the chart should be painted
|
|
|
|
|
|
\param data the data that will be displayed as a chart
|
|
|
|
|
|
*/
|
|
|
|
|
|
void KDChartAxesPainter::paintAxes( TQPainter* painter,
|
|
|
|
|
|
KDChartTableDataBase* data )
|
|
|
|
|
|
{
|
|
|
|
|
|
if ( !painter || !data || 0 == params() )
|
|
|
|
|
|
return ;
|
|
|
|
|
|
|
|
|
|
|
|
const bool bMultiRowBarChart = KDChartParams::Bar == params()->chartType() &&
|
|
|
|
|
|
KDChartParams::BarMultiRows == params()->barChartSubType();
|
|
|
|
|
|
|
|
|
|
|
|
double areaWidthP1000 = _logicalWidth / 1000.0;
|
|
|
|
|
|
double areaHeightP1000 = _logicalHeight / 1000.0;
|
|
|
|
|
|
double averageValueP1000 = TQMIN(areaWidthP1000, areaHeightP1000);//( areaWidthP1000 + areaHeightP1000 ) / 2.0;
|
|
|
|
|
|
// length of little delimiter-marks indicating axis scaling
|
|
|
|
|
|
double delimLen;
|
|
|
|
|
|
|
|
|
|
|
|
//tqDebug("-------------------------------------------------------------------------------------");
|
|
|
|
|
|
|
|
|
|
|
|
calculateAllAxesLabelTextsAndCalcValues( painter, data, areaWidthP1000, areaHeightP1000, delimLen );
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// Now the labels are known, so let us paint the axes...
|
|
|
|
|
|
painter->save();
|
|
|
|
|
|
painter->setPen( TQt::NoPen );
|
|
|
|
|
|
|
|
|
|
|
|
bool screenOutput = params()->optimizeOutputForScreen();
|
|
|
|
|
|
uint iAxis;
|
|
|
|
|
|
|
|
|
|
|
|
for ( iAxis = 0; iAxis < KDCHART_MAX_AXES; ++iAxis ){
|
|
|
|
|
|
internal__KDChart__CalcValues& cv = calcVal[iAxis];
|
|
|
|
|
|
if( cv.processThisAxis ){
|
|
|
|
|
|
|
|
|
|
|
|
const KDChartAxisParams & para = params()->axisParams( iAxis );
|
|
|
|
|
|
|
|
|
|
|
|
internal__KDChart__CalcValues& cv = calcVal[iAxis];
|
|
|
|
|
|
|
|
|
|
|
|
const TQColor labelsColor( para.axisLabelsColor() );
|
|
|
|
|
|
|
|
|
|
|
|
// Debugging axis areas:
|
|
|
|
|
|
//painter->fillRect(para.axisTrueAreaRect(), TQt::yellow);
|
|
|
|
|
|
|
|
|
|
|
|
uint lineWidth = 0 <= para.axisLineWidth()
|
|
|
|
|
|
? para.axisLineWidth()
|
|
|
|
|
|
: -1 * static_cast < int > ( para.axisLineWidth()
|
|
|
|
|
|
* averageValueP1000 );
|
|
|
|
|
|
( ( KDChartAxisParams& ) para ).setAxisTrueLineWidth( lineWidth );
|
|
|
|
|
|
|
|
|
|
|
|
uint gridLineWidth
|
|
|
|
|
|
= ( KDCHART_AXIS_GRID_AUTO_LINEWIDTH
|
|
|
|
|
|
== para.axisGridLineWidth() )
|
|
|
|
|
|
? lineWidth
|
|
|
|
|
|
: ( ( 0 <= para.axisGridLineWidth() )
|
|
|
|
|
|
? para.axisGridLineWidth()
|
|
|
|
|
|
: -1 * static_cast < int > ( para.axisGridLineWidth()
|
|
|
|
|
|
* averageValueP1000 ) );
|
|
|
|
|
|
|
|
|
|
|
|
uint gridSubLineWidth
|
|
|
|
|
|
= ( KDCHART_AXIS_GRID_AUTO_LINEWIDTH
|
|
|
|
|
|
== para.axisGridSubLineWidth() )
|
|
|
|
|
|
? lineWidth
|
|
|
|
|
|
: ( ( 0 <= para.axisGridSubLineWidth() )
|
|
|
|
|
|
? para.axisGridSubLineWidth()
|
|
|
|
|
|
: -1 * static_cast < int > ( para.axisGridSubLineWidth()
|
|
|
|
|
|
* averageValueP1000 ) );
|
|
|
|
|
|
|
|
|
|
|
|
// Magic to find out axis scaling factors and labels text height
|
|
|
|
|
|
// =============================================================
|
|
|
|
|
|
// - khz, 02/24/2001
|
|
|
|
|
|
//
|
|
|
|
|
|
// 1st Calculate the axis label texts height regarding to
|
|
|
|
|
|
// user-defined per-axis settings.
|
|
|
|
|
|
//
|
|
|
|
|
|
// 2nd This height is given to calculateLabelTexts() to
|
|
|
|
|
|
// calculate the delimiter and sub-delimiter distances as
|
|
|
|
|
|
// well as the axis scaling factors.
|
|
|
|
|
|
// If neccessary and possible the short replacement strings
|
|
|
|
|
|
// are taken that might have been specified by the user.
|
|
|
|
|
|
// - see KDChartAxisParams::setAxisLabelStringLists() -
|
|
|
|
|
|
//
|
|
|
|
|
|
// 3rd Before displaying the texts we make sure they fit into
|
|
|
|
|
|
// their space, if needed we will do the following
|
|
|
|
|
|
// in order to avoid clipping of text parts:
|
|
|
|
|
|
//
|
|
|
|
|
|
// (a) ABSCISSA axes only: rotate the texts in 5 steps
|
|
|
|
|
|
// until they are drawn vertically
|
|
|
|
|
|
//
|
|
|
|
|
|
// (b) further reduce the texts' font height down to 6pt
|
|
|
|
|
|
// .
|
|
|
|
|
|
//
|
|
|
|
|
|
// If the texts *still* don't fit into their space, we are lost
|
|
|
|
|
|
// and they will be clipped. Such is live.
|
|
|
|
|
|
//
|
|
|
|
|
|
// Why all this?
|
|
|
|
|
|
//
|
|
|
|
|
|
// Because I do not believe in axis areas growing and shrinking
|
|
|
|
|
|
// regarding to long or short label texts: start such behaviour
|
|
|
|
|
|
// and become mad.
|
|
|
|
|
|
//
|
|
|
|
|
|
// Better plan: ask the user to specify a way how to abbreviate
|
|
|
|
|
|
// label texts (e.g. by writing "200" instead
|
|
|
|
|
|
// of that wide and unreadable "200,000.00")
|
|
|
|
|
|
//
|
|
|
|
|
|
//
|
|
|
|
|
|
// F E A T U R E P L A N N E D F O R F U T U R E . . .
|
|
|
|
|
|
//
|
|
|
|
|
|
//
|
|
|
|
|
|
|
|
|
|
|
|
// Note: The labels-touch-edges flag may have been set to true
|
|
|
|
|
|
// inside the calculateLabelTexts() function.
|
|
|
|
|
|
bool bTouchEdges = para.axisLabelsTouchEdges();
|
|
|
|
|
|
|
|
|
|
|
|
// NOTE: The steady-value-calc flag may have been set to true
|
|
|
|
|
|
// inside the calculateLabelTexts() function
|
|
|
|
|
|
// by a special setAxisLabelTextParams() call,
|
|
|
|
|
|
// therefor we do not store its value before calling that function.
|
|
|
|
|
|
if( cv.bLogarithmic )
|
|
|
|
|
|
cv.nSubDelimFactor = 0.1;
|
|
|
|
|
|
|
|
|
|
|
|
const double nUsableAxisHeight = cv.pTextsH;
|
|
|
|
|
|
const double nUsableAxisWidth = cv.pTextsW;
|
|
|
|
|
|
|
|
|
|
|
|
const bool isHorizontalAxis
|
|
|
|
|
|
= (KDChartAxisParams::AxisPosBottom == cv.basicPos) ||
|
|
|
|
|
|
(KDChartAxisParams::AxisPosTop == cv.basicPos);
|
|
|
|
|
|
|
|
|
|
|
|
TQStringList* labelTexts = ( TQStringList* ) para.axisLabelTexts();
|
|
|
|
|
|
uint nLabels = ( 0 != labelTexts )
|
|
|
|
|
|
? labelTexts->count()
|
|
|
|
|
|
: 0;
|
|
|
|
|
|
// start point of 1st delimiter on the axis-line == grid-start
|
|
|
|
|
|
TQPoint p1( cv.orig );
|
|
|
|
|
|
// end point of 1st delimiter near the label text
|
|
|
|
|
|
TQPoint p2( cv.orig );
|
|
|
|
|
|
// end point of small sub-delimiter
|
|
|
|
|
|
TQPoint p2a( cv.orig );
|
|
|
|
|
|
// start point of 1st grid-line (beginnig at the axis)
|
|
|
|
|
|
TQPoint pGA( cv.orig );
|
|
|
|
|
|
// end point of 1st grid-line at the other side of the chart
|
|
|
|
|
|
TQPoint pGZ( cv.orig );
|
|
|
|
|
|
// start point of zero-line, this is often identical with p1
|
|
|
|
|
|
// but will be different in case of shifted zero-line
|
|
|
|
|
|
double axisZeroLineStartX = p1.x();
|
|
|
|
|
|
double axisZeroLineStartY = p1.y();
|
|
|
|
|
|
|
|
|
|
|
|
p2.setX( p2.x() + static_cast < int > ( cv.pXDelimDeltaFaktor * delimLen ) );
|
|
|
|
|
|
p2.setY( p2.y() + static_cast < int > ( cv.pYDelimDeltaFaktor * delimLen ) );
|
|
|
|
|
|
p2a.setX( p2a.x() + static_cast < int > ( cv.pXDelimDeltaFaktor * delimLen * 2.0 / 3.0 ) );
|
|
|
|
|
|
p2a.setY( p2a.y() + static_cast < int > ( cv.pYDelimDeltaFaktor * delimLen * 2.0 / 3.0 ) );
|
|
|
|
|
|
pGZ.setX( pGZ.x() - static_cast < int > ( cv.pXDelimDeltaFaktor * (_dataRect.width() - 1) ) );
|
|
|
|
|
|
pGZ.setY( pGZ.y() - static_cast < int > ( cv.pYDelimDeltaFaktor * (_dataRect.height() - 1) ) );
|
|
|
|
|
|
|
|
|
|
|
|
if ( nLabels ) {
|
|
|
|
|
|
// Sometimes the first or last labels partially reach out of
|
|
|
|
|
|
// their axis area: we allow this
|
|
|
|
|
|
const bool oldClippingFlag = painter->hasClipping();
|
|
|
|
|
|
painter->setClipping( false );
|
|
|
|
|
|
|
|
|
|
|
|
if( para.hasAxisFirstLabelText() )
|
|
|
|
|
|
labelTexts->first() = para.axisFirstLabelText();
|
|
|
|
|
|
if( para.hasAxisLastLabelText() )
|
|
|
|
|
|
labelTexts->last() = para.axisLastLabelText();
|
|
|
|
|
|
|
|
|
|
|
|
const double pXDelta = cv.pXDeltaFactor * cv.pDelimDelta;
|
|
|
|
|
|
const double pYDelta = cv.pYDeltaFactor * cv.pDelimDelta;
|
|
|
|
|
|
|
|
|
|
|
|
// draw label texts and delimiters and grid
|
|
|
|
|
|
painter->setPen( TQPen( para.axisLineColor(),
|
|
|
|
|
|
lineWidth ) );
|
|
|
|
|
|
|
|
|
|
|
|
const TQString formatDT = cv.isDateTime
|
|
|
|
|
|
? para.axisLabelsDateTimeFormat()
|
|
|
|
|
|
: TQString();
|
|
|
|
|
|
|
|
|
|
|
|
// calculate font size
|
|
|
|
|
|
const double minTextHeight = para.axisLabelsFontMinSize();
|
|
|
|
|
|
//tqDebug("KChart::KDChartAxesPainter::paintAxes() cv.nTxtHeight: %f minTextHeight: %f", cv.nTxtHeight, minTextHeight);
|
|
|
|
|
|
if ( minTextHeight > cv.nTxtHeight )
|
|
|
|
|
|
cv.nTxtHeight = minTextHeight;
|
|
|
|
|
|
TQFont actFont( para.axisLabelsFont() );
|
|
|
|
|
|
if ( para.axisLabelsFontUseRelSize() ) {
|
|
|
|
|
|
actFont.setPixelSize( static_cast < int > ( cv.nTxtHeight ) );
|
|
|
|
|
|
}
|
|
|
|
|
|
painter->setFont( actFont );
|
|
|
|
|
|
TQFontMetrics fm( painter->fontMetrics() );
|
|
|
|
|
|
|
|
|
|
|
|
int nLeaveOut = 0;
|
|
|
|
|
|
int nRotation = 0;
|
|
|
|
|
|
|
|
|
|
|
|
// Draw simple string labels
|
|
|
|
|
|
// or calculate and draw nice Date/Time ruler?
|
|
|
|
|
|
TQString commonDtHeader;
|
|
|
|
|
|
if( cv.autoDtLabels ){
|
|
|
|
|
|
cv.textAlign = TQt::AlignCenter;
|
|
|
|
|
|
//tqDebug(dtLow.toString("\nd.MM.yyyy - h:mm:ss" ));
|
|
|
|
|
|
//tqDebug(dtHigh.toString( "d.MM.yyyy - h:mm:ss" ));
|
|
|
|
|
|
const TQDate& dLow = cv.dtLow.date();
|
|
|
|
|
|
const TQTime& tLow = cv.dtLow.time();
|
|
|
|
|
|
const TQDate& dHigh = cv.dtHigh.date();
|
|
|
|
|
|
const TQTime& tHigh = cv.dtHigh.time();
|
|
|
|
|
|
bool sameYear = dLow.year() == dHigh.year();
|
|
|
|
|
|
bool sameMonth = sameYear && (dLow.month() == dHigh.month() );
|
|
|
|
|
|
bool sameDay = sameMonth && (dLow.day() == dHigh.day() );
|
|
|
|
|
|
bool sameHour = sameDay && (tLow.hour() == tHigh.hour() );
|
|
|
|
|
|
bool sameMinute = sameHour && (tLow.minute() == tHigh.minute());
|
|
|
|
|
|
bool sameSecond = sameMinute && (tLow.second() == tHigh.second());
|
|
|
|
|
|
if( sameDay ){
|
|
|
|
|
|
commonDtHeader = TQString::number( dLow.day() )
|
|
|
|
|
|
+ ". "
|
|
|
|
|
|
+ TQDate::longMonthName( dLow.month() )
|
|
|
|
|
|
+ ' '
|
|
|
|
|
|
+ TQString::number( dLow.year() );
|
|
|
|
|
|
if( sameHour ){
|
|
|
|
|
|
commonDtHeader += " / "
|
|
|
|
|
|
+ TQString::number( tLow.hour() )
|
|
|
|
|
|
+ ':';
|
|
|
|
|
|
if( sameMinute ){
|
|
|
|
|
|
if( 10 > tLow.minute() )
|
|
|
|
|
|
commonDtHeader += '0';
|
|
|
|
|
|
commonDtHeader += TQString::number( tLow.minute() )
|
|
|
|
|
|
+ ':';
|
|
|
|
|
|
if( sameSecond ){
|
|
|
|
|
|
if( 10 > tLow.second() )
|
|
|
|
|
|
commonDtHeader += '0';
|
|
|
|
|
|
commonDtHeader += TQString::number( tLow.second() );
|
|
|
|
|
|
//
|
|
|
|
|
|
// " Huston, we have a problem! "
|
|
|
|
|
|
//
|
|
|
|
|
|
// Currently we don't support milli secs
|
|
|
|
|
|
// since they will not fit into a double
|
|
|
|
|
|
// when looking at years...
|
|
|
|
|
|
//
|
|
|
|
|
|
// This will be improved in release 2.0.
|
|
|
|
|
|
// (khz, 2002/07/12)
|
|
|
|
|
|
}
|
|
|
|
|
|
else
|
|
|
|
|
|
commonDtHeader += "00";
|
|
|
|
|
|
}
|
|
|
|
|
|
else
|
|
|
|
|
|
commonDtHeader += "00";
|
|
|
|
|
|
}
|
|
|
|
|
|
}else if( sameMonth )
|
|
|
|
|
|
commonDtHeader = TQDate::longMonthName( dLow.month() )
|
|
|
|
|
|
+ ' '
|
|
|
|
|
|
+ TQString::number( dLow.year() );
|
|
|
|
|
|
else if( sameYear )
|
|
|
|
|
|
commonDtHeader = TQString::number( dLow.year() );
|
|
|
|
|
|
//if( !commonDtHeader.isEmpty() )
|
|
|
|
|
|
// tqDebug(commonDtHeader);
|
|
|
|
|
|
}else{
|
|
|
|
|
|
// make sure all label texts fit into their space
|
|
|
|
|
|
// by rotating and/or shrinking the texts
|
|
|
|
|
|
// or by leaving out some of the labels
|
|
|
|
|
|
TQRegion unitedRegions;
|
|
|
|
|
|
|
|
|
|
|
|
const bool tryLeavingOut =
|
|
|
|
|
|
( para.axisValueLeaveOut() == KDCHART_AXIS_LABELS_AUTO_LEAVEOUT )
|
|
|
|
|
|
|| ( 0 < para.axisValueLeaveOut() );
|
|
|
|
|
|
if( tryLeavingOut ) {
|
|
|
|
|
|
if( para.axisValueLeaveOut()
|
|
|
|
|
|
== KDCHART_AXIS_LABELS_AUTO_LEAVEOUT )
|
|
|
|
|
|
nLeaveOut = 0;
|
|
|
|
|
|
else
|
|
|
|
|
|
nLeaveOut = para.axisValueLeaveOut();
|
|
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
else
|
|
|
|
|
|
nLeaveOut = 0;
|
|
|
|
|
|
int stepWidthLeaveOut = nLeaveOut+1;
|
|
|
|
|
|
int iStepsLeaveOut = 0;
|
|
|
|
|
|
|
|
|
|
|
|
const bool tryShrinking = !para.axisLabelsDontShrinkFont();
|
|
|
|
|
|
const double nInitialTxtHeight = cv.nTxtHeight;
|
|
|
|
|
|
|
|
|
|
|
|
const bool tryRotating = isHorizontalAxis
|
|
|
|
|
|
&& !para.axisLabelsDontAutoRotate();
|
|
|
|
|
|
const int nInitialRotation = ( (360 > para.axisLabelsRotation())
|
|
|
|
|
|
&& (270 <= para.axisLabelsRotation()) )
|
|
|
|
|
|
? para.axisLabelsRotation()
|
|
|
|
|
|
: 0;
|
|
|
|
|
|
nRotation = nInitialRotation;
|
|
|
|
|
|
|
|
|
|
|
|
bool textsDontFitIntoArea;
|
|
|
|
|
|
bool textsOverlapping;
|
|
|
|
|
|
bool textsMatching;
|
|
|
|
|
|
do {
|
|
|
|
|
|
textsDontFitIntoArea = false;
|
|
|
|
|
|
textsOverlapping = false;
|
|
|
|
|
|
textsMatching = true;
|
|
|
|
|
|
// test if all texts match without mutually overlapping
|
|
|
|
|
|
unitedRegions = TQRegion();
|
|
|
|
|
|
int align = nRotation
|
|
|
|
|
|
? (TQt::AlignRight | TQt::AlignVCenter) // adjusting for rotation
|
|
|
|
|
|
: cv.textAlign;
|
|
|
|
|
|
TQPoint anchor(200,200);
|
|
|
|
|
|
int iLeaveOut = 0;
|
|
|
|
|
|
double iLabel=0.0;
|
|
|
|
|
|
for ( TQStringList::Iterator it = labelTexts->begin();
|
|
|
|
|
|
it != labelTexts->end();
|
|
|
|
|
|
++it ) {
|
|
|
|
|
|
iLabel += 1.0;
|
|
|
|
|
|
if( iLeaveOut < nLeaveOut ) {
|
|
|
|
|
|
++iLeaveOut;
|
|
|
|
|
|
} else {
|
|
|
|
|
|
iLeaveOut = 0;
|
|
|
|
|
|
anchor.setX( p2.x() + static_cast < int > ( pXDelta * (iLabel - 0.5) ) );
|
|
|
|
|
|
anchor.setY( p2.y() + static_cast < int > ( pYDelta * (iLabel - 0.5) ) );
|
|
|
|
|
|
|
|
|
|
|
|
// allow for shearing and/or scaling of the painter
|
|
|
|
|
|
anchor = painter->worldMatrix().map( anchor );
|
|
|
|
|
|
|
|
|
|
|
|
TQString text;
|
|
|
|
|
|
if( cv.isDateTime ){
|
|
|
|
|
|
TQDateTime dt( TQDateTime::fromString( *it,
|
|
|
|
|
|
TQt::ISODate ) );
|
|
|
|
|
|
text = dt.toString( formatDT );
|
|
|
|
|
|
}else{
|
|
|
|
|
|
text = *it;
|
|
|
|
|
|
}
|
|
|
|
|
|
KDDrawTextRegionAndTrueRect infosKDD =
|
|
|
|
|
|
KDDrawText::measureRotatedText( painter,
|
|
|
|
|
|
nRotation,
|
|
|
|
|
|
anchor,
|
|
|
|
|
|
text,
|
|
|
|
|
|
0,
|
|
|
|
|
|
align,
|
|
|
|
|
|
&fm,
|
|
|
|
|
|
false,
|
|
|
|
|
|
false,
|
|
|
|
|
|
15 );
|
|
|
|
|
|
if( infosKDD.region.boundingRect().left()
|
|
|
|
|
|
< params()->globalLeadingLeft()+1 ){
|
|
|
|
|
|
textsMatching = false;
|
|
|
|
|
|
textsDontFitIntoArea = true;
|
|
|
|
|
|
//tqDebug("too wide");
|
|
|
|
|
|
}
|
|
|
|
|
|
//tqDebug("nRotation: %i",nRotation);
|
|
|
|
|
|
TQRegion sectReg;
|
|
|
|
|
|
if( nRotation ){
|
|
|
|
|
|
//tqDebug("test 1");
|
|
|
|
|
|
sectReg = infosKDD.region.intersect( unitedRegions );
|
|
|
|
|
|
}else{
|
|
|
|
|
|
//tqDebug("test 2");
|
|
|
|
|
|
TQRect rect( infosKDD.region.boundingRect() );
|
|
|
|
|
|
rect.addCoords(-2,-2,2,2);
|
|
|
|
|
|
TQRegion biggerRegion( rect );
|
|
|
|
|
|
sectReg = biggerRegion.intersect( unitedRegions );
|
|
|
|
|
|
}
|
|
|
|
|
|
if ( sectReg.isEmpty() )
|
|
|
|
|
|
unitedRegions = unitedRegions.unite( infosKDD.region );
|
|
|
|
|
|
else {
|
|
|
|
|
|
textsMatching = false;
|
|
|
|
|
|
textsOverlapping = true;
|
|
|
|
|
|
//tqDebug("label regions are intersecting");
|
|
|
|
|
|
break;
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
|
|
|
if(!iAxis){
|
|
|
|
|
|
|
|
|
|
|
|
tqDebug("nTxtHeight: "+TQString::number(cv.nTxtHeight)+" nRotation: "+TQString::number(nRotation)+
|
|
|
|
|
|
" matching: "+TQString(textsMatching ? "TRUE":"FALSE"));
|
|
|
|
|
|
tqDebug("nUsableAxisHeight: %f, unitedRegions.boundingRect().height(): %i ",
|
|
|
|
|
|
nUsableAxisHeight, unitedRegions.boundingRect().height());
|
|
|
|
|
|
}
|
|
|
|
|
|
*/
|
|
|
|
|
|
if( isHorizontalAxis ) {
|
|
|
|
|
|
if( nUsableAxisHeight < unitedRegions.boundingRect().height() ){
|
|
|
|
|
|
//textsMatching = false;
|
|
|
|
|
|
textsDontFitIntoArea = true;
|
|
|
|
|
|
}
|
|
|
|
|
|
} else {
|
|
|
|
|
|
if( nUsableAxisWidth < unitedRegions.boundingRect().width() ){
|
|
|
|
|
|
//tqDebug("textsMatching: %s",textsMatching ? "TRUE" : "FALSE");
|
|
|
|
|
|
textsMatching = false;
|
|
|
|
|
|
textsDontFitIntoArea = true;
|
|
|
|
|
|
//tqDebug("too wide");
|
|
|
|
|
|
}
|
|
|
|
|
|
//else tqDebug("not too wide");
|
|
|
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
|
|
|
if(textsMatching && !iAxis){
|
|
|
|
|
|
tqDebug("--------------------------");
|
|
|
|
|
|
tqDebug("nTxtHeight: "+TQString::number(cv.nTxtHeight)+" nRotation: "+TQString::number(nRotation));
|
|
|
|
|
|
tqDebug("matching");
|
|
|
|
|
|
}
|
|
|
|
|
|
*/
|
|
|
|
|
|
if( !textsMatching ) {
|
|
|
|
|
|
bool rotatingDoesNotHelp = false;
|
|
|
|
|
|
// step 1: In case of labels being too wide
|
|
|
|
|
|
// to fit into the available space
|
|
|
|
|
|
// we try to rotate the texts in 5 steps.
|
|
|
|
|
|
// This is done for Abscissa axes only.
|
|
|
|
|
|
if ( tryRotating ) {
|
|
|
|
|
|
//tqDebug("try rotating");
|
|
|
|
|
|
// The following is designed for horizontal axes
|
|
|
|
|
|
// since we currently don't support label rotating
|
|
|
|
|
|
// on vertical axes. (khz, 2002/08/15)
|
|
|
|
|
|
if( textsDontFitIntoArea ){
|
|
|
|
|
|
if( nRotation != nInitialRotation ){
|
|
|
|
|
|
//textsDontFitIntoArea = false;
|
|
|
|
|
|
nRotation = nInitialRotation;
|
|
|
|
|
|
}
|
|
|
|
|
|
rotatingDoesNotHelp = true;
|
|
|
|
|
|
//tqDebug("rotating does not help (a)");
|
|
|
|
|
|
}
|
|
|
|
|
|
else{
|
|
|
|
|
|
if( nRotation ) {
|
|
|
|
|
|
if( 270 < nRotation ) {
|
|
|
|
|
|
nRotation -= 5;
|
|
|
|
|
|
if( 270 > nRotation )
|
|
|
|
|
|
nRotation = 270; // drawing vertically now
|
|
|
|
|
|
} else {
|
|
|
|
|
|
if( nInitialRotation )
|
|
|
|
|
|
nRotation = nInitialRotation;
|
|
|
|
|
|
else
|
|
|
|
|
|
nRotation = 0; // reset rotation to ZERO
|
|
|
|
|
|
rotatingDoesNotHelp = true;
|
|
|
|
|
|
//tqDebug("rotating does not help (b)");
|
|
|
|
|
|
}
|
|
|
|
|
|
} else {
|
|
|
|
|
|
if( nInitialRotation )
|
|
|
|
|
|
nRotation = nInitialRotation;
|
|
|
|
|
|
else
|
|
|
|
|
|
nRotation = 350; // (re-)start rotating with -10
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
if ( !tryRotating || rotatingDoesNotHelp ) {
|
|
|
|
|
|
|
|
|
|
|
|
// step 2: In case of labels being too wide and
|
|
|
|
|
|
// rotating them did not help or is forbidden
|
|
|
|
|
|
// we try to reduce the font size.
|
|
|
|
|
|
if ( tryShrinking && (minTextHeight < cv.nTxtHeight) ) {
|
|
|
|
|
|
//tqDebug("try shrinking");
|
|
|
|
|
|
cv.nTxtHeight -= 1.0;
|
|
|
|
|
|
if ( minTextHeight > cv.nTxtHeight )
|
|
|
|
|
|
cv.nTxtHeight = minTextHeight;
|
|
|
|
|
|
} else {
|
|
|
|
|
|
|
|
|
|
|
|
// step 3: In case reducing the font size is not possible
|
|
|
|
|
|
// any further (or is not allowed at all) we try
|
|
|
|
|
|
// to leave out some of the labels.
|
|
|
|
|
|
if( tryLeavingOut
|
|
|
|
|
|
&& textsOverlapping
|
|
|
|
|
|
&& (nLeaveOut+1 < static_cast < int > ( nLabels ) ) ) {
|
|
|
|
|
|
//tqDebug("try leaving out");
|
|
|
|
|
|
++iStepsLeaveOut;
|
|
|
|
|
|
//if(!iAxis)tqDebug("iStepsLeaveOut: %i", iStepsLeaveOut);
|
|
|
|
|
|
nLeaveOut =
|
|
|
|
|
|
iStepsLeaveOut*stepWidthLeaveOut - 1;
|
|
|
|
|
|
if( tryShrinking )
|
|
|
|
|
|
cv.nTxtHeight = nInitialTxtHeight;
|
|
|
|
|
|
}
|
|
|
|
|
|
else
|
|
|
|
|
|
break;
|
|
|
|
|
|
}
|
|
|
|
|
|
if( tryShrinking ) {
|
|
|
|
|
|
actFont.setPixelSize( static_cast < int > ( cv.nTxtHeight ) );
|
|
|
|
|
|
//tqDebug("axis: cv.nTxtHeight: %f", iAxis, cv.nTxtHeight);
|
|
|
|
|
|
painter->setFont( actFont );
|
|
|
|
|
|
fm = painter->fontMetrics();
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
//tqDebug("nLeaveOut: %i",nLeaveOut);
|
|
|
|
|
|
} while( !textsMatching );
|
|
|
|
|
|
|
|
|
|
|
|
if( nRotation ){
|
|
|
|
|
|
// The following is designed for horizontal axes
|
|
|
|
|
|
// since we currently don't support label rotating
|
|
|
|
|
|
// on vertical axes. (khz, 2002/08/15)
|
|
|
|
|
|
//int oldVert = textAlign & (TQt::AlignTop | TQt::AlignBottom);
|
|
|
|
|
|
//int steepness = abs(270-nRotation);
|
|
|
|
|
|
//bool steep = (30 > steepness);
|
|
|
|
|
|
cv.textAlign = TQt::AlignRight | TQt::AlignVCenter; // adjusting for rotation
|
|
|
|
|
|
//cv.textAlign = TQt::AlignRight | TQt::AlignVCenter;
|
|
|
|
|
|
/* ( steep ? TQt::AlignVCenter : oldVert);*/
|
|
|
|
|
|
//int dx = pXDelta / 2 - steep ? (nTxtHeight / 4) : 0;
|
|
|
|
|
|
double dx = (pXDelta / 2) - (cv.nTxtHeight / 4);
|
|
|
|
|
|
double dy = /*steep ? 0 : */(cv.nTxtHeight / 2.0);
|
|
|
|
|
|
cv.pTextsX += dx;
|
|
|
|
|
|
cv.pTextsY += dy;
|
|
|
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
|
|
|
TQBrush oldBrush = painter->brush();
|
|
|
|
|
|
TQRegion oldReg = painter->clipRegion();//TQPainter::CoordPainter);
|
|
|
|
|
|
painter->setBrush(TQt::Dense4Pattern);
|
|
|
|
|
|
painter->setClipRegion(unitedRegions);//,TQPainter::CoordPainter);
|
|
|
|
|
|
painter->drawRect(0,0,2000,1500);
|
|
|
|
|
|
painter->setClipRegion(oldReg);//,TQPainter::CoordPainter);
|
|
|
|
|
|
painter->setBrush(oldBrush);
|
|
|
|
|
|
*/
|
|
|
|
|
|
/*if(!iAxis){
|
|
|
|
|
|
tqDebug("==========================");
|
|
|
|
|
|
tqDebug("nTxtHeight: "+TQString::number(nTxtHeight)+" nRotation: "+TQString::number(nRotation));
|
|
|
|
|
|
tqDebug(textsMatching ? "matching":"not matching");
|
|
|
|
|
|
}*/
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
painter->setFont( actFont );
|
|
|
|
|
|
fm = TQFontMetrics( painter->fontMetrics() );
|
|
|
|
|
|
|
|
|
|
|
|
// set colour of grid pen
|
|
|
|
|
|
TQPen gridPen, leaveOutGridPen;
|
|
|
|
|
|
if( para.axisShowGrid() && !bMultiRowBarChart )
|
|
|
|
|
|
gridPen.setColor( para.axisGridColor() );
|
|
|
|
|
|
|
|
|
|
|
|
const int pXDeltaDiv2 = static_cast < int > ( pXDelta / 2.0 );
|
|
|
|
|
|
const int pYDeltaDiv2 = static_cast < int > ( pYDelta / 2.0 );
|
|
|
|
|
|
|
|
|
|
|
|
bool bDrawAdditionalSubGridLine = false;
|
|
|
|
|
|
double pGXMicroAdjust = 0.0;
|
|
|
|
|
|
double pGYMicroAdjust = 0.0;
|
|
|
|
|
|
if ( !bTouchEdges ) {
|
|
|
|
|
|
// adjust the data values pos
|
|
|
|
|
|
p1.setX( p1.x() + pXDeltaDiv2 );
|
|
|
|
|
|
p1.setY( p1.y() + pYDeltaDiv2 );
|
|
|
|
|
|
p2.setX( p2.x() + pXDeltaDiv2 );
|
|
|
|
|
|
p2.setY( p2.y() + pYDeltaDiv2 );
|
|
|
|
|
|
// adjust the short delimiter lines pos
|
|
|
|
|
|
p2a.setX( p2a.x() + pXDeltaDiv2 );
|
|
|
|
|
|
p2a.setY( p2a.y() + pYDeltaDiv2 );
|
|
|
|
|
|
// adjust grid lines pos
|
|
|
|
|
|
bDrawAdditionalSubGridLine =
|
|
|
|
|
|
isHorizontalAxis && !
|
|
|
|
|
|
params()->axisParams(
|
|
|
|
|
|
KDChartAxisParams::AxisPosRight ).axisVisible() &&
|
|
|
|
|
|
!bMultiRowBarChart;
|
|
|
|
|
|
pGA.setX( pGA.x() + pXDeltaDiv2 );
|
|
|
|
|
|
pGA.setY( pGA.y() + pYDeltaDiv2 );
|
|
|
|
|
|
pGZ.setX( pGZ.x() + pXDeltaDiv2 );
|
|
|
|
|
|
pGZ.setY( pGZ.y() + pYDeltaDiv2 );
|
|
|
|
|
|
// fine-tune grid line pos for grid of vertical axis
|
|
|
|
|
|
if( KDChartAxisParams::AxisTypeNORTH == para.axisType() ) {
|
|
|
|
|
|
pGXMicroAdjust = cv.pXDeltaFactor * lineWidth / 2.0;
|
|
|
|
|
|
pGYMicroAdjust = cv.pYDeltaFactor * lineWidth / 2.0;
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
double x1, y1, x2, y2, xGA, yGA, xGZ, yGZ,
|
|
|
|
|
|
p1X, p1Y, p2X, p2Y, pGAX, pGAY, pGZX, pGZY, xT, yT;
|
|
|
|
|
|
|
|
|
|
|
|
double pXSubDelimDelta = pXDelta * cv.nSubDelimFactor;
|
|
|
|
|
|
double pYSubDelimDelta = pYDelta * cv.nSubDelimFactor;
|
|
|
|
|
|
|
|
|
|
|
|
if ( !cv.autoDtLabels
|
|
|
|
|
|
&& 0.0 != cv.nSubDelimFactor
|
|
|
|
|
|
&& para.axisShowSubDelimiters()
|
|
|
|
|
|
&& para.axisLabelsVisible()
|
|
|
|
|
|
&& !nLeaveOut ) {
|
|
|
|
|
|
TQPen pen( para.axisLineColor(), static_cast < int > ( 0.5 * lineWidth ) );
|
|
|
|
|
|
uint penWidth = pen.width();
|
|
|
|
|
|
bool bOk = true;
|
|
|
|
|
|
|
|
|
|
|
|
if( cv.bLogarithmic )
|
|
|
|
|
|
cv.nSubDelimFactor = 0.1;
|
|
|
|
|
|
|
|
|
|
|
|
while ( fabs( ( pXDelta + pYDelta ) * cv.nSubDelimFactor / 6.0 )
|
|
|
|
|
|
<= 1.0 + penWidth
|
|
|
|
|
|
&& bOk ) {
|
|
|
|
|
|
if ( 0 < penWidth ) {
|
|
|
|
|
|
--penWidth;
|
|
|
|
|
|
pen.setWidth( penWidth );
|
|
|
|
|
|
}else{
|
|
|
|
|
|
if( cv.bLogarithmic ){
|
|
|
|
|
|
break; // there is nothing we can do: we allways
|
|
|
|
|
|
// want 10 sub-delims per logarithmic step
|
|
|
|
|
|
}else{
|
|
|
|
|
|
if ( 0.5 != cv.nSubDelimFactor ) {
|
|
|
|
|
|
// emercency: reduce number of sub-scaling
|
|
|
|
|
|
cv.nSubDelimFactor = 0.5;
|
|
|
|
|
|
|
|
|
|
|
|
pXSubDelimDelta = pXDelta * cv.nSubDelimFactor;
|
|
|
|
|
|
pYSubDelimDelta = pYDelta * cv.nSubDelimFactor;
|
|
|
|
|
|
} else
|
|
|
|
|
|
bOk = false;
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
if ( bOk ) {
|
|
|
|
|
|
x1 = p1.x();
|
|
|
|
|
|
y1 = p1.y();
|
|
|
|
|
|
x2 = p2a.x();
|
|
|
|
|
|
y2 = p2a.y();
|
|
|
|
|
|
xGA = pGA.x();
|
|
|
|
|
|
yGA = pGA.y();
|
|
|
|
|
|
xGZ = pGZ.x();
|
|
|
|
|
|
yGZ = pGZ.y();
|
|
|
|
|
|
p1X = x1;
|
|
|
|
|
|
p1Y = y1;
|
|
|
|
|
|
p2X = x2;
|
|
|
|
|
|
p2Y = y2;
|
|
|
|
|
|
pGAX = xGA;
|
|
|
|
|
|
pGAY = yGA;
|
|
|
|
|
|
pGZX = xGZ;
|
|
|
|
|
|
pGZY = yGZ;
|
|
|
|
|
|
|
|
|
|
|
|
// set up grid pen for drawing the sub-grid lines
|
|
|
|
|
|
const TQPen oldGridPen( gridPen );
|
|
|
|
|
|
if ( para.axisShowGrid() ) {
|
|
|
|
|
|
gridPen.setColor( para.axisGridSubColor() );
|
|
|
|
|
|
gridPen.setWidth( gridSubLineWidth );
|
|
|
|
|
|
gridPen.setStyle( para.axisGridSubStyle() );
|
|
|
|
|
|
}
|
|
|
|
|
|
const TQPen oldPen( painter->pen() );
|
|
|
|
|
|
painter->setPen( pen );
|
|
|
|
|
|
double nSubDelim = ( labelTexts->count() - 1 )
|
|
|
|
|
|
/ cv.nSubDelimFactor;
|
|
|
|
|
|
|
|
|
|
|
|
//tqDebug("subDelim: %f",
|
|
|
|
|
|
modf( nSubDelim, &nSubDelim );
|
|
|
|
|
|
|
|
|
|
|
|
int logarithCnt = 1;
|
|
|
|
|
|
double xLogarithOffs = 0;
|
|
|
|
|
|
double yLogarithOffs = 0;
|
|
|
|
|
|
double dDummy;
|
|
|
|
|
|
double mainDelim = 0.0;
|
|
|
|
|
|
bool paint = true;
|
|
|
|
|
|
|
|
|
|
|
|
for ( double iDelim = 1.0;
|
|
|
|
|
|
iDelim <= nSubDelim + 1.0;
|
|
|
|
|
|
iDelim += 1.0, logarithCnt++ ) {
|
|
|
|
|
|
// test if it is a sub or a main delimiter
|
|
|
|
|
|
if ( mainDelim > 0.0 )
|
|
|
|
|
|
paint = true;
|
|
|
|
|
|
else
|
|
|
|
|
|
paint = false;
|
|
|
|
|
|
|
|
|
|
|
|
if ( cv.bLogarithmic )
|
|
|
|
|
|
{
|
|
|
|
|
|
if ( logarithCnt == 11 )
|
|
|
|
|
|
{
|
|
|
|
|
|
xLogarithOffs +=
|
|
|
|
|
|
pXDelta * log10( 10*cv.nSubDelimFactor*10 );
|
|
|
|
|
|
yLogarithOffs +=
|
|
|
|
|
|
pYDelta * log10( 10*cv.nSubDelimFactor*10 );
|
|
|
|
|
|
logarithCnt=1;
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
pXSubDelimDelta =
|
|
|
|
|
|
pXDelta * log10( 10*cv.nSubDelimFactor*logarithCnt );
|
|
|
|
|
|
pYSubDelimDelta =
|
|
|
|
|
|
pYDelta * log10( 10*cv.nSubDelimFactor*logarithCnt );
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
if ( para.axisShowGrid() && !bMultiRowBarChart) {
|
|
|
|
|
|
// draw the sub grid line
|
|
|
|
|
|
if( 0.0 != modf((iDelim-1.0) * cv.nSubDelimFactor, &dDummy) )
|
|
|
|
|
|
|
|
|
|
|
|
saveDrawLine( *painter,
|
|
|
|
|
|
TQPoint( static_cast<int>( pGAX - pGXMicroAdjust ),
|
|
|
|
|
|
static_cast<int>( pGAY - pGYMicroAdjust ) ),
|
|
|
|
|
|
TQPoint( static_cast<int>( pGZX - pGXMicroAdjust ),
|
|
|
|
|
|
static_cast<int>( pGZY - pGYMicroAdjust ) ),
|
|
|
|
|
|
gridPen );
|
|
|
|
|
|
|
|
|
|
|
|
if( cv.bLogarithmic ){
|
|
|
|
|
|
pGAX = xGA + pXSubDelimDelta + xLogarithOffs;
|
|
|
|
|
|
pGAY = yGA + pYSubDelimDelta + yLogarithOffs;
|
|
|
|
|
|
pGZX = xGZ + pXSubDelimDelta + xLogarithOffs;
|
|
|
|
|
|
pGZY = yGZ + pYSubDelimDelta + yLogarithOffs;
|
|
|
|
|
|
}else{
|
|
|
|
|
|
pGAX = xGA + iDelim * pXSubDelimDelta;
|
|
|
|
|
|
pGAY = yGA + iDelim * pYSubDelimDelta;
|
|
|
|
|
|
pGZX = xGZ + iDelim * pXSubDelimDelta;
|
|
|
|
|
|
pGZY = yGZ + iDelim * pYSubDelimDelta;
|
|
|
|
|
|
/*
|
|
|
|
|
|
if( !modf(iDelim * cv.nSubDelimFactor, &dDummy) ){
|
|
|
|
|
|
pGAX = xGA + (iDelim * cv.nSubDelimFactor) * pXDelta;
|
|
|
|
|
|
pGAY = yGA + (iDelim * cv.nSubDelimFactor) * pYDelta;
|
|
|
|
|
|
pGZX = xGZ + (iDelim * cv.nSubDelimFactor) * pXDelta;
|
|
|
|
|
|
pGZY = yGZ + (iDelim * cv.nSubDelimFactor) * pYDelta;
|
|
|
|
|
|
}
|
|
|
|
|
|
*/
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// draw the short delimiter line
|
|
|
|
|
|
// PENDING: Michel - make sure not to draw the sub-delimiters over the main ones.
|
|
|
|
|
|
// by testing if it is a sub delimiter or a main one
|
|
|
|
|
|
if ( paint )
|
|
|
|
|
|
painter->drawLine( TQPoint( static_cast<int>( p1X ), static_cast<int>( p1Y ) ),
|
|
|
|
|
|
TQPoint( static_cast<int>( p2X ), static_cast<int>( p2Y ) ) );
|
|
|
|
|
|
|
|
|
|
|
|
mainDelim += 1.0;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
if( cv.bLogarithmic ){
|
|
|
|
|
|
p1X = x1 + pXSubDelimDelta + xLogarithOffs;
|
|
|
|
|
|
p1Y = y1 + pYSubDelimDelta + yLogarithOffs;
|
|
|
|
|
|
p2X = x2 + pXSubDelimDelta + xLogarithOffs;
|
|
|
|
|
|
p2Y = y2 + pYSubDelimDelta + yLogarithOffs;
|
|
|
|
|
|
}else{
|
|
|
|
|
|
p1X = x1 + iDelim * pXSubDelimDelta;
|
|
|
|
|
|
p1Y = y1 + iDelim * pYSubDelimDelta;
|
|
|
|
|
|
p2X = x2 + iDelim * pXSubDelimDelta;
|
|
|
|
|
|
p2Y = y2 + iDelim * pYSubDelimDelta;
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
if ( mainDelim >= nSubDelim/(labelTexts->count() -1) )
|
|
|
|
|
|
mainDelim = 0.0;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
} // for
|
|
|
|
|
|
// draw additional sub grid line
|
|
|
|
|
|
if( bDrawAdditionalSubGridLine
|
|
|
|
|
|
&& para.axisShowGrid() ) {
|
|
|
|
|
|
|
|
|
|
|
|
saveDrawLine( *painter,
|
|
|
|
|
|
TQPoint( static_cast<int>( pGAX - pGXMicroAdjust ),
|
|
|
|
|
|
static_cast<int>( pGAY - pGYMicroAdjust ) ),
|
|
|
|
|
|
TQPoint( static_cast<int>( pGZX - pGXMicroAdjust ),
|
|
|
|
|
|
static_cast<int>( pGZY - pGYMicroAdjust ) ),
|
|
|
|
|
|
gridPen );
|
|
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
painter->setPen( oldPen );
|
|
|
|
|
|
gridPen = oldGridPen;
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
x1 = p1.x();
|
|
|
|
|
|
y1 = p1.y();
|
|
|
|
|
|
x2 = p2.x();
|
|
|
|
|
|
y2 = p2.y();
|
|
|
|
|
|
xGA = pGA.x();
|
|
|
|
|
|
yGA = pGA.y();
|
|
|
|
|
|
xGZ = pGZ.x();
|
|
|
|
|
|
yGZ = pGZ.y();
|
|
|
|
|
|
p1X = x1;
|
|
|
|
|
|
p1Y = y1;
|
|
|
|
|
|
p2X = x2;
|
|
|
|
|
|
p2Y = y2;
|
|
|
|
|
|
pGAX = xGA;
|
|
|
|
|
|
pGAY = yGA;
|
|
|
|
|
|
pGZX = xGZ;
|
|
|
|
|
|
pGZY = yGZ;
|
|
|
|
|
|
xT = cv.pTextsX;
|
|
|
|
|
|
yT = cv.pTextsY;
|
|
|
|
|
|
// set up grid pen for drawing the normal grid lines
|
|
|
|
|
|
if ( para.axisShowGrid() ) {
|
|
|
|
|
|
gridPen.setWidth( gridLineWidth );
|
|
|
|
|
|
gridPen.setStyle( para.axisGridStyle() );
|
|
|
|
|
|
// if axis not visible draw the 1st grid line too
|
|
|
|
|
|
if( !para.axisLineVisible() )
|
|
|
|
|
|
saveDrawLine( *painter, cv.orig, cv.dest, gridPen );
|
|
|
|
|
|
}
|
|
|
|
|
|
if( nLeaveOut ) {
|
|
|
|
|
|
leaveOutGridPen = gridPen;
|
|
|
|
|
|
leaveOutGridPen.setWidth( gridLineWidth / 2 );
|
|
|
|
|
|
leaveOutGridPen.setStyle( TQt::DotLine );
|
|
|
|
|
|
}
|
|
|
|
|
|
// =========================================================
|
|
|
|
|
|
// || The labels and delimiters and grid printing loops ||
|
|
|
|
|
|
// =========================================================
|
|
|
|
|
|
//
|
|
|
|
|
|
double iLabel = 0.0;
|
|
|
|
|
|
if( cv.autoDtLabels )
|
|
|
|
|
|
{
|
|
|
|
|
|
/*
|
|
|
|
|
|
tqDebug("\ndtLow: %i %i %i %i:%i:%i",
|
|
|
|
|
|
dtLow.date().year(),
|
|
|
|
|
|
dtLow.date().month(),
|
|
|
|
|
|
dtLow.date().day(),
|
|
|
|
|
|
dtLow.time().hour(),
|
|
|
|
|
|
dtLow.time().minute(),
|
|
|
|
|
|
dtLow.time().second());
|
|
|
|
|
|
tqDebug("dtHigh: %i %i %i %i:%i:%i",
|
|
|
|
|
|
dtHigh.date().year(),
|
|
|
|
|
|
dtHigh.date().month(),
|
|
|
|
|
|
dtHigh.date().day(),
|
|
|
|
|
|
dtHigh.time().hour(),
|
|
|
|
|
|
dtHigh.time().minute(),
|
|
|
|
|
|
dtHigh.time().second());
|
|
|
|
|
|
*/
|
|
|
|
|
|
int pXD = static_cast <int> (cv.pXDelimDeltaFaktor * 1.25 * (cv.nTxtHeight+4));
|
|
|
|
|
|
int pYD = static_cast <int> (cv.pYDelimDeltaFaktor * 1.25 * (cv.nTxtHeight+4));
|
|
|
|
|
|
int orgXD = pXD;
|
|
|
|
|
|
int orgYD = pYD;
|
|
|
|
|
|
cv.pTextsW = fabs( (0.0 == pXDelta) ? pXD : pXDelta );
|
|
|
|
|
|
cv.pTextsH = fabs( (0.0 == pYDelta) ? pYD : pYDelta );
|
|
|
|
|
|
|
|
|
|
|
|
double pSecX = x1;
|
|
|
|
|
|
double pSecY = y1;
|
|
|
|
|
|
bool secPaint= false;
|
|
|
|
|
|
double pMinX = x1;
|
|
|
|
|
|
double pMinY = y1;
|
|
|
|
|
|
bool minPaint= false;
|
|
|
|
|
|
double pHourX = x1;
|
|
|
|
|
|
double pHourY = y1;
|
|
|
|
|
|
bool hourPaint= false;
|
|
|
|
|
|
double pDayX = x1;
|
|
|
|
|
|
double pDayY = y1;
|
|
|
|
|
|
bool dayPaint= false;
|
|
|
|
|
|
/* khz: currently not used
|
|
|
|
|
|
double pWeekX = x1;
|
|
|
|
|
|
double pWeekY = y1;
|
|
|
|
|
|
bool weekPaint= false;
|
|
|
|
|
|
*/
|
|
|
|
|
|
double pMonthX = x1;
|
|
|
|
|
|
double pMonthY = y1;
|
|
|
|
|
|
bool monthPaint= false;
|
|
|
|
|
|
/*double pQuarterX = x1;
|
|
|
|
|
|
double pQuarterY = y1;
|
|
|
|
|
|
bool minPaint= false;
|
|
|
|
|
|
*/
|
|
|
|
|
|
double pYearX = x1;
|
|
|
|
|
|
double pYearY = y1;
|
|
|
|
|
|
bool yearPaint= false;
|
|
|
|
|
|
|
|
|
|
|
|
double pXYDelta = fabs( pXDelta ) + fabs( pYDelta );
|
|
|
|
|
|
|
|
|
|
|
|
if( 0.0 == para.trueAxisDeltaPixels() )
|
|
|
|
|
|
( ( KDChartAxisParams& ) para ).setTrueAxisDeltaPixels( TQMIN(_logicalWidth, _logicalHeight) / 150 );
|
|
|
|
|
|
|
|
|
|
|
|
bool dtGoDown = cv.dtLow > cv.dtHigh;
|
|
|
|
|
|
int mult = dtGoDown ? -1 : 1;
|
|
|
|
|
|
const TQDateTime& startDt = dtGoDown ? cv.dtHigh : cv.dtLow;
|
|
|
|
|
|
|
|
|
|
|
|
( ( KDChartAxisParams& ) para ).setAxisDtLowPos( x1, y1 );
|
|
|
|
|
|
// adjust stored dt-low and scale settings
|
|
|
|
|
|
( ( KDChartAxisParams& ) para ).setTrueAxisDtLow( startDt );
|
|
|
|
|
|
( ( KDChartAxisParams& ) para ).setTrueAxisDtScale( cv.dtDeltaScale );
|
|
|
|
|
|
|
|
|
|
|
|
int gridDX = pGZ.x() - pGA.x();
|
|
|
|
|
|
int gridDY = pGZ.y() - pGA.y();
|
|
|
|
|
|
if ( para.axisShowGrid() ) {
|
|
|
|
|
|
gridPen.setColor( para.axisGridColor() );
|
|
|
|
|
|
gridPen.setWidth( gridLineWidth );
|
|
|
|
|
|
gridPen.setStyle( para.axisGridStyle() );
|
|
|
|
|
|
}
|
|
|
|
|
|
TQPen subGridPen( gridPen.color(), 1, para.axisGridStyle() );
|
|
|
|
|
|
TQPen subSubGridPen( gridPen.color(), 1, para.axisGridSubStyle() );
|
|
|
|
|
|
TQPen pen = subGridPen;
|
|
|
|
|
|
|
|
|
|
|
|
TQDateTime dt( startDt );
|
|
|
|
|
|
TQDateTime newDt( startDt );
|
|
|
|
|
|
for( uint i=1; i <= nLabels; ++i ){
|
|
|
|
|
|
switch( cv.dtDeltaScale ) {
|
|
|
|
|
|
case KDChartAxisParams::ValueScaleSecond:
|
|
|
|
|
|
dtAddSecs( dt, 1 * mult, newDt );
|
|
|
|
|
|
break;
|
|
|
|
|
|
case KDChartAxisParams::ValueScaleMinute:
|
|
|
|
|
|
dtAddSecs( dt, 60 * mult, newDt );
|
|
|
|
|
|
break;
|
|
|
|
|
|
case KDChartAxisParams::ValueScaleHour:
|
|
|
|
|
|
dtAddSecs( dt, 3600 * mult, newDt );
|
|
|
|
|
|
break;
|
|
|
|
|
|
case KDChartAxisParams::ValueScaleDay:
|
|
|
|
|
|
dtAddDays( dt, 1 * mult, newDt );
|
|
|
|
|
|
break;
|
|
|
|
|
|
case KDChartAxisParams::ValueScaleWeek:
|
|
|
|
|
|
dtAddDays( dt, 7 * mult, newDt );
|
|
|
|
|
|
break;
|
|
|
|
|
|
case KDChartAxisParams::ValueScaleMonth:
|
|
|
|
|
|
dtAddMonths( dt,1 * mult, newDt );
|
|
|
|
|
|
break;
|
|
|
|
|
|
case KDChartAxisParams::ValueScaleQuarter:
|
|
|
|
|
|
dtAddMonths( dt,3 * mult, newDt );
|
|
|
|
|
|
break;
|
|
|
|
|
|
case KDChartAxisParams::ValueScaleYear:
|
|
|
|
|
|
dtAddYears( dt, 1 * mult, newDt );
|
|
|
|
|
|
break;
|
|
|
|
|
|
default:
|
|
|
|
|
|
dtAddDays( dt, 1 * mult, newDt );
|
|
|
|
|
|
break;
|
|
|
|
|
|
}
|
|
|
|
|
|
const TQDateTime& testDt
|
|
|
|
|
|
= dtGoDown
|
|
|
|
|
|
? ( ( newDt < cv.dtLow )
|
|
|
|
|
|
? cv.dtLow
|
|
|
|
|
|
: newDt )
|
|
|
|
|
|
: ( ( newDt > cv.dtHigh )
|
|
|
|
|
|
? cv.dtHigh
|
|
|
|
|
|
: newDt );
|
|
|
|
|
|
/*
|
|
|
|
|
|
tqDebug(" dt: %i %i %i %i:%i:%i",
|
|
|
|
|
|
newDt.date().year(),newDt.date().month(),newDt.date().day(),
|
|
|
|
|
|
newDt.time().hour(),newDt.time().minute(),newDt.time().second());
|
|
|
|
|
|
tqDebug("testDt: %i %i %i %i:%i:%i",
|
|
|
|
|
|
testDt.date().year(),testDt.date().month(),testDt.date().day(),
|
|
|
|
|
|
testDt.time().hour(),testDt.time().minute(),testDt.time().second());
|
|
|
|
|
|
*/
|
|
|
|
|
|
bool endLoop = (i == nLabels) || (&testDt != &newDt);
|
|
|
|
|
|
|
|
|
|
|
|
secPaint = ( KDChartAxisParams::ValueScaleSecond >= cv.dtDeltaScale ) &&
|
|
|
|
|
|
( testDt.time().second() != dt.time().second() ||
|
|
|
|
|
|
( endLoop && ((pSecX != x1) || (pSecY != y1))));
|
|
|
|
|
|
minPaint = ( KDChartAxisParams::ValueScaleMinute >= cv.dtDeltaScale ) &&
|
|
|
|
|
|
( testDt.time().minute() != dt.time().minute() ||
|
|
|
|
|
|
( endLoop && ((pMinX != x1) || (pMinY != y1))));
|
|
|
|
|
|
hourPaint = ( KDChartAxisParams::ValueScaleHour >= cv.dtDeltaScale ) &&
|
|
|
|
|
|
( testDt.time().hour() != dt.time().hour() ||
|
|
|
|
|
|
( endLoop && ((pHourX != x1) || (pHourY != y1))));
|
|
|
|
|
|
dayPaint = ( KDChartAxisParams::ValueScaleDay >= cv.dtDeltaScale ) &&
|
|
|
|
|
|
( testDt.date().day() != dt.date().day() ||
|
|
|
|
|
|
( endLoop && ((pDayX != x1) || (pDayY != y1))));
|
|
|
|
|
|
/* khz: currently not used
|
|
|
|
|
|
weekPaint = ( KDChartAxisParams::ValueScaleWeek >= cv.dtDeltaScale ) &&
|
|
|
|
|
|
( testDt.date().week() != dt.date().week() ||
|
|
|
|
|
|
( endLoop && ((pWeekX != x1) || (pWeekY != y1))));
|
|
|
|
|
|
*/
|
|
|
|
|
|
monthPaint = ( KDChartAxisParams::ValueScaleMonth >= cv.dtDeltaScale ) &&
|
|
|
|
|
|
( testDt.date().month() != dt.date().month() ||
|
|
|
|
|
|
( endLoop && ((pMonthX != x1) || (pMonthY != y1))));
|
|
|
|
|
|
yearPaint = ( KDChartAxisParams::ValueScaleYear >= cv.dtDeltaScale ) &&
|
|
|
|
|
|
( testDt.date().year() != dt.date().year() ||
|
|
|
|
|
|
( endLoop && ((pYearX != x1) || (pYearY != y1))));
|
|
|
|
|
|
|
|
|
|
|
|
p1X = x1 + iLabel * pXDelta;
|
|
|
|
|
|
p1Y = y1 + iLabel * pYDelta;
|
|
|
|
|
|
p2X = p1X + pXDelta;
|
|
|
|
|
|
p2Y = p1Y + pYDelta;
|
|
|
|
|
|
pXD = orgXD;
|
|
|
|
|
|
pYD = orgYD;
|
|
|
|
|
|
|
|
|
|
|
|
if( endLoop ){
|
|
|
|
|
|
( ( KDChartAxisParams& ) para ).setAxisDtHighPos( p1X, p1Y );
|
|
|
|
|
|
// adjust stored dt-high settings
|
|
|
|
|
|
( ( KDChartAxisParams& ) para ).setTrueAxisDtHigh( dt );
|
|
|
|
|
|
}
|
|
|
|
|
|
pen = subGridPen;
|
|
|
|
|
|
/*
|
|
|
|
|
|
// old code: just draw the seconds without any tests
|
|
|
|
|
|
// (not wise to do that when supporting sec1000
|
|
|
|
|
|
// and the like some day...)
|
|
|
|
|
|
if( newDt.time().second() != dt.time().second() ){
|
|
|
|
|
|
painter->drawLine( TQPoint( p1X, p1Y ), TQPoint( p1X+pXD, p1Y+pYD ) );
|
|
|
|
|
|
painter->drawLine( TQPoint( p1X+pXD, p1Y+pYD ),
|
|
|
|
|
|
TQPoint( p1X+pXD + pXDelta, p1Y+pYD + pYDelta ) );
|
|
|
|
|
|
painter->drawText( p1X+pXD-orgXD, p1Y+pYD-orgYD,
|
|
|
|
|
|
pTextsW, pTextsH,
|
|
|
|
|
|
textAlign | TQt::DontClip,
|
|
|
|
|
|
TQString::number( dt.time().second() ) );
|
|
|
|
|
|
pXD += orgXD;
|
|
|
|
|
|
pYD += orgYD;
|
|
|
|
|
|
}
|
|
|
|
|
|
*/
|
|
|
|
|
|
if( secPaint ){
|
|
|
|
|
|
painter->drawLine( TQPoint( static_cast<int>( pSecX+pXD ),
|
|
|
|
|
|
static_cast<int>( pSecY+pYD ) ),
|
|
|
|
|
|
TQPoint( static_cast<int>( p2X + pXD ),
|
|
|
|
|
|
static_cast<int>( p2Y + pYD ) ) );
|
|
|
|
|
|
if( (pXDelta/2.0 < p2X - pSecX) || (pYDelta/2.0 < p2Y - pSecY) ){
|
|
|
|
|
|
TQPen oldPen( painter->pen() );
|
|
|
|
|
|
painter->setPen( TQPen( labelsColor ) );
|
|
|
|
|
|
painter->drawText( static_cast<int>( pSecX+pXD-orgXD ),
|
|
|
|
|
|
static_cast<int>( pSecY+pYD-orgYD ),
|
|
|
|
|
|
static_cast<int>( fabs((0.0 == pXDelta) ? cv.pTextsW : (p2X - pSecX))),
|
|
|
|
|
|
static_cast<int>( fabs((0.0 == pYDelta) ? cv.pTextsH : (p2Y - pSecY))),
|
|
|
|
|
|
cv.textAlign | TQt::DontClip,
|
|
|
|
|
|
TQString::number( dt.time().second() ) );
|
|
|
|
|
|
painter->setPen( oldPen );
|
|
|
|
|
|
if ( para.axisShowGrid() ){
|
|
|
|
|
|
|
|
|
|
|
|
saveDrawLine( *painter,
|
|
|
|
|
|
TQPoint( static_cast<int>( pSecX ),
|
|
|
|
|
|
static_cast<int>( pSecY ) ),
|
|
|
|
|
|
TQPoint( static_cast<int>( pSecX + gridDX ),
|
|
|
|
|
|
static_cast<int>( pSecY + gridDY ) ),
|
|
|
|
|
|
pen );
|
|
|
|
|
|
pen = gridPen;
|
|
|
|
|
|
}
|
|
|
|
|
|
if( !minPaint || pMinX != pSecX || pMinY != pSecY ){
|
|
|
|
|
|
painter->drawLine( TQPoint( static_cast<int>( pSecX ),
|
|
|
|
|
|
static_cast<int>( pSecY ) ),
|
|
|
|
|
|
TQPoint( static_cast<int>( pSecX+pXD ),
|
|
|
|
|
|
static_cast<int>( pSecY+pYD ) ) );
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
if( endLoop && !minPaint )
|
|
|
|
|
|
painter->drawLine( TQPoint( static_cast<int>( p2X ),
|
|
|
|
|
|
static_cast<int>( p2Y ) ),
|
|
|
|
|
|
TQPoint( static_cast<int>( p2X+pXD ),
|
|
|
|
|
|
static_cast<int>( p2Y+pYD ) ) );
|
|
|
|
|
|
pSecX = p1X + pXDelta;
|
|
|
|
|
|
pSecY = p1Y + pYDelta;
|
|
|
|
|
|
pXD += orgXD;
|
|
|
|
|
|
pYD += orgYD;
|
|
|
|
|
|
}
|
|
|
|
|
|
if( minPaint ){
|
|
|
|
|
|
painter->drawLine( TQPoint( static_cast<int>( pMinX+pXD ),
|
|
|
|
|
|
static_cast<int>( pMinY+pYD ) ),
|
|
|
|
|
|
TQPoint( static_cast<int>( p2X + pXD ),
|
|
|
|
|
|
static_cast<int>( p2Y + pYD ) ) );
|
|
|
|
|
|
if( (pXDelta/2.0 < p2X - pMinX) || (pYDelta/2.0 < p2Y - pMinY) ){
|
|
|
|
|
|
TQPen oldPen( painter->pen() );
|
|
|
|
|
|
painter->setPen( TQPen( labelsColor ) );
|
|
|
|
|
|
painter->drawText( static_cast<int>( pMinX+pXD-orgXD ),
|
|
|
|
|
|
static_cast<int>( pMinY+pYD-orgYD ),
|
|
|
|
|
|
static_cast<int>( fabs((0.0 == pXDelta) ? cv.pTextsW : (p2X - pMinX)) ),
|
|
|
|
|
|
static_cast<int>( fabs((0.0 == pYDelta) ? cv.pTextsH : (p2Y - pMinY)) ),
|
|
|
|
|
|
cv.textAlign | TQt::DontClip,
|
|
|
|
|
|
TQString::number( dt.time().minute() ) );
|
|
|
|
|
|
painter->setPen( oldPen );
|
|
|
|
|
|
if ( para.axisShowGrid() ){
|
|
|
|
|
|
if( !secPaint && 10 < pXYDelta ){
|
|
|
|
|
|
saveDrawLine( *painter,
|
|
|
|
|
|
TQPoint( static_cast<int>( pMinX+pXDelta/2 ),
|
|
|
|
|
|
static_cast<int>( pMinY+pYDelta/2 ) ),
|
|
|
|
|
|
TQPoint( static_cast<int>( pMinX+pXDelta/2 + gridDX ),
|
|
|
|
|
|
static_cast<int>( pMinY+pYDelta/2 + gridDY ) ),
|
|
|
|
|
|
subSubGridPen );
|
|
|
|
|
|
}
|
|
|
|
|
|
saveDrawLine( *painter,
|
|
|
|
|
|
TQPoint( static_cast<int>( pMinX ),
|
|
|
|
|
|
static_cast<int>( pMinY ) ),
|
|
|
|
|
|
TQPoint( static_cast<int>( pMinX + gridDX ),
|
|
|
|
|
|
static_cast<int>( pMinY + gridDY ) ),
|
|
|
|
|
|
pen );
|
|
|
|
|
|
pen = gridPen;
|
|
|
|
|
|
}
|
|
|
|
|
|
if( !hourPaint || pHourX != pMinX || pHourY != pMinY ){
|
|
|
|
|
|
painter->drawLine( TQPoint( static_cast<int>( pMinX ),
|
|
|
|
|
|
static_cast<int>( pMinY ) ),
|
|
|
|
|
|
TQPoint( static_cast<int>( pMinX+pXD ),
|
|
|
|
|
|
static_cast<int>( pMinY+pYD ) ) );
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
if( endLoop && !hourPaint )
|
|
|
|
|
|
painter->drawLine( TQPoint( static_cast<int>( p2X ),
|
|
|
|
|
|
static_cast<int>( p2Y ) ),
|
|
|
|
|
|
TQPoint( static_cast<int>( p2X+pXD ),
|
|
|
|
|
|
static_cast<int>( p2Y+pYD ) ) );
|
|
|
|
|
|
pMinX = p1X + pXDelta;
|
|
|
|
|
|
pMinY = p1Y + pYDelta;
|
|
|
|
|
|
pXD += orgXD;
|
|
|
|
|
|
pYD += orgYD;
|
|
|
|
|
|
}
|
|
|
|
|
|
if( hourPaint ){
|
|
|
|
|
|
painter->drawLine( TQPoint( static_cast<int>( pHourX+pXD ),
|
|
|
|
|
|
static_cast<int>( pHourY+pYD ) ),
|
|
|
|
|
|
TQPoint( static_cast<int>( p2X + pXD ),
|
|
|
|
|
|
static_cast<int>( p2Y + pYD ) ) );
|
|
|
|
|
|
/*
|
|
|
|
|
|
tqDebug("line");
|
|
|
|
|
|
tqDebug("pXDelta / 2.0 : %f", pXDelta/2.0);
|
|
|
|
|
|
tqDebug("p2X - pHourX : %f", p2X - pHourX);
|
|
|
|
|
|
*/
|
|
|
|
|
|
if( (pXDelta/2.0 < p2X - pHourX) || (pYDelta/2.0 < p2Y - pHourY) ){
|
|
|
|
|
|
/*
|
|
|
|
|
|
tqDebug("pHourX %f", pHourX );
|
|
|
|
|
|
tqDebug(" +pXD %i", pXD );
|
|
|
|
|
|
tqDebug(" -orgXD %i", orgXD);
|
|
|
|
|
|
tqDebug("pHourY %f", pHourY );
|
|
|
|
|
|
tqDebug(" +pYD %i", pYD );
|
|
|
|
|
|
tqDebug(" -orgYD %i", orgYD);
|
|
|
|
|
|
*/
|
|
|
|
|
|
TQPen oldPen( painter->pen() );
|
|
|
|
|
|
painter->setPen( TQPen( labelsColor ) );
|
|
|
|
|
|
painter->drawText( static_cast<int>( pHourX+pXD-orgXD ),
|
|
|
|
|
|
static_cast<int>( pHourY+pYD-orgYD ),
|
|
|
|
|
|
static_cast<int>( fabs((0.0 == pXDelta) ? cv.pTextsW : (p2X - pHourX))),
|
|
|
|
|
|
static_cast<int>( fabs((0.0 == pYDelta) ? cv.pTextsH : (p2Y - pHourY))),
|
|
|
|
|
|
cv.textAlign | TQt::DontClip,
|
|
|
|
|
|
TQString::number( dt.time().hour() ) );
|
|
|
|
|
|
painter->setPen( oldPen );
|
|
|
|
|
|
if ( para.axisShowGrid() ){
|
|
|
|
|
|
if( !minPaint && 10 < pXYDelta ){
|
|
|
|
|
|
saveDrawLine( *painter,
|
|
|
|
|
|
TQPoint( static_cast<int>( pHourX+pXDelta/2 ),
|
|
|
|
|
|
static_cast<int>( pHourY+pYDelta/2 ) ),
|
|
|
|
|
|
TQPoint( static_cast<int>( pHourX+pXDelta/2 + gridDX ),
|
|
|
|
|
|
static_cast<int>( pHourY+pYDelta/2 + gridDY ) ),
|
|
|
|
|
|
subSubGridPen );
|
|
|
|
|
|
}
|
|
|
|
|
|
saveDrawLine( *painter,
|
|
|
|
|
|
TQPoint( static_cast<int>( pHourX ),
|
|
|
|
|
|
static_cast<int>( pHourY ) ),
|
|
|
|
|
|
TQPoint( static_cast<int>( pHourX + gridDX ),
|
|
|
|
|
|
static_cast<int>( pHourY + gridDY ) ),
|
|
|
|
|
|
pen );
|
|
|
|
|
|
pen = gridPen;
|
|
|
|
|
|
}
|
|
|
|
|
|
if( !dayPaint || pDayX != pHourX || pDayY != pHourY ){
|
|
|
|
|
|
painter->drawLine( TQPoint( static_cast<int>( pHourX ),
|
|
|
|
|
|
static_cast<int>( pHourY ) ),
|
|
|
|
|
|
TQPoint( static_cast<int>( pHourX+pXD ),
|
|
|
|
|
|
static_cast<int>( pHourY+pYD ) ) );
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
if( endLoop && !dayPaint )
|
|
|
|
|
|
painter->drawLine( TQPoint( static_cast<int>( p2X ),
|
|
|
|
|
|
static_cast<int>( p2Y ) ),
|
|
|
|
|
|
TQPoint( static_cast<int>( p2X+pXD ),
|
|
|
|
|
|
static_cast<int>( p2Y+pYD ) ) );
|
|
|
|
|
|
pHourX = p1X + pXDelta;
|
|
|
|
|
|
pHourY = p1Y + pYDelta;
|
|
|
|
|
|
pXD += orgXD;
|
|
|
|
|
|
pYD += orgYD;
|
|
|
|
|
|
}
|
|
|
|
|
|
if( dayPaint ){
|
|
|
|
|
|
painter->drawLine( TQPoint( static_cast<int>( pDayX+pXD ),
|
|
|
|
|
|
static_cast<int>( pDayY+pYD ) ),
|
|
|
|
|
|
TQPoint( static_cast<int>( p2X + pXD ),
|
|
|
|
|
|
static_cast<int>( p2Y + pYD ) ) );
|
|
|
|
|
|
if( (pXDelta/2.0 < p2X - pDayX) || (pYDelta/2.0 < p2Y - pDayY) ){
|
|
|
|
|
|
TQPen oldPen( painter->pen() );
|
|
|
|
|
|
painter->setPen( TQPen( labelsColor ) );
|
|
|
|
|
|
painter->drawText( static_cast<int>( pDayX+pXD-orgXD ),
|
|
|
|
|
|
static_cast<int>( pDayY+pYD-orgYD ),
|
|
|
|
|
|
static_cast<int>( fabs((0.0 == pXDelta) ? cv.pTextsW : (p2X - pDayX)) ),
|
|
|
|
|
|
static_cast<int>( fabs((0.0 == pYDelta) ? cv.pTextsH : (p2Y - pDayY)) ),
|
|
|
|
|
|
cv.textAlign | TQt::DontClip,
|
|
|
|
|
|
TQString::number( dt.date().day() ) );
|
|
|
|
|
|
painter->setPen( oldPen );
|
|
|
|
|
|
/* khz: currently not used
|
|
|
|
|
|
if( !weekPaint || pWeekX != pDayX || pWeekY != pDayY )
|
|
|
|
|
|
*/
|
|
|
|
|
|
if ( para.axisShowGrid() ){
|
|
|
|
|
|
if( !hourPaint && 10 < pXYDelta ){
|
|
|
|
|
|
saveDrawLine( *painter,
|
|
|
|
|
|
TQPoint( static_cast<int>( pDayX+pXDelta/2 ),
|
|
|
|
|
|
static_cast<int>( pDayY+pYDelta/2 ) ),
|
|
|
|
|
|
TQPoint( static_cast<int>( pDayX+pXDelta/2 + gridDX ),
|
|
|
|
|
|
static_cast<int>( pDayY+pYDelta/2 + gridDY ) ),
|
|
|
|
|
|
subSubGridPen );
|
|
|
|
|
|
}
|
|
|
|
|
|
saveDrawLine( *painter,
|
|
|
|
|
|
TQPoint( static_cast<int>( pDayX ),
|
|
|
|
|
|
static_cast<int>( pDayY ) ),
|
|
|
|
|
|
TQPoint( static_cast<int>( pDayX + gridDX ),
|
|
|
|
|
|
static_cast<int>( pDayY + gridDY ) ),
|
|
|
|
|
|
pen );
|
|
|
|
|
|
pen = gridPen;
|
|
|
|
|
|
}
|
|
|
|
|
|
if( !monthPaint || pMonthX != pDayX || pMonthY != pDayY ){
|
|
|
|
|
|
painter->drawLine( TQPoint( static_cast<int>( pDayX ),
|
|
|
|
|
|
static_cast<int>( pDayY ) ),
|
|
|
|
|
|
TQPoint( static_cast<int>( pDayX+pXD ),
|
|
|
|
|
|
static_cast<int>( pDayY+pYD ) ) );
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
/* khz: currently not used
|
|
|
|
|
|
if( endLoop && !weekPaint )
|
|
|
|
|
|
*/
|
|
|
|
|
|
if( endLoop && !monthPaint )
|
|
|
|
|
|
painter->drawLine( TQPoint( static_cast<int>( p2X ),
|
|
|
|
|
|
static_cast<int>( p2Y ) ),
|
|
|
|
|
|
TQPoint( static_cast<int>( p2X+pXD ),
|
|
|
|
|
|
static_cast<int>( p2Y+pYD ) ) );
|
|
|
|
|
|
pDayX = p1X + pXDelta;
|
|
|
|
|
|
pDayY = p1Y + pYDelta;
|
|
|
|
|
|
pXD += orgXD;
|
|
|
|
|
|
pYD += orgYD;
|
|
|
|
|
|
}
|
|
|
|
|
|
/* khz: currently unused
|
|
|
|
|
|
if( weekPaint ){
|
|
|
|
|
|
painter->drawLine( TQPoint( pWeekX+pXD, pWeekY+pYD ),
|
|
|
|
|
|
TQPoint( p2X + pXD, p2Y + pYD ) );
|
|
|
|
|
|
if( (pXDelta/2.0 < p2X - pWeekX) || (pYDelta/2.0 < p2Y - pWeekY) ){
|
|
|
|
|
|
TQPen oldPen( painter->pen() );
|
|
|
|
|
|
painter->setPen( TQPen( labelsColor ) );
|
|
|
|
|
|
painter->drawText( pWeekX+pXD-orgXD, pWeekY+pYD-orgYD,
|
|
|
|
|
|
painter->setPen( oldPen );
|
|
|
|
|
|
fabs((0.0 == pXDelta) ? pTextsW : (p2X - pWeekX)),
|
|
|
|
|
|
fabs((0.0 == pYDelta) ? pTextsH : (p2Y - pWeekY)),
|
|
|
|
|
|
textAlign | TQt::DontClip,
|
|
|
|
|
|
TQString::number( dt.date().week() ) );
|
|
|
|
|
|
if ( para.axisShowGrid() ){
|
|
|
|
|
|
if( !dayPaint && 40 < pXYDelta ){
|
|
|
|
|
|
// draw 7 lines:
|
|
|
|
|
|
//saveDrawLine( *painter,
|
|
|
|
|
|
// TQPoint( pWeekX+pXDelta/2,
|
|
|
|
|
|
// pWeekY+pYDelta/2 ),
|
|
|
|
|
|
// TQPoint( pWeekX+pXDelta/2 + gridDX,
|
|
|
|
|
|
// pWeekY+pYDelta/2 + gridDY ),
|
|
|
|
|
|
// subSubGridPen );
|
|
|
|
|
|
}
|
|
|
|
|
|
saveDrawLine( *painter,
|
|
|
|
|
|
TQPoint( pWeekX,
|
|
|
|
|
|
pWeekY ),
|
|
|
|
|
|
TQPoint( pWeekX + gridDX,
|
|
|
|
|
|
pWeekY + gridDY ),
|
|
|
|
|
|
pen );
|
|
|
|
|
|
pen = gridPen;
|
|
|
|
|
|
}
|
|
|
|
|
|
if( !monthPaint || pMonthX != pDayX || pMonthY != pDayY ){
|
|
|
|
|
|
painter->drawLine( TQPoint( pWeekX, pWeekY ), TQPoint( pWeekX+pXD, pWeekY+pYD ) );
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
if( endLoop && !monthPaint )
|
|
|
|
|
|
painter->drawLine( TQPoint( p2X, p2Y ), TQPoint( p2X+pXD, p2Y+pYD ) );
|
|
|
|
|
|
pWeekX = p1X + pXDelta;
|
|
|
|
|
|
pWeekY = p1Y + pYDelta;
|
|
|
|
|
|
pXD += orgXD;
|
|
|
|
|
|
pYD += orgYD;
|
|
|
|
|
|
}
|
|
|
|
|
|
*/
|
|
|
|
|
|
if( monthPaint ){
|
|
|
|
|
|
painter->drawLine( TQPoint( static_cast<int>( pMonthX+pXD ),
|
|
|
|
|
|
static_cast<int>( pMonthY+pYD ) ),
|
|
|
|
|
|
TQPoint( static_cast<int>( p2X + pXD ),
|
|
|
|
|
|
static_cast<int>( p2Y + pYD ) ) );
|
|
|
|
|
|
if( (pXDelta/2.0 < p2X - pMonthX) || (pYDelta/2.0 < p2Y - pMonthY) ){
|
|
|
|
|
|
TQPen oldPen( painter->pen() );
|
|
|
|
|
|
painter->setPen( TQPen( labelsColor ) );
|
|
|
|
|
|
painter->drawText( static_cast<int>( pMonthX+pXD-orgXD ),
|
|
|
|
|
|
static_cast<int>( pMonthY+pYD-orgYD ),
|
|
|
|
|
|
static_cast<int>( fabs((0.0 == pXDelta) ? cv.pTextsW : (p2X - pMonthX)) ),
|
|
|
|
|
|
static_cast<int>( fabs((0.0 == pYDelta) ? cv.pTextsH : (p2Y - pMonthY)) ),
|
|
|
|
|
|
cv.textAlign | TQt::DontClip,
|
|
|
|
|
|
TQString::number( dt.date().month() ) );
|
|
|
|
|
|
painter->setPen( oldPen );
|
|
|
|
|
|
if ( para.axisShowGrid() ){
|
|
|
|
|
|
/* khz: currently unused
|
|
|
|
|
|
if( !weekPaint &&
|
|
|
|
|
|
&& 10 < pXYDelta ){
|
|
|
|
|
|
saveDrawLine( *painter,
|
|
|
|
|
|
TQPoint( pMonthX+pXDelta/2,
|
|
|
|
|
|
pMonthY+pYDelta/2 ),
|
|
|
|
|
|
TQPoint( pMonthX+pXDelta/2 + gridDX,
|
|
|
|
|
|
pMonthY+pYDelta/2 + gridDY ),
|
|
|
|
|
|
subSubGridPen );
|
|
|
|
|
|
}
|
|
|
|
|
|
*/
|
|
|
|
|
|
saveDrawLine( *painter,
|
|
|
|
|
|
TQPoint( static_cast<int>( pMonthX ),
|
|
|
|
|
|
static_cast<int>( pMonthY ) ),
|
|
|
|
|
|
TQPoint( static_cast<int>( pMonthX + gridDX ),
|
|
|
|
|
|
static_cast<int>( pMonthY + gridDY ) ),
|
|
|
|
|
|
pen );
|
|
|
|
|
|
pen = gridPen;
|
|
|
|
|
|
}
|
|
|
|
|
|
if( !yearPaint || pYearX != pMonthX || pYearY != pMonthY ){
|
|
|
|
|
|
painter->drawLine( TQPoint( static_cast<int>( pMonthX ),
|
|
|
|
|
|
static_cast<int>( pMonthY ) ),
|
|
|
|
|
|
TQPoint( static_cast<int>( pMonthX+pXD ),
|
|
|
|
|
|
static_cast<int>( pMonthY+pYD ) ) );
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
if( endLoop && !yearPaint )
|
|
|
|
|
|
painter->drawLine( TQPoint( static_cast<int>( p2X ),
|
|
|
|
|
|
static_cast<int>( p2Y ) ),
|
|
|
|
|
|
TQPoint( static_cast<int>( p2X+pXD ),
|
|
|
|
|
|
static_cast<int>( p2Y+pYD ) ) );
|
|
|
|
|
|
pMonthX = p1X + pXDelta;
|
|
|
|
|
|
pMonthY = p1Y + pYDelta;
|
|
|
|
|
|
pXD += orgXD;
|
|
|
|
|
|
pYD += orgYD;
|
|
|
|
|
|
}
|
|
|
|
|
|
if( yearPaint ){
|
|
|
|
|
|
painter->drawLine( TQPoint( static_cast<int>( pYearX+pXD ),
|
|
|
|
|
|
static_cast<int>( pYearY+pYD ) ),
|
|
|
|
|
|
TQPoint( static_cast<int>( p2X + pXD ),
|
|
|
|
|
|
static_cast<int>( p2Y + pYD ) ) );
|
|
|
|
|
|
if( (pXDelta/2.0 < p2X - pYearX) || (pYDelta/2.0 < p2Y - pYearY) ){
|
|
|
|
|
|
TQPen oldPen( painter->pen() );
|
|
|
|
|
|
painter->setPen( TQPen( labelsColor ) );
|
|
|
|
|
|
painter->drawText( static_cast<int>( pYearX+pXD-orgXD ),
|
|
|
|
|
|
static_cast<int>( pYearY+pYD-orgYD ),
|
|
|
|
|
|
static_cast<int>( fabs((0.0 == pXDelta) ? cv.pTextsW : (p2X - pYearX)) ),
|
|
|
|
|
|
static_cast<int>( fabs((0.0 == pYDelta) ? cv.pTextsH : (p2Y - pYearY)) ),
|
|
|
|
|
|
cv.textAlign | TQt::DontClip,
|
|
|
|
|
|
TQString::number( dt.date().year() ) );
|
|
|
|
|
|
painter->setPen( oldPen );
|
|
|
|
|
|
if ( para.axisShowGrid() ){
|
|
|
|
|
|
if( !monthPaint && 10 < pXYDelta ){
|
|
|
|
|
|
saveDrawLine( *painter,
|
|
|
|
|
|
TQPoint( static_cast<int>( pYearX+pXDelta/2 ),
|
|
|
|
|
|
static_cast<int>( pYearY+pYDelta/2 ) ),
|
|
|
|
|
|
TQPoint( static_cast<int>( pYearX+pXDelta/2 + gridDX ),
|
|
|
|
|
|
static_cast<int>( pYearY+pYDelta/2 + gridDY ) ),
|
|
|
|
|
|
subSubGridPen );
|
|
|
|
|
|
}
|
|
|
|
|
|
saveDrawLine( *painter,
|
|
|
|
|
|
TQPoint( static_cast<int>( pYearX ),
|
|
|
|
|
|
static_cast<int>( pYearY ) ),
|
|
|
|
|
|
TQPoint( static_cast<int>( pYearX + gridDX ),
|
|
|
|
|
|
static_cast<int>( pYearY + gridDY ) ),
|
|
|
|
|
|
pen );
|
|
|
|
|
|
pen = gridPen;
|
|
|
|
|
|
}
|
|
|
|
|
|
painter->drawLine( TQPoint( static_cast<int>( pYearX ),
|
|
|
|
|
|
static_cast<int>( pYearY ) ),
|
|
|
|
|
|
TQPoint( static_cast<int>( pYearX+pXD ),
|
|
|
|
|
|
static_cast<int>( pYearY+pYD ) ) );
|
|
|
|
|
|
}
|
|
|
|
|
|
if( endLoop )
|
|
|
|
|
|
painter->drawLine( TQPoint( static_cast<int>( p2X ),
|
|
|
|
|
|
static_cast<int>( p2Y ) ),
|
|
|
|
|
|
TQPoint( static_cast<int>( p2X+pXD ),
|
|
|
|
|
|
static_cast<int>( p2Y+pYD ) ) );
|
|
|
|
|
|
pYearX = p1X + pXDelta;
|
|
|
|
|
|
pYearY = p1Y + pYDelta;
|
|
|
|
|
|
pXD += orgXD;
|
|
|
|
|
|
pYD += orgYD;
|
|
|
|
|
|
}
|
|
|
|
|
|
if( &testDt != &newDt )
|
|
|
|
|
|
break;
|
|
|
|
|
|
dt = newDt;
|
|
|
|
|
|
iLabel += 1.0;
|
|
|
|
|
|
}
|
|
|
|
|
|
if( !commonDtHeader.isEmpty() ){
|
|
|
|
|
|
TQPen oldPen( painter->pen() );
|
|
|
|
|
|
painter->setPen( TQPen( labelsColor ) );
|
|
|
|
|
|
painter->drawText( static_cast<int>( x1 + pXD ), static_cast<int>( y1 + pYD ),
|
|
|
|
|
|
commonDtHeader );
|
|
|
|
|
|
painter->setPen( oldPen );
|
|
|
|
|
|
}
|
|
|
|
|
|
}else{
|
|
|
|
|
|
int iLeaveOut = nLeaveOut;
|
|
|
|
|
|
TQString label;
|
|
|
|
|
|
for ( TQStringList::Iterator labelIter = labelTexts->begin();
|
|
|
|
|
|
labelIter != labelTexts->end();
|
|
|
|
|
|
++labelIter ) {
|
|
|
|
|
|
TQDateTime dt;
|
|
|
|
|
|
if( cv.isDateTime ){
|
|
|
|
|
|
dt = TQDateTime::fromString( *labelIter,
|
|
|
|
|
|
TQt::ISODate );
|
|
|
|
|
|
label = dt.toString( formatDT );
|
|
|
|
|
|
}else{
|
|
|
|
|
|
label = *labelIter;
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
if( iLeaveOut < nLeaveOut )
|
|
|
|
|
|
++iLeaveOut;
|
|
|
|
|
|
else
|
|
|
|
|
|
iLeaveOut = 0;
|
|
|
|
|
|
//Pending Michel: test if the user implicitely wants to get rid
|
|
|
|
|
|
//of the non fractional values delimiters and grid lines.
|
|
|
|
|
|
// axisDigitsBehindComma == 0 and the user implicitely
|
|
|
|
|
|
// setAxisShowFractionalValuesDelimiters() to false
|
|
|
|
|
|
bool showDelim = para.axisShowFractionalValuesDelimiters();
|
|
|
|
|
|
if ( para.axisShowGrid() && !bMultiRowBarChart ) {
|
|
|
|
|
|
if ( !label.isNull() || showDelim ){
|
|
|
|
|
|
if( !iLeaveOut )
|
|
|
|
|
|
// draw the main grid line
|
|
|
|
|
|
|
|
|
|
|
|
saveDrawLine( *painter,
|
|
|
|
|
|
TQPoint( static_cast<int>( pGAX - pGXMicroAdjust ),
|
|
|
|
|
|
static_cast<int>( pGAY - pGYMicroAdjust ) ),
|
|
|
|
|
|
TQPoint( static_cast<int>( pGZX - pGXMicroAdjust ),
|
|
|
|
|
|
static_cast<int>( pGZY - pGYMicroAdjust ) ),
|
|
|
|
|
|
gridPen );
|
|
|
|
|
|
|
|
|
|
|
|
else if( para.axisShowSubDelimiters() )
|
|
|
|
|
|
// draw a thin sub grid line instead of main line
|
|
|
|
|
|
saveDrawLine( *painter,
|
|
|
|
|
|
TQPoint( static_cast<int>( pGAX - pGXMicroAdjust ),
|
|
|
|
|
|
static_cast<int>( pGAY - pGYMicroAdjust ) ),
|
|
|
|
|
|
TQPoint( static_cast<int>( pGZX - pGXMicroAdjust ),
|
|
|
|
|
|
static_cast<int>( pGZY - pGYMicroAdjust ) ),
|
|
|
|
|
|
leaveOutGridPen );
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
if ( para.axisLabelsVisible() ) {
|
|
|
|
|
|
if( !iLeaveOut ) {
|
|
|
|
|
|
/*PENDING Michel: those points should not be redrawn if sub-delimiters are drawn
|
|
|
|
|
|
*drawing the submarkers
|
|
|
|
|
|
* make it visible or not
|
|
|
|
|
|
*In the case we have a null label - axisDigitsBehindComma is implicitely set to 0 -
|
|
|
|
|
|
*also paint or dont paint the delimiter corresponding to this label - default is paint.
|
|
|
|
|
|
*/
|
|
|
|
|
|
if ( !label.isNull() || showDelim )
|
|
|
|
|
|
painter->drawLine( TQPoint( static_cast<int>( p1X ),
|
|
|
|
|
|
static_cast<int>( p1Y ) ),
|
|
|
|
|
|
TQPoint( static_cast<int>( p2X ),
|
|
|
|
|
|
static_cast<int>( p2Y ) ) );
|
|
|
|
|
|
|
|
|
|
|
|
cv.pLastX = p1X;
|
|
|
|
|
|
cv.pLastY = p1Y;
|
|
|
|
|
|
TQPen oldPen( painter->pen() );
|
|
|
|
|
|
painter->setPen( TQPen( labelsColor ) );
|
|
|
|
|
|
if( para.axisLabelsDontShrinkFont()
|
|
|
|
|
|
&& isHorizontalAxis
|
|
|
|
|
|
&& (TQt::AlignHCenter == (cv.textAlign & TQt::AlignHCenter)) ) {
|
|
|
|
|
|
double w = fm.width( label ) + 4.0;
|
|
|
|
|
|
double x0 = cv.pTextsX + cv.pTextsW / 2.0;
|
|
|
|
|
|
|
|
|
|
|
|
painter->drawText( static_cast<int>( x0 - w / 2.0 ),
|
|
|
|
|
|
static_cast<int>( cv.pTextsY ),
|
|
|
|
|
|
static_cast<int>( w ),
|
|
|
|
|
|
static_cast<int>( cv.pTextsH ),
|
|
|
|
|
|
cv.textAlign, label );
|
|
|
|
|
|
} else {
|
|
|
|
|
|
if( nRotation ){
|
|
|
|
|
|
KDDrawText::drawRotatedText(
|
|
|
|
|
|
painter,
|
|
|
|
|
|
nRotation,
|
|
|
|
|
|
painter->worldMatrix().map(
|
|
|
|
|
|
TQPoint( static_cast<int>( cv.pTextsX ),
|
|
|
|
|
|
static_cast<int>( cv.pTextsY ) ) ),
|
|
|
|
|
|
label,
|
|
|
|
|
|
0,
|
|
|
|
|
|
cv.textAlign,
|
|
|
|
|
|
false,
|
|
|
|
|
|
&fm,
|
|
|
|
|
|
screenOutput,screenOutput,0,
|
|
|
|
|
|
screenOutput );
|
|
|
|
|
|
} else {
|
|
|
|
|
|
// Pending Michel draw the axis labels
|
|
|
|
|
|
painter->drawText( static_cast<int>( cv.pTextsX ),
|
|
|
|
|
|
static_cast<int>( cv.pTextsY ),
|
|
|
|
|
|
static_cast<int>( cv.pTextsW ),
|
|
|
|
|
|
static_cast<int>( cv.pTextsH ),
|
|
|
|
|
|
cv.textAlign | TQt::DontClip,
|
|
|
|
|
|
label );
|
|
|
|
|
|
|
|
|
|
|
|
// debugging text rect
|
|
|
|
|
|
/*
|
|
|
|
|
|
painter->drawRect(static_cast <int>(cv.pTextsX),
|
|
|
|
|
|
static_cast <int>(cv.pTextsY),
|
|
|
|
|
|
static_cast <int> (nUsableAxisWidth),
|
|
|
|
|
|
static_cast <int> (nUsableAxisHeight));
|
|
|
|
|
|
*/
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
painter->setPen( oldPen );
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
if( cv.isDateTime ){
|
|
|
|
|
|
if( labelTexts->begin() == labelIter ){
|
|
|
|
|
|
((KDChartAxisParams&)para).setAxisDtLowPos(
|
|
|
|
|
|
pGAX - pGXMicroAdjust,
|
|
|
|
|
|
pGAY - pGYMicroAdjust );
|
|
|
|
|
|
// adjust stored dt-low settings
|
|
|
|
|
|
( ( KDChartAxisParams& ) para ).setTrueAxisDtLow( dt );
|
|
|
|
|
|
}else{
|
|
|
|
|
|
((KDChartAxisParams&)para).setAxisDtHighPos(
|
|
|
|
|
|
pGAX - pGXMicroAdjust,
|
|
|
|
|
|
pGAY - pGYMicroAdjust );
|
|
|
|
|
|
// adjust stored dt-high settings
|
|
|
|
|
|
( ( KDChartAxisParams& ) para ).setTrueAxisDtHigh( dt );
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
iLabel += 1.0;
|
|
|
|
|
|
p1X = x1 + iLabel * pXDelta;
|
|
|
|
|
|
p1Y = y1 + iLabel * pYDelta;
|
|
|
|
|
|
p2X = x2 + iLabel * pXDelta;
|
|
|
|
|
|
p2Y = y2 + iLabel * pYDelta;
|
|
|
|
|
|
cv.pTextsX = xT + iLabel * pXDelta;
|
|
|
|
|
|
cv.pTextsY = yT + iLabel * pYDelta;
|
|
|
|
|
|
|
|
|
|
|
|
pGAX = xGA + iLabel * pXDelta;
|
|
|
|
|
|
pGAY = yGA + iLabel * pYDelta;
|
|
|
|
|
|
pGZX = xGZ + iLabel * pXDelta;
|
|
|
|
|
|
pGZY = yGZ + iLabel * pYDelta;
|
|
|
|
|
|
/*
|
|
|
|
|
|
pGAX = xGA + iLabel * pXSubDelimDelta / cv.nSubDelimFactor;
|
|
|
|
|
|
pGAY = yGA + iLabel * pYSubDelimDelta / cv.nSubDelimFactor;
|
|
|
|
|
|
pGZX = xGZ + iLabel * pXSubDelimDelta / cv.nSubDelimFactor;
|
|
|
|
|
|
pGZY = yGZ + iLabel * pYSubDelimDelta / cv.nSubDelimFactor;
|
|
|
|
|
|
*/
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// adjust zero-line start, if not starting at origin
|
|
|
|
|
|
if ( cv.bSteadyCalc &&
|
|
|
|
|
|
( para.axisValuesDecreasing() ||
|
|
|
|
|
|
(0.0 != para.trueAxisLow()) ) ) {
|
|
|
|
|
|
//double x = p1.x();
|
|
|
|
|
|
double x = 0.0;
|
|
|
|
|
|
/* we have to find the *real* X axis position,
|
|
|
|
|
|
this is NOT always the p1.x() as it is the
|
|
|
|
|
|
case for left2 or right2 axes. [cmw, 12/01/2005] */
|
|
|
|
|
|
if (cv.basicPos==KDChartAxisParams::AxisPosRight)
|
|
|
|
|
|
x = static_cast<double>(_dataRect.right());
|
|
|
|
|
|
else
|
|
|
|
|
|
x = static_cast<double>(_dataRect.left());
|
|
|
|
|
|
double y = p1.y();
|
|
|
|
|
|
double mult = para.trueAxisLow() / para.trueAxisDelta();
|
|
|
|
|
|
x -= mult * pXDelta;
|
|
|
|
|
|
y -= mult * pYDelta;
|
|
|
|
|
|
axisZeroLineStartX = x;
|
|
|
|
|
|
axisZeroLineStartY = y;
|
|
|
|
|
|
//tqDebug( "axisZeroLineStartX %f, axisZeroLineStartY %f",
|
|
|
|
|
|
// axisZeroLineStartX, axisZeroLineStartY );
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
painter->setClipping( oldClippingFlag );
|
|
|
|
|
|
} // if( nLabels )
|
|
|
|
|
|
|
|
|
|
|
|
// draw zero-line (Ok, this might be overwritten by axes
|
|
|
|
|
|
// cause those are drawn after all labels and grid and
|
|
|
|
|
|
// zero-line(s) has been painted, see code below, starting
|
|
|
|
|
|
// with "// draw all the axes".
|
|
|
|
|
|
if ( cv.bSteadyCalc && !cv.isDateTime ) {
|
|
|
|
|
|
( ( KDChartAxisParams& ) para ).setAxisZeroLineStart( axisZeroLineStartX, axisZeroLineStartY );
|
|
|
|
|
|
double axisZeroLineStart;
|
|
|
|
|
|
int minCoord, maxCoord;
|
|
|
|
|
|
double xFactor, yFactor;
|
|
|
|
|
|
switch( cv.basicPos ){
|
|
|
|
|
|
case KDChartAxisParams::AxisPosLeft:
|
|
|
|
|
|
xFactor = 1.0;
|
|
|
|
|
|
yFactor = 0.0;
|
|
|
|
|
|
axisZeroLineStart = axisZeroLineStartY;
|
|
|
|
|
|
minCoord = TQMIN( cv.orig.y(), cv.dest.y() );
|
|
|
|
|
|
maxCoord = TQMAX( cv.orig.y(), cv.dest.y() );
|
|
|
|
|
|
|
|
|
|
|
|
break;
|
|
|
|
|
|
case KDChartAxisParams::AxisPosRight:
|
|
|
|
|
|
xFactor = -1.0;
|
|
|
|
|
|
yFactor = 0.0;
|
|
|
|
|
|
axisZeroLineStart = axisZeroLineStartY;
|
|
|
|
|
|
minCoord = TQMIN( cv.orig.y(), cv.dest.y() );
|
|
|
|
|
|
maxCoord = TQMAX( cv.orig.y(), cv.dest.y() );
|
|
|
|
|
|
break;
|
|
|
|
|
|
case KDChartAxisParams::AxisPosTop:
|
|
|
|
|
|
xFactor = 0.0;
|
|
|
|
|
|
yFactor = 1.0;
|
|
|
|
|
|
axisZeroLineStart = axisZeroLineStartX;
|
|
|
|
|
|
minCoord = TQMIN( cv.orig.x(), cv.dest.x() );
|
|
|
|
|
|
maxCoord = TQMAX( cv.orig.x(), cv.dest.x() );
|
|
|
|
|
|
break;
|
|
|
|
|
|
case KDChartAxisParams::AxisPosBottom:
|
|
|
|
|
|
xFactor = 0.0;
|
|
|
|
|
|
yFactor = -1.0;
|
|
|
|
|
|
axisZeroLineStart = axisZeroLineStartX;
|
|
|
|
|
|
minCoord = TQMIN( cv.orig.x(), cv.dest.x() );
|
|
|
|
|
|
maxCoord = TQMAX( cv.orig.x(), cv.dest.x() );
|
|
|
|
|
|
break;
|
|
|
|
|
|
default:
|
|
|
|
|
|
xFactor = 0.0;
|
|
|
|
|
|
yFactor = 0.0;
|
|
|
|
|
|
axisZeroLineStart = 0.0;
|
|
|
|
|
|
minCoord = 0;
|
|
|
|
|
|
maxCoord = 0;
|
|
|
|
|
|
}
|
|
|
|
|
|
if( axisZeroLineStart >= minCoord &&
|
|
|
|
|
|
axisZeroLineStart <= maxCoord ){
|
|
|
|
|
|
TQPoint pZ0( static_cast<int>( para.axisZeroLineStartX() ),
|
|
|
|
|
|
static_cast<int>( para.axisZeroLineStartY() ) );
|
|
|
|
|
|
TQPoint pZ( static_cast<int>( para.axisZeroLineStartX()
|
|
|
|
|
|
+ xFactor * _dataRect.width() ),
|
|
|
|
|
|
static_cast<int>( para.axisZeroLineStartY()
|
|
|
|
|
|
+ yFactor * _dataRect.height() ) );
|
|
|
|
|
|
//tqDebug("------");
|
|
|
|
|
|
saveDrawLine( *painter,
|
|
|
|
|
|
pZ0,
|
|
|
|
|
|
pZ,
|
|
|
|
|
|
TQPen( para.axisZeroLineColor(),
|
|
|
|
|
|
lineWidth ) );
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// Drawing all the axes lines:
|
|
|
|
|
|
/*
|
|
|
|
|
|
// 1. test if the standard axes are share one or several corner points
|
|
|
|
|
|
// if yes, we first draw a polyline using a "TQt::MiterJoin" PenJoinStyle
|
|
|
|
|
|
// to make sure the corners are filled
|
|
|
|
|
|
internal__KDChart__CalcValues& cv1 = calcVal[ KDChartAxisParams::AxisPosLeft ];
|
|
|
|
|
|
internal__KDChart__CalcValues& cv2 = calcVal[ KDChartAxisParams::AxisPosBottom ];
|
|
|
|
|
|
const KDChartAxisParams& pa1 = params()->axisParams( KDChartAxisParams::AxisPosLeft );
|
|
|
|
|
|
const KDChartAxisParams& pa2 = params()->axisParams( KDChartAxisParams::AxisPosBottom );
|
|
|
|
|
|
tqDebug("\n\nx1: %i y1: %i w1: %i\nx2: %i y2: %i w2: %i",
|
|
|
|
|
|
cv1.orig.x(), cv1.orig.y(), pa1.axisTrueLineWidth(),
|
|
|
|
|
|
cv2.orig.x(), cv2.orig.y(), pa2.axisTrueLineWidth() );
|
|
|
|
|
|
if( cv1.orig == cv2.orig ){
|
|
|
|
|
|
const TQColor c1( pa1.axisLineColor() );
|
|
|
|
|
|
const TQColor c2( pa2.axisLineColor() );
|
|
|
|
|
|
const TQPoint pA( cv1.dest );
|
|
|
|
|
|
const TQPoint pB( cv1.orig );
|
|
|
|
|
|
const TQPoint pC( cv2.dest );
|
|
|
|
|
|
TQPen pen( TQColor( (c1.red() + c2.red()) /2,
|
|
|
|
|
|
(c1.green() + c2.green())/2,
|
|
|
|
|
|
(c1.blue() + c2.blue()) /2 ),
|
|
|
|
|
|
TQMIN(pa1.axisTrueLineWidth(), pa2.axisTrueLineWidth()) );
|
|
|
|
|
|
pen.setJoinStyle( TQt::MiterJoin );
|
|
|
|
|
|
painter->setPen( pen );
|
|
|
|
|
|
TQPointArray a;
|
|
|
|
|
|
a.putPoints( 0, 3, pA.x(),pA.y(), pB.x(),pB.y(), pC.x(),pC.y() );
|
|
|
|
|
|
painter->drawPolyline( a );
|
|
|
|
|
|
tqDebug("done\n" );
|
|
|
|
|
|
}
|
|
|
|
|
|
*/
|
|
|
|
|
|
// 2. draw the axes using their normal color
|
|
|
|
|
|
for( iAxis = 0; iAxis < KDCHART_MAX_AXES; ++iAxis ){
|
|
|
|
|
|
internal__KDChart__CalcValues& cv = calcVal[iAxis];
|
|
|
|
|
|
const KDChartAxisParams & para = params()->axisParams( iAxis );
|
|
|
|
|
|
if( cv.processThisAxis && para.axisLineVisible() ){
|
|
|
|
|
|
painter->setPen( TQPen( para.axisLineColor(),
|
|
|
|
|
|
para.axisTrueLineWidth() ) );
|
|
|
|
|
|
int x = cv.dest.x();
|
|
|
|
|
|
if( 2.0 >= TQABS(cv.pLastX - x) )
|
|
|
|
|
|
x = static_cast < int > ( cv.pLastX );
|
|
|
|
|
|
int y = cv.dest.y();
|
|
|
|
|
|
if( 2.0 >= TQABS(cv.pLastY - y) )
|
|
|
|
|
|
y = static_cast < int > ( cv.pLastY );
|
|
|
|
|
|
painter->drawLine( cv.orig, TQPoint(x,y) );
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
painter->restore();
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
double fastPow10( int x )
|
|
|
|
|
|
{
|
|
|
|
|
|
double res = 1.0;
|
|
|
|
|
|
if( 0 <= x ){
|
|
|
|
|
|
for( int i = 1; i <= x; ++i )
|
|
|
|
|
|
res *= 10.0;
|
|
|
|
|
|
}else{
|
|
|
|
|
|
for( int i = -1; i >= x; --i )
|
|
|
|
|
|
res /= 10.0;
|
|
|
|
|
|
}
|
|
|
|
|
|
return res;
|
|
|
|
|
|
}
|
|
|
|
|
|
double fastPow10( double x )
|
|
|
|
|
|
{
|
|
|
|
|
|
return pow(10.0, x);
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
|
Calculates the actual label texts for one axis.
|
|
|
|
|
|
|
|
|
|
|
|
\note When calling this function the actual area size for this
|
|
|
|
|
|
axis must be set, this means you may only call it when
|
|
|
|
|
|
\c KDChartPainter::setupGeometry() has been called before.
|
|
|
|
|
|
|
|
|
|
|
|
\param painter the TQPainter onto which the chart should be painted
|
|
|
|
|
|
\param data the data that will be displayed as a chart
|
|
|
|
|
|
\param params the KDChartParams that were specified globally
|
|
|
|
|
|
\param axisNumber the number of this axis (used in some params structures)
|
|
|
|
|
|
\param averageValueP1000 (average height+width of the prtbl. area) / 1000
|
|
|
|
|
|
\param basicPos the basic axis position returned by
|
|
|
|
|
|
KDChartAxisParams::basicAxisPos()
|
|
|
|
|
|
\param orig the axis start point
|
|
|
|
|
|
\param delimLen the length of one delimiter mark
|
|
|
|
|
|
\param (all others) the reference parameters to be returned
|
|
|
|
|
|
by this function
|
|
|
|
|
|
*/
|
|
|
|
|
|
/**** static ****/
|
|
|
|
|
|
void KDChartAxesPainter::calculateLabelTexts(
|
|
|
|
|
|
TQPainter* painter,
|
|
|
|
|
|
const KDChartTableDataBase& data,
|
|
|
|
|
|
const KDChartParams& params,
|
|
|
|
|
|
uint axisNumber,
|
|
|
|
|
|
double averageValueP1000,
|
|
|
|
|
|
double delimLen,
|
|
|
|
|
|
// start of return parameters
|
|
|
|
|
|
KDChartAxisParams::AxisPos& basicPos,
|
|
|
|
|
|
TQPoint& orig,
|
|
|
|
|
|
TQPoint& dest,
|
|
|
|
|
|
double& pXDeltaFactor,
|
|
|
|
|
|
double& pYDeltaFactor,
|
|
|
|
|
|
double& pXDelimDeltaFaktor,
|
|
|
|
|
|
double& pYDelimDeltaFaktor,
|
|
|
|
|
|
double& nSubDelimFactor,
|
|
|
|
|
|
double& pDelimDelta,
|
|
|
|
|
|
double& nTxtHeight,
|
|
|
|
|
|
double& pTextsX,
|
|
|
|
|
|
double& pTextsY,
|
|
|
|
|
|
double& pTextsW,
|
|
|
|
|
|
double& pTextsH,
|
|
|
|
|
|
int& textAlign,
|
|
|
|
|
|
bool& isLogarithmic,
|
|
|
|
|
|
bool& isDateTime,
|
|
|
|
|
|
bool& autoDtLabels,
|
|
|
|
|
|
TQDateTime& dtLow,
|
|
|
|
|
|
TQDateTime& dtHigh,
|
|
|
|
|
|
KDChartAxisParams::ValueScale& dtDeltaScale,
|
|
|
|
|
|
bool adjustTheValues,
|
|
|
|
|
|
double trueDelta,
|
|
|
|
|
|
double trueDeltaPix )
|
|
|
|
|
|
{
|
|
|
|
|
|
//tqDebug("\nentering KDChartAxesPainter::calculateLabelTexts() : nTxtHeight: "+TQString::number(nTxtHeight));
|
|
|
|
|
|
const KDChartAxisParams & para = params.axisParams( axisNumber );
|
|
|
|
|
|
|
|
|
|
|
|
// store whether the labels are to be drawn in reverted order
|
|
|
|
|
|
const bool bDecreasing = para.axisValuesDecreasing();
|
|
|
|
|
|
|
|
|
|
|
|
basicPos = KDChartAxisParams::basicAxisPos( axisNumber );
|
|
|
|
|
|
|
|
|
|
|
|
pXDeltaFactor = 0.0;
|
|
|
|
|
|
pYDeltaFactor = 0.0;
|
|
|
|
|
|
pXDelimDeltaFaktor = 0.0;
|
|
|
|
|
|
pYDelimDeltaFaktor = 0.0;
|
|
|
|
|
|
int axisLength;
|
|
|
|
|
|
switch ( basicPos ) {
|
|
|
|
|
|
case KDChartAxisParams::AxisPosBottom: {
|
|
|
|
|
|
axisLength = para.axisTrueAreaRect().width();
|
|
|
|
|
|
orig = bDecreasing
|
|
|
|
|
|
? para.axisTrueAreaRect().topRight()
|
|
|
|
|
|
: para.axisTrueAreaRect().topLeft();
|
|
|
|
|
|
dest = bDecreasing
|
|
|
|
|
|
? para.axisTrueAreaRect().topLeft()
|
|
|
|
|
|
: para.axisTrueAreaRect().topRight();
|
|
|
|
|
|
pYDelimDeltaFaktor = 1.0;
|
|
|
|
|
|
pXDeltaFactor = bDecreasing ? -1.0 : 1.0;
|
|
|
|
|
|
//tqDebug("\nsetting pXDeltaFactor for axis %x", axisNumber);
|
|
|
|
|
|
//tqDebug(bDecreasing ? "bDecreasing = TRUE" : "bDecreasing = FALSE");
|
|
|
|
|
|
//tqDebug("pXDeltaFactor = %f\n",pXDeltaFactor);
|
|
|
|
|
|
}
|
|
|
|
|
|
break;
|
|
|
|
|
|
case KDChartAxisParams::AxisPosLeft: {
|
|
|
|
|
|
axisLength = para.axisTrueAreaRect().height();
|
|
|
|
|
|
orig = bDecreasing
|
|
|
|
|
|
? para.axisTrueAreaRect().topRight()
|
|
|
|
|
|
: para.axisTrueAreaRect().bottomRight();
|
|
|
|
|
|
dest = bDecreasing
|
|
|
|
|
|
? para.axisTrueAreaRect().bottomRight()
|
|
|
|
|
|
: para.axisTrueAreaRect().topRight();
|
|
|
|
|
|
pXDelimDeltaFaktor = -1.0;
|
|
|
|
|
|
pYDeltaFactor = bDecreasing ? 1.0 : -1.0;
|
|
|
|
|
|
}
|
|
|
|
|
|
break;
|
|
|
|
|
|
case KDChartAxisParams::AxisPosTop: {
|
|
|
|
|
|
axisLength = para.axisTrueAreaRect().width();
|
|
|
|
|
|
orig = bDecreasing
|
|
|
|
|
|
? para.axisTrueAreaRect().bottomRight()
|
|
|
|
|
|
: para.axisTrueAreaRect().bottomLeft();
|
|
|
|
|
|
dest = bDecreasing
|
|
|
|
|
|
? para.axisTrueAreaRect().bottomLeft()
|
|
|
|
|
|
: para.axisTrueAreaRect().bottomRight();
|
|
|
|
|
|
pYDelimDeltaFaktor = -1.0;
|
|
|
|
|
|
pXDeltaFactor = bDecreasing ? -1.0 : 1.0;
|
|
|
|
|
|
}
|
|
|
|
|
|
break;
|
|
|
|
|
|
case KDChartAxisParams::AxisPosRight: {
|
|
|
|
|
|
axisLength = para.axisTrueAreaRect().height();
|
|
|
|
|
|
orig = bDecreasing
|
|
|
|
|
|
? para.axisTrueAreaRect().topLeft()
|
|
|
|
|
|
: para.axisTrueAreaRect().bottomLeft();
|
|
|
|
|
|
dest = bDecreasing
|
|
|
|
|
|
? para.axisTrueAreaRect().bottomLeft()
|
|
|
|
|
|
: para.axisTrueAreaRect().topLeft();
|
|
|
|
|
|
pXDelimDeltaFaktor = 1.0;
|
|
|
|
|
|
pYDeltaFactor = bDecreasing ? 1.0 : -1.0;
|
|
|
|
|
|
}
|
|
|
|
|
|
break;
|
|
|
|
|
|
default: {
|
|
|
|
|
|
axisLength = 0;
|
|
|
|
|
|
tqDebug( "IMPLEMENTATION ERROR: KDChartAxesPainter::paintAxes() unhandled enum value." );
|
|
|
|
|
|
}
|
|
|
|
|
|
break;
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// which dataset(s) is/are represented by this axis?
|
|
|
|
|
|
uint dataset, dataset2, chart;
|
|
|
|
|
|
if ( !params.axisDatasets( axisNumber, dataset, dataset2, chart ) ) {
|
|
|
|
|
|
dataset = KDCHART_ALL_DATASETS;
|
|
|
|
|
|
dataset2 = KDCHART_ALL_DATASETS;
|
|
|
|
|
|
chart = 0;
|
|
|
|
|
|
//tqDebug("\nautomatic set values: chart: %u,\ndataset: %u, dataset2: %u",
|
|
|
|
|
|
//chart, dataset, dataset2);
|
|
|
|
|
|
}
|
|
|
|
|
|
// which dataset(s) with mode DataEntry (or mode ExtraLinesAnchor, resp.)
|
|
|
|
|
|
// is/are represented by this axis?
|
|
|
|
|
|
uint dataDataset, dataDataset2;
|
|
|
|
|
|
if( params.findDatasets( KDChartParams::DataEntry,
|
|
|
|
|
|
KDChartParams::ExtraLinesAnchor,
|
|
|
|
|
|
dataDataset,
|
|
|
|
|
|
dataDataset2,
|
|
|
|
|
|
chart ) ) {
|
|
|
|
|
|
// adjust dataDataset in case MORE THAN ONE AXIS
|
|
|
|
|
|
// is representing THIS CHART
|
|
|
|
|
|
if( ( KDCHART_ALL_DATASETS != dataset
|
|
|
|
|
|
&& KDCHART_NO_DATASET != dataset )
|
|
|
|
|
|
|| ( KDCHART_ALL_DATASETS != dataDataset
|
|
|
|
|
|
&& KDCHART_NO_DATASET != dataDataset ) ){
|
|
|
|
|
|
int ds = (KDCHART_ALL_DATASETS != dataset)
|
|
|
|
|
|
? dataset
|
|
|
|
|
|
: 0;
|
|
|
|
|
|
int dds = (KDCHART_ALL_DATASETS != dataDataset)
|
|
|
|
|
|
? dataDataset
|
|
|
|
|
|
: 0;
|
|
|
|
|
|
dataDataset = TQMAX( ds, dds );
|
|
|
|
|
|
}
|
|
|
|
|
|
if( ( KDCHART_ALL_DATASETS != dataset2
|
|
|
|
|
|
&& KDCHART_NO_DATASET != dataset2 )
|
|
|
|
|
|
|| ( KDCHART_ALL_DATASETS != dataDataset2
|
|
|
|
|
|
&& KDCHART_NO_DATASET != dataDataset2 ) ){
|
|
|
|
|
|
int ds2 = (KDCHART_ALL_DATASETS != dataset2)
|
|
|
|
|
|
? dataset2
|
|
|
|
|
|
: KDCHART_MAX_AXES-1;
|
|
|
|
|
|
int dds2 = (KDCHART_ALL_DATASETS != dataDataset2)
|
|
|
|
|
|
? dataDataset2
|
|
|
|
|
|
: KDCHART_MAX_AXES-1;
|
|
|
|
|
|
dataDataset2 = TQMIN( ds2, dds2 );
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
else {
|
|
|
|
|
|
// Should not happen
|
|
|
|
|
|
tqDebug( "IMPLEMENTATION ERROR: findDatasets( DataEntry, ExtraLinesAnchor ) should *always* return true. (b)" );
|
|
|
|
|
|
dataDataset = KDCHART_ALL_DATASETS;
|
|
|
|
|
|
}
|
|
|
|
|
|
//tqDebug("\naxisNumber: %x\nchart: %x\ndataset: %x, dataset2: %x,\ndataDataset: %x, dataDataset2: %x",
|
|
|
|
|
|
//axisNumber, chart, dataset, dataset2, dataDataset, dataDataset2);
|
|
|
|
|
|
|
|
|
|
|
|
if ( para.axisLabelsFontUseRelSize() ){
|
|
|
|
|
|
nTxtHeight = para.axisLabelsFontRelSize()
|
|
|
|
|
|
* averageValueP1000;
|
|
|
|
|
|
//tqDebug("using rel. size in KDChartAxesPainter::calculateLabelTexts() : nTxtHeight: "+TQString::number(nTxtHeight));
|
|
|
|
|
|
}else {
|
|
|
|
|
|
TQFontInfo info( para.axisLabelsFont() );
|
|
|
|
|
|
nTxtHeight = info.pointSize();
|
|
|
|
|
|
//tqDebug("using FIXED size in KDChartAxesPainter::calculateLabelTexts() : nTxtHeight: "+TQString::number(nTxtHeight));
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
const KDChartEnums::NumberNotation notation = para.axisLabelsNotation();
|
|
|
|
|
|
const int behindComma = para.axisDigitsBehindComma();
|
|
|
|
|
|
const int divPow10 = para.axisLabelsDivPow10();
|
|
|
|
|
|
const TQString decimalPoint = para.axisLabelsDecimalPoint();
|
|
|
|
|
|
const TQString thousandsPoint = para.axisLabelsThousandsPoint();
|
|
|
|
|
|
const TQString prefix = para.axisLabelsPrefix();
|
|
|
|
|
|
const TQString postfix = para.axisLabelsPostfix();
|
|
|
|
|
|
const int totalLen = para.axisLabelsTotalLen();
|
|
|
|
|
|
const TQChar padFill = para.axisLabelsPadFill();
|
|
|
|
|
|
const bool blockAlign = para.axisLabelsBlockAlign();
|
|
|
|
|
|
|
|
|
|
|
|
TQStringList labelTexts;
|
|
|
|
|
|
int colNum = para.labelTextsDataRow();
|
|
|
|
|
|
bool bDone = true;
|
|
|
|
|
|
switch ( para.axisLabelTextsFormDataRow() ) {
|
|
|
|
|
|
case KDChartAxisParams::LabelsFromDataRowYes: {
|
|
|
|
|
|
// Take whatever is in the specified column (even if not a string)
|
|
|
|
|
|
int trueBehindComma = -1;
|
|
|
|
|
|
TQVariant value;
|
|
|
|
|
|
for ( uint iDataset = 0; iDataset < data.usedRows(); iDataset++ ) {
|
|
|
|
|
|
if( data.cellCoord( iDataset, colNum, value, 1 ) ){
|
|
|
|
|
|
if( TQVariant::String == value.type() )
|
|
|
|
|
|
labelTexts.append( value.toString() );
|
|
|
|
|
|
else {
|
|
|
|
|
|
labelTexts.append( applyLabelsFormat( value.toDouble(),
|
|
|
|
|
|
divPow10,
|
|
|
|
|
|
behindComma,
|
|
|
|
|
|
para.axisValueDelta(),
|
|
|
|
|
|
trueBehindComma,
|
|
|
|
|
|
notation,
|
|
|
|
|
|
decimalPoint,
|
|
|
|
|
|
thousandsPoint,
|
|
|
|
|
|
prefix,
|
|
|
|
|
|
postfix,
|
|
|
|
|
|
totalLen,
|
|
|
|
|
|
padFill,
|
|
|
|
|
|
blockAlign ) );
|
|
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
break;
|
|
|
|
|
|
}
|
|
|
|
|
|
case KDChartAxisParams::LabelsFromDataRowGuess: {
|
|
|
|
|
|
TQVariant value;
|
|
|
|
|
|
for ( uint iDataset = 0; iDataset < data.usedRows(); iDataset++ ) {
|
|
|
|
|
|
if( data.cellCoord( iDataset, colNum, value, 1 ) ){
|
|
|
|
|
|
if( TQVariant::String == value.type() ){
|
|
|
|
|
|
const TQString sVal( value.toString() );
|
|
|
|
|
|
if( !sVal.isEmpty() && !sVal.isNull() )
|
|
|
|
|
|
labelTexts.append( sVal );
|
|
|
|
|
|
}
|
|
|
|
|
|
}else{
|
|
|
|
|
|
labelTexts.clear();
|
|
|
|
|
|
bDone = false;
|
|
|
|
|
|
break;
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
break;
|
|
|
|
|
|
}
|
|
|
|
|
|
case KDChartAxisParams::LabelsFromDataRowNo: {
|
|
|
|
|
|
bDone = false;
|
|
|
|
|
|
break;
|
|
|
|
|
|
}
|
|
|
|
|
|
default:
|
|
|
|
|
|
// Should not happen
|
|
|
|
|
|
tqDebug( "KDChart: Unknown label texts source" );
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// if necessary adjust text params *including* the steady value calc setting
|
|
|
|
|
|
const bool dataCellsHaveSeveralCoordinates =
|
|
|
|
|
|
(KDCHART_ALL_DATASETS == dataDataset)
|
|
|
|
|
|
? data.cellsHaveSeveralCoordinates()
|
|
|
|
|
|
: data.cellsHaveSeveralCoordinates( dataDataset, dataDataset2 );
|
|
|
|
|
|
if( dataCellsHaveSeveralCoordinates && !para.axisSteadyValueCalc() )
|
|
|
|
|
|
((KDChartParams&)params).setAxisLabelTextParams(
|
|
|
|
|
|
axisNumber,
|
|
|
|
|
|
true,
|
|
|
|
|
|
KDCHART_AXIS_LABELS_AUTO_LIMIT,
|
|
|
|
|
|
KDCHART_AXIS_LABELS_AUTO_LIMIT,
|
|
|
|
|
|
KDCHART_AXIS_LABELS_AUTO_DELTA,
|
|
|
|
|
|
para.axisLabelsDigitsBehindComma() );// NOTE: This sets MANY other params to default values too!
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
const KDChartParams::ChartType params_chartType
|
|
|
|
|
|
= ( 0 == chart )
|
|
|
|
|
|
? params.chartType()
|
|
|
|
|
|
: params.additionalChartType();
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// store whether we are calculating Ordinate-like axis values
|
|
|
|
|
|
const bool bSteadyCalc = para.axisSteadyValueCalc();
|
|
|
|
|
|
|
|
|
|
|
|
// store whether logarithmic calculation is wanted
|
|
|
|
|
|
isLogarithmic = bSteadyCalc &&
|
|
|
|
|
|
(KDChartParams::Line == params_chartType) &&
|
|
|
|
|
|
(KDChartAxisParams::AxisCalcLogarithmic == para.axisCalcMode());
|
|
|
|
|
|
|
|
|
|
|
|
//tqDebug(bSteadyCalc ? "bSteadyCalc":"NOT bSteadyCalc");
|
|
|
|
|
|
//tqDebug(isLogarithmic? "isLogarithmic":"NOT isLogarithmic");
|
|
|
|
|
|
|
|
|
|
|
|
// store whether this is a vertical axis or a horizontal axis
|
|
|
|
|
|
const bool bVertAxis = (KDChartAxisParams::AxisPosLeft == basicPos) ||
|
|
|
|
|
|
(KDChartAxisParams::AxisPosRight == basicPos);
|
|
|
|
|
|
|
|
|
|
|
|
// store the coordinate number to be used for this axis
|
|
|
|
|
|
const int coordinate = bVertAxis ? 1 : 2;
|
|
|
|
|
|
|
|
|
|
|
|
// store whether our coordinates are double or TQDateTime values
|
|
|
|
|
|
const TQVariant::Type valueType =
|
|
|
|
|
|
(KDCHART_ALL_DATASETS == dataDataset)
|
|
|
|
|
|
? data.cellsValueType( coordinate )
|
|
|
|
|
|
: data.cellsValueType( dataDataset, dataDataset2, coordinate );
|
|
|
|
|
|
isDateTime = valueType == TQVariant::DateTime;
|
|
|
|
|
|
bool bIsDouble = valueType == TQVariant::Double;
|
|
|
|
|
|
|
|
|
|
|
|
autoDtLabels = isDateTime && ( KDCHART_AXIS_LABELS_AUTO_DATETIME_FORMAT
|
|
|
|
|
|
== para.axisLabelsDateTimeFormat() );
|
|
|
|
|
|
|
|
|
|
|
|
if( autoDtLabels || bSteadyCalc )
|
|
|
|
|
|
( ( KDChartAxisParams& ) para ).setAxisLabelsTouchEdges( true );
|
|
|
|
|
|
|
|
|
|
|
|
bool bStatistical = KDChartParams::HiLo == params_chartType
|
|
|
|
|
|
|| KDChartParams::BoxWhisker == params_chartType;
|
|
|
|
|
|
|
|
|
|
|
|
if ( !bVertAxis && KDChartParams::BoxWhisker == params_chartType
|
|
|
|
|
|
&& ! para.axisLabelStringCount() ) {
|
|
|
|
|
|
uint ds1 = (KDCHART_ALL_DATASETS == dataDataset)
|
|
|
|
|
|
? 0
|
|
|
|
|
|
: dataDataset;
|
|
|
|
|
|
uint ds2 = (KDCHART_ALL_DATASETS == dataDataset)
|
|
|
|
|
|
? data.usedRows() - 1
|
|
|
|
|
|
: dataDataset2;
|
|
|
|
|
|
for (uint i = ds1; i <= ds2; ++i)
|
|
|
|
|
|
labelTexts.append(
|
|
|
|
|
|
TQObject::tr( "Series " ) + TQString::number( i + 1 ) );
|
|
|
|
|
|
bDone = true;
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
double nLow = 1.0 + bSteadyCalc;// ? 0.0 : data.colsScrolledBy();
|
|
|
|
|
|
double nHigh = 10.0;
|
|
|
|
|
|
double nDelta = 1.0;
|
|
|
|
|
|
if ( !bDone ) {
|
|
|
|
|
|
bDone = true;
|
|
|
|
|
|
|
|
|
|
|
|
// look if exact label specification was made via limits and delta
|
|
|
|
|
|
if ( ! isLogarithmic
|
|
|
|
|
|
&& ! para.axisLabelStringCount()
|
|
|
|
|
|
&& ! ( KDCHART_AXIS_LABELS_AUTO_LIMIT == para.axisValueStart() )
|
|
|
|
|
|
&& ! ( KDCHART_AXIS_LABELS_AUTO_LIMIT == para.axisValueEnd() )
|
|
|
|
|
|
&& ! ( para.axisValueStart() == para.axisValueEnd() )
|
|
|
|
|
|
&& ! ( KDCHART_AXIS_LABELS_AUTO_DELTA == para.axisValueDelta() )
|
|
|
|
|
|
&& ! ( 0.0 == para.axisValueDelta() ) ) {
|
|
|
|
|
|
nLow = para.axisValueStart().toDouble();
|
|
|
|
|
|
nHigh = para.axisValueEnd().toDouble();
|
|
|
|
|
|
nDelta = para.axisValueDelta();
|
|
|
|
|
|
int behindComma = para.axisDigitsBehindComma();
|
|
|
|
|
|
int trueBehindComma = -1;
|
|
|
|
|
|
bool upwards = (nLow < nHigh);
|
|
|
|
|
|
if( upwards != (0.0 < nDelta) )
|
|
|
|
|
|
nDelta *= -1.0;
|
|
|
|
|
|
double nVal = nLow;
|
|
|
|
|
|
bDone = false;
|
|
|
|
|
|
bool bShowVeryLastLabel = false;
|
|
|
|
|
|
//tqDebug("\n nLow: %f, nHigh: %f, nDelta: %f", nLow, nHigh, nDelta );
|
|
|
|
|
|
while( bShowVeryLastLabel || (upwards ? (nVal <= nHigh) : (nVal >= nHigh)) ){
|
|
|
|
|
|
//tqDebug("nVal : %f", nVal );
|
|
|
|
|
|
labelTexts.append( applyLabelsFormat( nVal,
|
|
|
|
|
|
divPow10,
|
|
|
|
|
|
behindComma,
|
|
|
|
|
|
nDelta,
|
|
|
|
|
|
trueBehindComma,
|
|
|
|
|
|
notation,
|
|
|
|
|
|
decimalPoint,
|
|
|
|
|
|
thousandsPoint,
|
|
|
|
|
|
prefix,
|
|
|
|
|
|
postfix,
|
|
|
|
|
|
totalLen,
|
|
|
|
|
|
padFill,
|
|
|
|
|
|
blockAlign ) );
|
|
|
|
|
|
nVal += nDelta;
|
|
|
|
|
|
//tqDebug("nVal-neu: %f", nVal );
|
|
|
|
|
|
if( ! (upwards ? (nVal <= nHigh) : (nVal >= nHigh)) ){
|
|
|
|
|
|
// work around a rounding error: show the last label, even if not nVal == nHigh is not matching exactly
|
|
|
|
|
|
if( bShowVeryLastLabel )
|
|
|
|
|
|
bShowVeryLastLabel = false;
|
|
|
|
|
|
else{
|
|
|
|
|
|
TQString sHigh( applyLabelsFormat( nHigh,
|
|
|
|
|
|
divPow10,
|
|
|
|
|
|
behindComma,
|
|
|
|
|
|
nDelta,
|
|
|
|
|
|
trueBehindComma,
|
|
|
|
|
|
notation,
|
|
|
|
|
|
decimalPoint,
|
|
|
|
|
|
thousandsPoint,
|
|
|
|
|
|
prefix,
|
|
|
|
|
|
postfix,
|
|
|
|
|
|
totalLen,
|
|
|
|
|
|
padFill,
|
|
|
|
|
|
blockAlign ) );
|
|
|
|
|
|
TQString sValue( applyLabelsFormat( nVal,
|
|
|
|
|
|
divPow10,
|
|
|
|
|
|
behindComma,
|
|
|
|
|
|
nDelta,
|
|
|
|
|
|
trueBehindComma,
|
|
|
|
|
|
notation,
|
|
|
|
|
|
decimalPoint,
|
|
|
|
|
|
thousandsPoint,
|
|
|
|
|
|
prefix,
|
|
|
|
|
|
postfix,
|
|
|
|
|
|
totalLen,
|
|
|
|
|
|
padFill,
|
|
|
|
|
|
blockAlign ) );
|
|
|
|
|
|
bShowVeryLastLabel = (sValue == sHigh);
|
|
|
|
|
|
//tqDebug("test: sHigh: "+sHigh+" sValue: "+sValue );
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
bDone = true;
|
|
|
|
|
|
}
|
|
|
|
|
|
( ( KDChartAxisParams& ) para ).setTrueAxisLowHighDelta( nLow, nHigh, nDelta );
|
|
|
|
|
|
//tqDebug("\n[Z-0] nLow: %f, nHigh: %f, nDelta: %f", nLow, nHigh, nDelta );
|
|
|
|
|
|
} // look if a string list was specified
|
|
|
|
|
|
else if ( para.axisLabelStringCount() ) {
|
|
|
|
|
|
int nLabels = bSteadyCalc
|
|
|
|
|
|
? para.axisLabelStringCount()
|
|
|
|
|
|
: bStatistical ? data.usedRows() : data.usedCols();
|
|
|
|
|
|
calculateBasicTextFactors( nTxtHeight, para, averageValueP1000,
|
|
|
|
|
|
basicPos, orig, delimLen, nLabels,
|
|
|
|
|
|
// start of return parameters
|
|
|
|
|
|
pDelimDelta,
|
|
|
|
|
|
pTextsX, pTextsY, pTextsW, pTextsH,
|
|
|
|
|
|
textAlign );
|
|
|
|
|
|
bool useShortLabels = false;
|
|
|
|
|
|
TQStringList tmpList( para.axisLabelStringList() );
|
|
|
|
|
|
|
|
|
|
|
|
// find start- and/or end-entry
|
|
|
|
|
|
int iStart = 0;
|
|
|
|
|
|
int iEnd = para.axisLabelStringCount() - 1;
|
|
|
|
|
|
if( ! ( KDCHART_AXIS_LABELS_AUTO_LIMIT == para.axisValueStart() )
|
|
|
|
|
|
|| ! ( KDCHART_AXIS_LABELS_AUTO_LIMIT == para.axisValueEnd() ) ) {
|
|
|
|
|
|
const bool testStart = !( TQVariant::String == para.axisValueStart().type() );
|
|
|
|
|
|
const bool testEnd = !( TQVariant::String == para.axisValueEnd().type() );
|
|
|
|
|
|
TQString sStart = testStart
|
|
|
|
|
|
? para.axisValueStart().toString().upper()
|
|
|
|
|
|
: TQString();
|
|
|
|
|
|
TQString sEnd = testEnd
|
|
|
|
|
|
? para.axisValueEnd().toString().upper()
|
|
|
|
|
|
: TQString();
|
|
|
|
|
|
|
|
|
|
|
|
uint i = 0;
|
|
|
|
|
|
for ( TQStringList::Iterator it = tmpList.begin();
|
|
|
|
|
|
it != tmpList.end(); ++it, ++i ) {
|
|
|
|
|
|
if ( 0 == iStart &&
|
|
|
|
|
|
0 == TQString::compare( sStart, ( *it ).upper() ) ) {
|
|
|
|
|
|
iStart = i;
|
|
|
|
|
|
}
|
|
|
|
|
|
if ( 0 == TQString::compare( sEnd, ( *it ).upper() ) ) {
|
|
|
|
|
|
iEnd = i;
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// check text widths to ensure all the entries will fit
|
|
|
|
|
|
// into the available space
|
|
|
|
|
|
if ( para.axisLabelStringCount()
|
|
|
|
|
|
&& para.axisShortLabelsStringCount()
|
|
|
|
|
|
&& para.axisLabelStringList() != para.axisShortLabelsStringList() ) {
|
|
|
|
|
|
TQFont font( para.axisLabelsFont() );
|
|
|
|
|
|
if ( para.axisLabelsFontUseRelSize() )
|
|
|
|
|
|
font.setPixelSize( static_cast < int > ( nTxtHeight ) );
|
|
|
|
|
|
painter->setFont( font );
|
|
|
|
|
|
TQFontMetrics fm( painter->fontMetrics() );
|
|
|
|
|
|
|
|
|
|
|
|
TQStringList::Iterator it = tmpList.begin();
|
|
|
|
|
|
for ( int i = 0; i < nLabels; ++i ) {
|
|
|
|
|
|
if ( it != tmpList.end() ) {
|
|
|
|
|
|
if ( fm.width( *it ) > pTextsW ) {
|
|
|
|
|
|
useShortLabels = true;
|
|
|
|
|
|
break;
|
|
|
|
|
|
}
|
|
|
|
|
|
++it;
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
if ( useShortLabels )
|
|
|
|
|
|
tmpList = para.axisShortLabelsStringList();
|
|
|
|
|
|
else
|
|
|
|
|
|
tmpList = para.axisLabelStringList();
|
|
|
|
|
|
|
|
|
|
|
|
// prepare transfering the strings into the labelTexts list
|
|
|
|
|
|
double ddelta
|
|
|
|
|
|
= ( KDCHART_AXIS_LABELS_AUTO_DELTA == para.axisValueDelta() )
|
|
|
|
|
|
? 1.0
|
|
|
|
|
|
: para.axisValueDelta();
|
|
|
|
|
|
modf( ddelta, &ddelta );
|
|
|
|
|
|
bool positive = ( 0.0 <= ddelta );
|
|
|
|
|
|
int delta = static_cast < int > ( fabs( ddelta ) );
|
|
|
|
|
|
// find 1st significant entry
|
|
|
|
|
|
TQStringList::Iterator it = positive
|
|
|
|
|
|
? tmpList.begin()
|
|
|
|
|
|
: tmpList.fromLast();
|
|
|
|
|
|
if ( positive )
|
|
|
|
|
|
for ( int i = 0; i < (int)tmpList.count(); ++i ) {
|
|
|
|
|
|
if ( i >= iStart )
|
|
|
|
|
|
break;
|
|
|
|
|
|
++it;
|
|
|
|
|
|
}
|
|
|
|
|
|
else
|
|
|
|
|
|
for ( int i = tmpList.count() - 1; i >= 0; --i ) {
|
|
|
|
|
|
if ( i <= iEnd )
|
|
|
|
|
|
break;
|
|
|
|
|
|
--it;
|
|
|
|
|
|
}
|
|
|
|
|
|
// transfer the strings
|
|
|
|
|
|
int meter = delta;
|
|
|
|
|
|
int i2 = positive ? iStart : iEnd;
|
|
|
|
|
|
for ( int iLabel = 0; iLabel < nLabels; ) {
|
|
|
|
|
|
if ( positive ) {
|
|
|
|
|
|
if ( it == tmpList.end() ) {
|
|
|
|
|
|
it = tmpList.begin();
|
|
|
|
|
|
i2 = 0;
|
|
|
|
|
|
}
|
|
|
|
|
|
} else {
|
|
|
|
|
|
if ( it == tmpList.begin() ) {
|
|
|
|
|
|
it = tmpList.end();
|
|
|
|
|
|
i2 = tmpList.count();
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
if ( ( positive && i2 >= iStart )
|
|
|
|
|
|
|| ( !positive && i2 <= iEnd ) ) {
|
|
|
|
|
|
if ( meter >= delta ) {
|
|
|
|
|
|
labelTexts << *it;
|
|
|
|
|
|
++iLabel;
|
|
|
|
|
|
meter = 1;
|
|
|
|
|
|
} else {
|
|
|
|
|
|
meter += 1;
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
if ( positive ) {
|
|
|
|
|
|
if ( i2 == iEnd ) {
|
|
|
|
|
|
it = tmpList.begin();
|
|
|
|
|
|
i2 = 0;
|
|
|
|
|
|
} else {
|
|
|
|
|
|
++it;
|
|
|
|
|
|
++i2;
|
|
|
|
|
|
}
|
|
|
|
|
|
} else {
|
|
|
|
|
|
if ( i2 == iStart ) {
|
|
|
|
|
|
it = tmpList.end();
|
|
|
|
|
|
i2 = tmpList.count();
|
|
|
|
|
|
} else {
|
|
|
|
|
|
--it;
|
|
|
|
|
|
--i2;
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
} else {
|
|
|
|
|
|
// find out if the associated dataset contains only strings
|
|
|
|
|
|
// if yes, we will take these as label texts
|
|
|
|
|
|
uint dset = ( dataset == KDCHART_ALL_DATASETS ) ? 0 : dataset;
|
|
|
|
|
|
//tqDebug("\ndset: %u", dset);
|
|
|
|
|
|
bDone = false;
|
|
|
|
|
|
TQVariant value;
|
|
|
|
|
|
for ( uint col = 0; col < data.usedCols(); ++col ) {
|
|
|
|
|
|
if( data.cellCoord( dset, col, value, coordinate ) ){
|
|
|
|
|
|
if( TQVariant::String == value.type() ){
|
|
|
|
|
|
const TQString sVal = value.toString();
|
|
|
|
|
|
if( !sVal.isEmpty() && !sVal.isNull() ){
|
|
|
|
|
|
labelTexts.append( sVal );
|
|
|
|
|
|
bDone = true;
|
|
|
|
|
|
}
|
|
|
|
|
|
}else{
|
|
|
|
|
|
labelTexts.clear();
|
|
|
|
|
|
bDone = false;
|
|
|
|
|
|
break;
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
if ( bDone ) {
|
|
|
|
|
|
// Some strings were found, now let us see which of them are
|
|
|
|
|
|
// actually to be taken right now.
|
|
|
|
|
|
//
|
|
|
|
|
|
//
|
|
|
|
|
|
// F E A T U R E P L A N N E D F O R F U T U R E . . .
|
|
|
|
|
|
//
|
|
|
|
|
|
//
|
|
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
else {
|
|
|
|
|
|
// No strings were found, so let us either calculate the texts
|
|
|
|
|
|
// based upon the numerical values of the associated dataset(s)
|
|
|
|
|
|
// or just compose some default texts...
|
|
|
|
|
|
if ( data.usedCols() && bSteadyCalc ) {
|
|
|
|
|
|
// double values for numerical coordinates
|
|
|
|
|
|
double nLow = 0.01;
|
|
|
|
|
|
double nHigh = 0.0;
|
|
|
|
|
|
double orgLow = 0.0;
|
|
|
|
|
|
double orgHigh = 0.0;
|
|
|
|
|
|
double nDelta = 0.0;
|
|
|
|
|
|
double nDist = 0.0;
|
|
|
|
|
|
|
|
|
|
|
|
// VERTICAL axes support three modes:
|
|
|
|
|
|
enum { Normal, Stacked, Percent } mode;
|
|
|
|
|
|
|
|
|
|
|
|
if( bVertAxis ){
|
|
|
|
|
|
switch ( params_chartType ) {
|
|
|
|
|
|
case KDChartParams::Bar:
|
|
|
|
|
|
if ( KDChartParams::BarStacked
|
|
|
|
|
|
== params.barChartSubType() )
|
|
|
|
|
|
mode = Stacked;
|
|
|
|
|
|
else if ( KDChartParams::BarPercent
|
|
|
|
|
|
== params.barChartSubType() )
|
|
|
|
|
|
mode = Percent;
|
|
|
|
|
|
else
|
|
|
|
|
|
mode = Normal;
|
|
|
|
|
|
break;
|
|
|
|
|
|
case KDChartParams::Line:
|
|
|
|
|
|
if ( KDChartParams::LineStacked
|
|
|
|
|
|
== params.lineChartSubType() )
|
|
|
|
|
|
mode = Stacked;
|
|
|
|
|
|
else if ( KDChartParams::LinePercent
|
|
|
|
|
|
== params.lineChartSubType() )
|
|
|
|
|
|
mode = Percent;
|
|
|
|
|
|
else
|
|
|
|
|
|
mode = Normal;
|
|
|
|
|
|
break;
|
|
|
|
|
|
case KDChartParams::Area:
|
|
|
|
|
|
if ( KDChartParams::AreaStacked
|
|
|
|
|
|
== params.areaChartSubType() )
|
|
|
|
|
|
mode = Stacked;
|
|
|
|
|
|
else if ( KDChartParams::AreaPercent
|
|
|
|
|
|
== params.areaChartSubType() )
|
|
|
|
|
|
mode = Percent;
|
|
|
|
|
|
else
|
|
|
|
|
|
mode = Normal;
|
|
|
|
|
|
break;
|
|
|
|
|
|
case KDChartParams::HiLo:
|
|
|
|
|
|
case KDChartParams::BoxWhisker:
|
|
|
|
|
|
mode = Normal;
|
|
|
|
|
|
break;
|
|
|
|
|
|
case KDChartParams::Polar:
|
|
|
|
|
|
if ( KDChartParams::PolarStacked
|
|
|
|
|
|
== params.polarChartSubType() )
|
|
|
|
|
|
mode = Stacked;
|
|
|
|
|
|
else if ( KDChartParams::PolarPercent
|
|
|
|
|
|
== params.polarChartSubType() )
|
|
|
|
|
|
mode = Percent;
|
|
|
|
|
|
else
|
|
|
|
|
|
mode = Normal;
|
|
|
|
|
|
break;
|
|
|
|
|
|
default: {
|
|
|
|
|
|
// Should not happen
|
|
|
|
|
|
tqDebug( "IMPLEMENTATION ERROR: Unknown params_chartType in calculateLabelTexts()" );
|
|
|
|
|
|
mode = Normal;
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
}else
|
|
|
|
|
|
mode = Normal; // this axis is not a vertical axis
|
|
|
|
|
|
|
|
|
|
|
|
uint nLabels = 200;
|
|
|
|
|
|
|
|
|
|
|
|
// find highest and lowest value of associated dataset(s)
|
|
|
|
|
|
bool bOrdFactorsOk = false;
|
|
|
|
|
|
|
|
|
|
|
|
if( adjustTheValues ){
|
|
|
|
|
|
nDelta = fabs( trueDelta );
|
|
|
|
|
|
pDelimDelta = trueDeltaPix;
|
|
|
|
|
|
nLow = TQMIN( para.trueAxisLow(), para.trueAxisHigh() );
|
|
|
|
|
|
//tqDebug("\nsearching: para.trueAxisLow() %f para.trueAxisHigh() %f",para.trueAxisLow(),para.trueAxisHigh());
|
|
|
|
|
|
double orgLow( nLow );
|
|
|
|
|
|
modf( nLow / nDelta, &nLow );
|
|
|
|
|
|
nLow *= nDelta;
|
|
|
|
|
|
if ( nLow > orgLow )
|
|
|
|
|
|
nLow -= nDelta;
|
|
|
|
|
|
if ( 0.0 < nLow && 0.0 >= orgLow )
|
|
|
|
|
|
nLow = 0.0;
|
|
|
|
|
|
nHigh = nLow;
|
|
|
|
|
|
double dx = fabs( pXDeltaFactor * pDelimDelta );
|
|
|
|
|
|
double dy = fabs( pYDeltaFactor * pDelimDelta );
|
|
|
|
|
|
double x = 0.0;
|
|
|
|
|
|
double y = 0.0;
|
|
|
|
|
|
nLabels = 1;
|
|
|
|
|
|
if( axisLength ){
|
|
|
|
|
|
do{
|
|
|
|
|
|
++nLabels;
|
|
|
|
|
|
nHigh += nDelta;
|
|
|
|
|
|
x += dx;
|
|
|
|
|
|
y += dy;
|
|
|
|
|
|
}while( x < axisLength && y < axisLength );
|
|
|
|
|
|
nHigh -= nDelta;
|
|
|
|
|
|
--nLabels;
|
|
|
|
|
|
}
|
|
|
|
|
|
nDist = nHigh - nLow;
|
|
|
|
|
|
bOrdFactorsOk = true;
|
|
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
if( !bOrdFactorsOk ){
|
|
|
|
|
|
const bool bAutoCalcStart =
|
|
|
|
|
|
( Percent != mode )
|
|
|
|
|
|
&& ( KDCHART_AXIS_LABELS_AUTO_LIMIT == para.axisValueStart() );
|
|
|
|
|
|
const bool bAutoCalcEnd =
|
|
|
|
|
|
( Percent != mode )
|
|
|
|
|
|
&& ( KDCHART_AXIS_LABELS_AUTO_LIMIT == para.axisValueEnd() );
|
|
|
|
|
|
|
|
|
|
|
|
if( !bIsDouble && !isDateTime ){
|
|
|
|
|
|
// no data at all: let us use our default 0..10 range
|
|
|
|
|
|
nLow = 0.0;
|
|
|
|
|
|
nHigh = 10.0;
|
|
|
|
|
|
nDist = 10.0;
|
|
|
|
|
|
nDelta = 1.0;
|
|
|
|
|
|
nSubDelimFactor = 0.5;
|
|
|
|
|
|
bIsDouble = true;
|
|
|
|
|
|
bOrdFactorsOk = true;
|
|
|
|
|
|
}else if( mode == Percent ){
|
|
|
|
|
|
// precentage mode: we use a 0..100 range
|
|
|
|
|
|
nLow = 0.0;
|
|
|
|
|
|
nHigh = 100.0;
|
|
|
|
|
|
nDist = 100.0;
|
|
|
|
|
|
nDelta = 10.0;
|
|
|
|
|
|
nSubDelimFactor = 0.25;
|
|
|
|
|
|
bOrdFactorsOk = true;
|
|
|
|
|
|
}else{
|
|
|
|
|
|
//tqDebug("\ngo: nLow: %f nHigh: %f", nLow, nHigh );
|
|
|
|
|
|
// get the raw start value
|
|
|
|
|
|
const bool bStackedMode = (mode == Stacked);
|
|
|
|
|
|
if( bAutoCalcStart ){
|
|
|
|
|
|
if ( dataDataset == KDCHART_ALL_DATASETS ) {
|
|
|
|
|
|
if( bIsDouble ){
|
|
|
|
|
|
nLow = bStackedMode
|
|
|
|
|
|
? TQMIN( data.minColSum(), 0.0 )
|
|
|
|
|
|
: data.minValue( coordinate,
|
|
|
|
|
|
isLogarithmic );
|
|
|
|
|
|
//tqDebug("\n1: nLow: %f", nLow );
|
|
|
|
|
|
|
|
|
|
|
|
}else{
|
|
|
|
|
|
dtLow = data.minDtValue( coordinate );
|
|
|
|
|
|
}
|
|
|
|
|
|
} else {
|
|
|
|
|
|
if( bIsDouble ){
|
|
|
|
|
|
nLow = bStackedMode
|
|
|
|
|
|
? TQMIN( data.minColSum( dataDataset, dataDataset2 ),
|
|
|
|
|
|
0.0 )
|
|
|
|
|
|
: data.minInRows( dataDataset,dataDataset2,
|
|
|
|
|
|
coordinate,
|
|
|
|
|
|
isLogarithmic );
|
|
|
|
|
|
}else{
|
|
|
|
|
|
dtLow = data.minDtInRows( dataDataset,dataDataset2,
|
|
|
|
|
|
coordinate );
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
}else{
|
|
|
|
|
|
if( bIsDouble ){
|
|
|
|
|
|
if( TQVariant::Double == para.axisValueStart().type() )
|
|
|
|
|
|
nLow = para.axisValueStart().toDouble();
|
|
|
|
|
|
}else{
|
|
|
|
|
|
if( TQVariant::DateTime == para.axisValueStart().type() )
|
|
|
|
|
|
dtLow = para.axisValueStart().toDateTime();
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// get the raw end value
|
|
|
|
|
|
if( bAutoCalcEnd ){
|
|
|
|
|
|
if ( dataDataset == KDCHART_ALL_DATASETS ) {
|
|
|
|
|
|
if( bIsDouble ){
|
|
|
|
|
|
nHigh = bStackedMode
|
|
|
|
|
|
? TQMAX( data.maxColSum(), 0.0 )
|
|
|
|
|
|
: data.maxValue( coordinate );
|
|
|
|
|
|
}else{
|
|
|
|
|
|
dtHigh = data.maxDtValue( coordinate );
|
|
|
|
|
|
}
|
|
|
|
|
|
} else {
|
|
|
|
|
|
if( bIsDouble )
|
|
|
|
|
|
nHigh = bStackedMode
|
|
|
|
|
|
? TQMAX( data.maxColSum( dataDataset, dataDataset2 ),
|
|
|
|
|
|
0.0 )
|
|
|
|
|
|
: data.maxInRows( dataDataset,dataDataset2,
|
|
|
|
|
|
coordinate );
|
|
|
|
|
|
else
|
|
|
|
|
|
dtHigh = data.maxDtInRows( dataDataset,dataDataset2,
|
|
|
|
|
|
coordinate );
|
|
|
|
|
|
}
|
|
|
|
|
|
//tqDebug("\nbAutoCalcEnd:\n nLow: %f\n nHigh: %f", nLow, nHigh );
|
|
|
|
|
|
}else{
|
|
|
|
|
|
if( bIsDouble ){
|
|
|
|
|
|
if( TQVariant::Double == para.axisValueEnd().type() )
|
|
|
|
|
|
nHigh = para.axisValueEnd().toDouble();
|
|
|
|
|
|
}else{
|
|
|
|
|
|
if( TQVariant::DateTime == para.axisValueEnd().type() )
|
|
|
|
|
|
dtHigh = para.axisValueEnd().toDateTime();
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
//tqDebug("\nnew: nLow: %f nHigh: %f", nLow, nHigh );
|
|
|
|
|
|
|
|
|
|
|
|
if( bIsDouble ) {
|
|
|
|
|
|
if( DBL_MAX == nLow
|
|
|
|
|
|
|| ( ( 0.0 == nHigh || 0 == nHigh )
|
|
|
|
|
|
&& ( 0.0 == nLow || 0 == nLow ) ) ) {
|
|
|
|
|
|
// tqDebug("NO values or all values have ZERO value, showing 0.0 - 10.0 span");
|
|
|
|
|
|
nLow = 0.0;
|
|
|
|
|
|
nHigh = 10.0;
|
|
|
|
|
|
nDist = 10.0;
|
|
|
|
|
|
nDelta = 1.0;
|
|
|
|
|
|
nSubDelimFactor = 0.5;
|
|
|
|
|
|
bOrdFactorsOk = true;
|
|
|
|
|
|
//tqDebug("nLow: %f, nHigh: %f", nLow, nHigh);
|
|
|
|
|
|
}else if( nLow == nHigh ){
|
|
|
|
|
|
// if both values are equal, but NOT Zero
|
|
|
|
|
|
// -> move the appropriate one to Zero
|
|
|
|
|
|
if( nLow < 0.0 )
|
|
|
|
|
|
nHigh = 0.0;
|
|
|
|
|
|
else
|
|
|
|
|
|
nLow = 0.0;
|
|
|
|
|
|
//tqDebug("nLow: %f, nHigh: %f", nLow, nHigh);
|
|
|
|
|
|
}else if( nHigh < nLow ){
|
|
|
|
|
|
// make sure nLow is <= nHigh
|
|
|
|
|
|
double nTmp = nLow;
|
|
|
|
|
|
nLow = nHigh;
|
|
|
|
|
|
nHigh = nTmp;
|
|
|
|
|
|
}
|
|
|
|
|
|
} else if( isDateTime ){
|
|
|
|
|
|
bool toggleDts = dtLow > dtHigh;
|
|
|
|
|
|
if( toggleDts ) {
|
|
|
|
|
|
TQDateTime dt( dtLow );
|
|
|
|
|
|
dtLow = dtHigh;
|
|
|
|
|
|
dtHigh = dt;
|
|
|
|
|
|
}
|
|
|
|
|
|
double secDist = dtLow.secsTo( dtHigh );
|
|
|
|
|
|
secDist += (dtHigh.time().msec() - dtLow.time().msec()) / 1000.0;
|
|
|
|
|
|
const double aDist = fabs( secDist );
|
|
|
|
|
|
const double secMin = 60.0;
|
|
|
|
|
|
const double secHour = 60.0 * secMin;
|
|
|
|
|
|
const double secDay = 24.0 * secHour;
|
|
|
|
|
|
//
|
|
|
|
|
|
// we temporarily disable week alignment until bug
|
|
|
|
|
|
// is fixed (1st week of year must not start in the
|
|
|
|
|
|
// preceeding year but rather be shown incompletely)
|
|
|
|
|
|
//
|
|
|
|
|
|
// (khz, 2003/10/10)
|
|
|
|
|
|
//
|
|
|
|
|
|
//const int secWeek = 7 * secDay;
|
|
|
|
|
|
const double secMonth = 30 * secDay; // approx.
|
|
|
|
|
|
const double secYear = 12 * secMonth; // approx.
|
|
|
|
|
|
if( 2.0*secMin > aDist )
|
|
|
|
|
|
dtDeltaScale = KDChartAxisParams::ValueScaleSecond;
|
|
|
|
|
|
else if( 2.0*secHour > aDist )
|
|
|
|
|
|
dtDeltaScale = KDChartAxisParams::ValueScaleMinute;
|
|
|
|
|
|
else if( 2.0*secDay > aDist )
|
|
|
|
|
|
dtDeltaScale = KDChartAxisParams::ValueScaleHour;
|
|
|
|
|
|
// khz: else if( 2*secWeek > aDist )
|
|
|
|
|
|
// khz: dtDeltaScale = KDChartAxisParams::ValueScaleDay;
|
|
|
|
|
|
else if( 2.0*secMonth > aDist )
|
|
|
|
|
|
dtDeltaScale = KDChartAxisParams::ValueScaleDay;
|
|
|
|
|
|
// khz: dtDeltaScale = KDChartAxisParams::ValueScaleWeek;
|
|
|
|
|
|
|
|
|
|
|
|
else if( 2.0*secYear > aDist )
|
|
|
|
|
|
dtDeltaScale = KDChartAxisParams::ValueScaleMonth;
|
|
|
|
|
|
else if( 10.0*secYear > aDist )
|
|
|
|
|
|
dtDeltaScale = KDChartAxisParams::ValueScaleQuarter;
|
|
|
|
|
|
else
|
|
|
|
|
|
dtDeltaScale = KDChartAxisParams::ValueScaleYear;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
//const int yearLow = dtLow.date().year();
|
|
|
|
|
|
const int monthLow = dtLow.date().month();
|
|
|
|
|
|
// khz: currently unused: const int dowLow = dtLow.date().dayOfWeek();
|
|
|
|
|
|
const int dayLow = dtLow.date().day();
|
|
|
|
|
|
const int hourLow = dtLow.time().hour();
|
|
|
|
|
|
const int minuteLow = dtLow.time().minute();
|
|
|
|
|
|
const int secondLow = dtLow.time().second();
|
|
|
|
|
|
|
|
|
|
|
|
//const int yearHigh = dtHigh.date().year();
|
|
|
|
|
|
const int monthHigh = dtHigh.date().month();
|
|
|
|
|
|
// khz: currently unused: const int dowHigh = dtHigh.date().dayOfWeek();
|
|
|
|
|
|
const int hourHigh = dtHigh.time().hour();
|
|
|
|
|
|
const int minuteHigh = dtHigh.time().minute();
|
|
|
|
|
|
const int secondHigh = dtHigh.time().second();
|
|
|
|
|
|
int yearLowD = 0;
|
|
|
|
|
|
int monthLowD = 0;
|
|
|
|
|
|
int dayLowD = 0;
|
|
|
|
|
|
int hourLowD = 0;
|
|
|
|
|
|
int minuteLowD = 0;
|
|
|
|
|
|
int secondLowD = 0;
|
|
|
|
|
|
int yearHighD = 0;
|
|
|
|
|
|
int monthHighD = 0;
|
|
|
|
|
|
int dayHighD = 0;
|
|
|
|
|
|
int hourHighD = 0;
|
|
|
|
|
|
int minuteHighD = 0;
|
|
|
|
|
|
int secondHighD = 0;
|
|
|
|
|
|
bool gotoEndOfMonth = false;
|
|
|
|
|
|
switch( dtDeltaScale ) {
|
|
|
|
|
|
case KDChartAxisParams::ValueScaleSecond:
|
|
|
|
|
|
//tqDebug("\nKDChartAxisParams::ValueScaleSecond");
|
|
|
|
|
|
if( 5.0 < aDist ){
|
|
|
|
|
|
secondLowD = secondLow % 5;
|
|
|
|
|
|
if( secondHigh % 5 )
|
|
|
|
|
|
secondHighD = 5 - secondHigh % 5;
|
|
|
|
|
|
}
|
|
|
|
|
|
break;
|
|
|
|
|
|
case KDChartAxisParams::ValueScaleMinute:
|
|
|
|
|
|
//tqDebug("\nKDChartAxisParams::ValueScaleMinute");
|
|
|
|
|
|
secondLowD = secondLow;
|
|
|
|
|
|
secondHighD = 59-secondHigh;
|
|
|
|
|
|
break;
|
|
|
|
|
|
case KDChartAxisParams::ValueScaleHour:
|
|
|
|
|
|
//tqDebug("\nKDChartAxisParams::ValueScaleHour");
|
|
|
|
|
|
minuteLowD = minuteLow;
|
|
|
|
|
|
secondLowD = secondLow;
|
|
|
|
|
|
minuteHighD = 59-minuteHigh;
|
|
|
|
|
|
secondHighD = 59-secondHigh;
|
|
|
|
|
|
break;
|
|
|
|
|
|
case KDChartAxisParams::ValueScaleDay:
|
|
|
|
|
|
//tqDebug("\nKDChartAxisParams::ValueScaleDay");
|
|
|
|
|
|
hourLowD = hourLow;
|
|
|
|
|
|
minuteLowD = minuteLow;
|
|
|
|
|
|
secondLowD = secondLow;
|
|
|
|
|
|
hourHighD = 23-hourHigh;
|
|
|
|
|
|
minuteHighD = 59-minuteHigh;
|
|
|
|
|
|
secondHighD = 59-secondHigh;
|
|
|
|
|
|
break;
|
|
|
|
|
|
case KDChartAxisParams::ValueScaleWeek:
|
|
|
|
|
|
//tqDebug("\nKDChartAxisParams::ValueScaleWeek");
|
|
|
|
|
|
// khz: week scaling is disabled at the moment
|
|
|
|
|
|
/*
|
|
|
|
|
|
dayLowD = dowLow - 1;
|
|
|
|
|
|
hourLowD = hourLow;
|
|
|
|
|
|
minuteLowD = minuteLow;
|
|
|
|
|
|
secondLowD = secondLow;
|
|
|
|
|
|
if( 7 > dowHigh )
|
|
|
|
|
|
dayHighD = 7 - dowHigh + 1;
|
|
|
|
|
|
*/
|
|
|
|
|
|
break;
|
|
|
|
|
|
case KDChartAxisParams::ValueScaleMonth:
|
|
|
|
|
|
//tqDebug("\nKDChartAxisParams::ValueScaleMonth");
|
|
|
|
|
|
if( 1 < dayLow )
|
|
|
|
|
|
dayLowD = dayLow - 1;
|
|
|
|
|
|
hourLowD = hourLow;
|
|
|
|
|
|
minuteLowD = minuteLow;
|
|
|
|
|
|
secondLowD = secondLow;
|
|
|
|
|
|
gotoEndOfMonth = true;
|
|
|
|
|
|
break;
|
|
|
|
|
|
case KDChartAxisParams::ValueScaleQuarter:
|
|
|
|
|
|
//tqDebug("\nKDChartAxisParams::ValueScaleQuarter");
|
|
|
|
|
|
monthLowD = ( monthLow - 1 ) % 3;
|
|
|
|
|
|
dayLowD = dayLow;
|
|
|
|
|
|
hourLowD = hourLow;
|
|
|
|
|
|
minuteLowD = minuteLow;
|
|
|
|
|
|
secondLowD = secondLow;
|
|
|
|
|
|
if( ( monthHigh - 1 ) % 3 )
|
|
|
|
|
|
monthHighD = 3 - ( monthHigh - 1 ) % 3;
|
|
|
|
|
|
gotoEndOfMonth = true;
|
|
|
|
|
|
break;
|
|
|
|
|
|
case KDChartAxisParams::ValueScaleYear:
|
|
|
|
|
|
//tqDebug("\nKDChartAxisParams::ValueScaleYear");
|
|
|
|
|
|
monthLowD = monthLow;
|
|
|
|
|
|
dayLowD = dayLow;
|
|
|
|
|
|
hourLowD = hourLow;
|
|
|
|
|
|
minuteLowD = minuteLow;
|
|
|
|
|
|
secondLowD = secondLow;
|
|
|
|
|
|
if( 12 > monthHigh )
|
|
|
|
|
|
monthHighD = 12 - monthHigh;
|
|
|
|
|
|
gotoEndOfMonth = true;
|
|
|
|
|
|
break;
|
|
|
|
|
|
default:
|
|
|
|
|
|
/* NOOP */
|
|
|
|
|
|
break;
|
|
|
|
|
|
}
|
|
|
|
|
|
dtLow = dtLow.addSecs( -1 * (secondLowD + 60*minuteLowD + 3600*hourLowD) );
|
|
|
|
|
|
dtLow = dtLow.addDays( -1 * dayLowD );
|
|
|
|
|
|
dtAddMonths( dtLow, -1 * monthLowD, dtLow );
|
|
|
|
|
|
dtAddYears( dtLow, -1 * yearLowD, dtLow );
|
|
|
|
|
|
dtHigh = dtHigh.addSecs( secondHighD + 60*minuteHighD + 3600* hourHighD );
|
|
|
|
|
|
dtHigh = dtHigh.addDays( dayHighD );
|
|
|
|
|
|
dtAddMonths( dtHigh, monthHighD, dtHigh );
|
|
|
|
|
|
dtAddYears( dtHigh, yearHighD, dtHigh );
|
|
|
|
|
|
if( gotoEndOfMonth ){
|
|
|
|
|
|
dtHigh.setDate( TQDate( dtHigh.date().year(),
|
|
|
|
|
|
dtHigh.date().month(),
|
|
|
|
|
|
dtHigh.date().daysInMonth() ) );
|
|
|
|
|
|
dtHigh.setTime( TQTime( 23, 59, 59 ) );
|
|
|
|
|
|
}
|
|
|
|
|
|
if( toggleDts ) {
|
|
|
|
|
|
TQDateTime dt( dtLow );
|
|
|
|
|
|
dtLow = dtHigh;
|
|
|
|
|
|
dtHigh = dt;
|
|
|
|
|
|
}
|
|
|
|
|
|
// secDist = dtLow.secsTo( dtHigh );
|
|
|
|
|
|
|
|
|
|
|
|
// NOTE: nSubDelimFactor is not set here since it
|
|
|
|
|
|
// cannot be used for TQDateTime values.
|
|
|
|
|
|
nSubDelimFactor = 0.0;
|
|
|
|
|
|
bOrdFactorsOk = true;
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
if( !bOrdFactorsOk ) {
|
|
|
|
|
|
// adjust one or both of our limit values
|
|
|
|
|
|
// according to max-empty-inner-span settings
|
|
|
|
|
|
nDist = nHigh - nLow;
|
|
|
|
|
|
if( !isLogarithmic ){
|
|
|
|
|
|
// replace nLow (or nHigh, resp.) by zero if NOT ALL OF
|
|
|
|
|
|
// our values are located outside of the 'max. empty
|
|
|
|
|
|
// inner space' (i.e. percentage of the y-axis range
|
|
|
|
|
|
// that may to contain NO data entries)
|
|
|
|
|
|
int maxEmpty = para.axisMaxEmptyInnerSpan();
|
|
|
|
|
|
if( bAutoCalcStart ) {
|
|
|
|
|
|
//tqDebug("\nbAutoCalcStart:\n nLow: %f\n nHigh: %f", nLow, nHigh );
|
|
|
|
|
|
if( 0.0 < nLow ) {
|
|
|
|
|
|
if( maxEmpty == KDCHART_AXIS_IGNORE_EMPTY_INNER_SPAN
|
|
|
|
|
|
|| maxEmpty > ( nLow / nHigh * 100.0 ) )
|
|
|
|
|
|
nLow = 0.0;
|
|
|
|
|
|
else if( nDist / 100.0 < nLow )
|
|
|
|
|
|
nLow -= nDist / 100.0; // shift lowest value
|
|
|
|
|
|
}
|
|
|
|
|
|
else if( nDist / 100.0 < fabs( nLow ) )
|
|
|
|
|
|
nLow -= nDist / 100.0; // shift lowest value
|
|
|
|
|
|
nDist = nHigh - nLow;
|
|
|
|
|
|
//tqDebug("* nLow: %f\n nHigh: %f", nLow, nHigh );
|
|
|
|
|
|
}
|
|
|
|
|
|
if( bAutoCalcEnd ) {
|
|
|
|
|
|
//tqDebug("\nbAutoCalcEnd:\n nLow: %f\n nHigh: %f", nLow, nHigh );
|
|
|
|
|
|
if( 0.0 > nHigh ) {
|
|
|
|
|
|
if( maxEmpty == KDCHART_AXIS_IGNORE_EMPTY_INNER_SPAN
|
|
|
|
|
|
|| maxEmpty > ( nHigh / nLow * 100.0 ) )
|
|
|
|
|
|
nHigh = 0.0;
|
|
|
|
|
|
else if( nDist / 100.0 > nHigh )
|
|
|
|
|
|
nHigh += nDist / 100.0; // shift highest value
|
|
|
|
|
|
}
|
|
|
|
|
|
else if( nDist / 100.0 < fabs( nHigh ) )
|
|
|
|
|
|
nHigh += nDist / 100.0; // shift highest value
|
|
|
|
|
|
nDist = nHigh - nLow;
|
|
|
|
|
|
//tqDebug("* nLow: %f\n nHigh: %f\n\n", nLow, nHigh );
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
if( isLogarithmic ){
|
|
|
|
|
|
if( bIsDouble ) {
|
|
|
|
|
|
//tqDebug("\n[L--] nLow: %f, nHigh: %f, nDelta: %f", nLow, nHigh, nDelta );
|
|
|
|
|
|
if( 0.0 == TQABS( nLow ) )
|
|
|
|
|
|
nLow = -5;
|
|
|
|
|
|
else{
|
|
|
|
|
|
// find the Low / High values for the log. axis
|
|
|
|
|
|
nLow = log10( TQABS( nLow ) );
|
|
|
|
|
|
//if( 0.0 >= nLow ){
|
|
|
|
|
|
//nLow = fastPow10( -nLow );
|
|
|
|
|
|
//}
|
|
|
|
|
|
}
|
|
|
|
|
|
nHigh = log10( TQABS( nHigh ) );
|
|
|
|
|
|
|
|
|
|
|
|
//tqDebug("[L-0] nLow: %f, nHigh: %f", nLow, nHigh );
|
|
|
|
|
|
double intPart;
|
|
|
|
|
|
double fractPart = modf( nLow, &intPart );
|
|
|
|
|
|
//tqDebug(" intPart: %f\nfractPart: %f", intPart, fractPart );
|
|
|
|
|
|
if( 0.0 > nLow && 0.0 != fractPart )
|
|
|
|
|
|
nLow = intPart - 1.0;
|
|
|
|
|
|
else
|
|
|
|
|
|
nLow = intPart;
|
|
|
|
|
|
fractPart = modf( nHigh, &intPart );
|
|
|
|
|
|
if( 0.0 != fractPart )
|
|
|
|
|
|
nHigh = intPart + 1.0;
|
|
|
|
|
|
|
|
|
|
|
|
nDist = nHigh - nLow;
|
|
|
|
|
|
nDelta = 1.0;
|
|
|
|
|
|
nSubDelimFactor = 0.1;
|
|
|
|
|
|
//tqDebug("\n[L-1] nLow: %f, nHigh: %f, nDelta: %f", nLow, nHigh, nDelta );
|
|
|
|
|
|
bOrdFactorsOk = true;
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
if ( !bOrdFactorsOk ) {
|
|
|
|
|
|
// adjust one or both of our limit values
|
|
|
|
|
|
// according to first two digits of (nHigh - nLow) delta
|
|
|
|
|
|
double nDivisor;
|
|
|
|
|
|
double nRound;
|
|
|
|
|
|
nDist = nHigh - nLow;
|
|
|
|
|
|
//tqDebug("* nLow: %f\n nHigh: %f nDist: %f\n\n", nLow, nHigh, nDist );
|
|
|
|
|
|
// find out factors and adjust nLow and nHigh
|
|
|
|
|
|
orgLow = nLow;
|
|
|
|
|
|
orgHigh = nHigh;
|
|
|
|
|
|
calculateOrdinateFactors( para, isLogarithmic,
|
|
|
|
|
|
nDist, nDivisor, nRound,
|
|
|
|
|
|
nDelta, nSubDelimFactor,
|
|
|
|
|
|
nLow, nHigh );
|
|
|
|
|
|
nLabels = params.roundVal( nDist / nDelta );
|
|
|
|
|
|
|
|
|
|
|
|
//tqDebug("\n0. nOrgHigh: %f\n nOrgLow: %f",
|
|
|
|
|
|
// orgHigh, orgLow);
|
|
|
|
|
|
//tqDebug("\n nDist: %f\n nHigh: %f\n nLow: %f",
|
|
|
|
|
|
// nDist, nHigh, nLow);
|
|
|
|
|
|
//tqDebug(" nDelta: %f", nDelta);
|
|
|
|
|
|
//tqDebug(" nRound: %f", nRound);
|
|
|
|
|
|
//tqDebug(" nLabels: %u", nLabels);
|
|
|
|
|
|
|
|
|
|
|
|
if( para.axisSteadyValueCalc() ) {
|
|
|
|
|
|
++nLabels;
|
|
|
|
|
|
//tqDebug("* nLabels: %u", nLabels );
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// calculate the amount of nLabels to be written we could take
|
|
|
|
|
|
// based on the space we have for writing the label texts
|
|
|
|
|
|
if( ! ( KDCHART_AXIS_LABELS_AUTO_DELTA
|
|
|
|
|
|
== para.axisValueDelta() ) ){
|
|
|
|
|
|
nDist = nHigh - nLow;
|
|
|
|
|
|
nDelta = para.axisValueDelta();
|
|
|
|
|
|
nLabels = params.roundVal( nDist / nDelta );
|
|
|
|
|
|
|
|
|
|
|
|
//tqDebug("\nI nLow: %f\n nHigh: %f\n nDelta: %f\n nLabels: %u",
|
|
|
|
|
|
// nLow, nHigh, nDelta, nLabels );
|
|
|
|
|
|
|
|
|
|
|
|
if( para.axisSteadyValueCalc() ) {
|
|
|
|
|
|
++nLabels;
|
|
|
|
|
|
|
|
|
|
|
|
//tqDebug("* nLabels: %u", nLabels );
|
|
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// make sure labels fit into available height, if vertical axis
|
|
|
|
|
|
if( bVertAxis ) {
|
|
|
|
|
|
//Pending Michel
|
|
|
|
|
|
//find out the width
|
|
|
|
|
|
const KDChartAxisParams & xpara = params.axisParams( KDChartAxisParams::AxisPosBottom );
|
|
|
|
|
|
double areaWidth = xpara.axisTrueAreaRect().width();
|
|
|
|
|
|
//make sure to avoid inf
|
|
|
|
|
|
double areaHeight = para.axisTrueAreaRect().height()>0?para.axisTrueAreaRect().height():1.0;
|
|
|
|
|
|
double widthHeight = areaWidth / areaHeight;
|
|
|
|
|
|
//tqDebug( "widthHeight %f, nDelta %f", widthHeight, nDelta);
|
|
|
|
|
|
//tqDebug( "maxValue %f", data.maxValue());
|
|
|
|
|
|
//tqDebug( "maxColSum %f", data.maxColSum());
|
|
|
|
|
|
//tqDebug( "axisValueEnd() %f", para.axisValueEnd().toDouble());
|
|
|
|
|
|
double nDivisor;
|
|
|
|
|
|
double nRound;
|
|
|
|
|
|
orgLow = nLow;
|
|
|
|
|
|
orgHigh = nHigh;
|
|
|
|
|
|
|
|
|
|
|
|
//check if there are axis limitation - if not (auto calculation):
|
|
|
|
|
|
//adjust the axis for 3dbars in order to display the whole top of the bar
|
|
|
|
|
|
//in relation to the with and the height of the area.
|
|
|
|
|
|
// add conditions for multirows here
|
|
|
|
|
|
if ( KDCHART_AXIS_LABELS_AUTO_LIMIT == para.axisValueEnd().toDouble()) {
|
|
|
|
|
|
if (params.threeDBars() ) {
|
|
|
|
|
|
if ( KDChartParams::BarPercent != params.barChartSubType()) {
|
|
|
|
|
|
if ( widthHeight > 1.5 )
|
|
|
|
|
|
orgHigh += nDelta * widthHeight;
|
|
|
|
|
|
else
|
|
|
|
|
|
orgHigh += widthHeight * 0.5;
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
} else {
|
|
|
|
|
|
orgHigh = nHigh = para.axisValueEnd().toDouble();
|
|
|
|
|
|
}
|
|
|
|
|
|
//tqDebug("\ncalc ordinate 0. nDist: %f\n nLow: %f\n nHigh: %f\n nDelta: %f\n nLabels: %u", nDist, nLow, nHigh, nDelta, nLabels );
|
|
|
|
|
|
bool bTryNext = false;
|
|
|
|
|
|
uint minLabels = para.axisSteadyValueCalc() ? 3 : 2;
|
|
|
|
|
|
// the following must be processed at least twice - to avoid rounding errors
|
|
|
|
|
|
int pass = 0;
|
|
|
|
|
|
do{
|
|
|
|
|
|
nDist = nHigh - nLow;
|
|
|
|
|
|
nLow = orgLow;
|
|
|
|
|
|
nHigh = orgHigh;
|
|
|
|
|
|
/*
|
|
|
|
|
|
tqDebug("\n=============================================================================\ncalc ordinate 1. nDist: %f\n nLow: %f\n nHigh: %f\n nDelta: %f\n nLabels: %u",
|
|
|
|
|
|
nDist, nLow, nHigh, nDelta, nLabels );
|
|
|
|
|
|
*/
|
|
|
|
|
|
calculateOrdinateFactors( para, isLogarithmic,
|
|
|
|
|
|
nDist, nDivisor, nRound,
|
|
|
|
|
|
nDelta,
|
|
|
|
|
|
nSubDelimFactor, nLow, nHigh,
|
|
|
|
|
|
bTryNext );
|
|
|
|
|
|
nLabels = params.roundVal( nDist / nDelta );
|
|
|
|
|
|
|
|
|
|
|
|
//tqDebug("\ncalc ordinate 2. nDist: %f\n+ nLow: %f\n nHigh: %f\n nDelta: %f\n nLabels: %u",
|
|
|
|
|
|
//nDist, nLow, nHigh, nDelta, nLabels );
|
|
|
|
|
|
//TQString sDelta;sDelta.setNum( nDelta, 'f', 24 );
|
|
|
|
|
|
//TQString sLow; sLow.setNum( nLow, 'f', 24 );
|
|
|
|
|
|
//tqDebug("nLow: %f, sLow: %s, sDelta: %s", nLow, sLow.latin1(), sDelta.latin1());
|
|
|
|
|
|
|
|
|
|
|
|
// special case: End values was set by the user, but no Detla values was set.
|
|
|
|
|
|
if( !bAutoCalcEnd && orgHigh > nLow + nLabels * nDelta ) {
|
|
|
|
|
|
++nLabels;
|
|
|
|
|
|
//tqDebug("\nnLabels: %u\n", nLabels );
|
|
|
|
|
|
}
|
|
|
|
|
|
if( para.axisSteadyValueCalc() ) {
|
|
|
|
|
|
++nLabels;
|
|
|
|
|
|
//tqDebug("\nnLabels: %u\n", nLabels );
|
|
|
|
|
|
}
|
|
|
|
|
|
//tqDebug("calc ordinate n. nDist = nHigh - nLow: %f = %f - %f",nDist, nHigh, nLow);
|
|
|
|
|
|
//tqDebug(" nRound: %f\n", nRound);
|
|
|
|
|
|
bTryNext = true;
|
|
|
|
|
|
++pass;
|
|
|
|
|
|
}while ( ( pass < 2 )
|
|
|
|
|
|
|| ( ( minLabels < nLabels )
|
|
|
|
|
|
&& ( areaHeight < ( nTxtHeight * 1.5 ) * nLabels ) ) );
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// finally we can build the texts
|
|
|
|
|
|
if( bIsDouble ) {
|
|
|
|
|
|
int trueBehindComma = -1;
|
|
|
|
|
|
double nVal = nLow;
|
|
|
|
|
|
for ( uint i = 0; i < nLabels; ++i ) {
|
|
|
|
|
|
if( isLogarithmic ) {
|
|
|
|
|
|
labelTexts.append( applyLabelsFormat(
|
|
|
|
|
|
fastPow10( static_cast < int > ( nVal ) ),
|
|
|
|
|
|
divPow10,
|
|
|
|
|
|
behindComma,
|
|
|
|
|
|
1.0 == nDelta ? KDCHART_AXIS_LABELS_AUTO_DELTA : nDelta,
|
|
|
|
|
|
trueBehindComma,
|
|
|
|
|
|
notation,
|
|
|
|
|
|
decimalPoint,
|
|
|
|
|
|
thousandsPoint,
|
|
|
|
|
|
prefix,
|
|
|
|
|
|
postfix,
|
|
|
|
|
|
totalLen,
|
|
|
|
|
|
padFill,
|
|
|
|
|
|
blockAlign ) );
|
|
|
|
|
|
} else {
|
|
|
|
|
|
labelTexts.append( applyLabelsFormat( nVal,
|
|
|
|
|
|
divPow10,
|
|
|
|
|
|
behindComma,
|
|
|
|
|
|
nDelta,
|
|
|
|
|
|
trueBehindComma,
|
|
|
|
|
|
notation,
|
|
|
|
|
|
decimalPoint,
|
|
|
|
|
|
thousandsPoint,
|
|
|
|
|
|
prefix,
|
|
|
|
|
|
postfix,
|
|
|
|
|
|
totalLen,
|
|
|
|
|
|
padFill,
|
|
|
|
|
|
blockAlign ) );
|
|
|
|
|
|
}
|
|
|
|
|
|
nVal += nDelta;
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// save our true Low and High value
|
|
|
|
|
|
//tqDebug(para.axisSteadyValueCalc()?"\ntrue " : "\nfalse");
|
|
|
|
|
|
//tqDebug("nVal: %f, nDelta: %f", nVal, nDelta );
|
|
|
|
|
|
if ( para.axisSteadyValueCalc() ) {
|
|
|
|
|
|
nHigh = nVal - nDelta;
|
|
|
|
|
|
}
|
|
|
|
|
|
( ( KDChartAxisParams& ) para ).setTrueAxisLowHighDelta( nLow, nHigh, nDelta );
|
|
|
|
|
|
//tqDebug("[Z] nLow: %f, nHigh: %f, nDelta: %f", nLow, nHigh, nDelta );
|
|
|
|
|
|
|
|
|
|
|
|
} else {
|
|
|
|
|
|
bool goDown = dtLow > dtHigh;
|
|
|
|
|
|
int mult = goDown ? -1 : 1;
|
|
|
|
|
|
TQDateTime dt( dtLow );
|
|
|
|
|
|
nLabels = 0;
|
|
|
|
|
|
/*
|
|
|
|
|
|
tqDebug("dtLow: ");
|
|
|
|
|
|
tqDebug(dtLow.toString( TQt::ISODate ));
|
|
|
|
|
|
tqDebug("dtHigh: ");
|
|
|
|
|
|
tqDebug(dtHigh.toString( TQt::ISODate ));
|
|
|
|
|
|
*/
|
|
|
|
|
|
bool bDone=false;
|
|
|
|
|
|
while( !bDone ) {
|
|
|
|
|
|
/*
|
|
|
|
|
|
tqDebug("dtLow: %i %i %i %i:%i:%i",
|
|
|
|
|
|
dtLow.date().year(),
|
|
|
|
|
|
dtLow.date().month(),
|
|
|
|
|
|
dtLow.date().day(),
|
|
|
|
|
|
dtLow.time().hour(),
|
|
|
|
|
|
dtLow.time().minute(),
|
|
|
|
|
|
dtLow.time().second());
|
|
|
|
|
|
tqDebug("dtHigh: %i %i %i %i:%i:%i",
|
|
|
|
|
|
dtHigh.date().year(),
|
|
|
|
|
|
dtHigh.date().month(),
|
|
|
|
|
|
dtHigh.date().day(),
|
|
|
|
|
|
dtHigh.time().hour(),
|
|
|
|
|
|
dtHigh.time().minute(),
|
|
|
|
|
|
dtHigh.time().second());
|
|
|
|
|
|
tqDebug("dt: %i %i %i %i:%i:%i",
|
|
|
|
|
|
dt.date().year(),
|
|
|
|
|
|
dt.date().month(),
|
|
|
|
|
|
dt.date().day(),
|
|
|
|
|
|
dt.time().hour(),
|
|
|
|
|
|
dt.time().minute(),
|
|
|
|
|
|
dt.time().second());
|
|
|
|
|
|
*/
|
|
|
|
|
|
++nLabels;
|
|
|
|
|
|
if( autoDtLabels )
|
|
|
|
|
|
labelTexts.append( "x" );
|
|
|
|
|
|
else
|
|
|
|
|
|
labelTexts.append( dt.toString( TQt::ISODate ) );
|
|
|
|
|
|
bDone = (goDown ? (dt < dtLow ) : (dt > dtHigh));
|
|
|
|
|
|
/*if( bDone ){
|
|
|
|
|
|
dtHigh = dt;
|
|
|
|
|
|
}else*/{
|
|
|
|
|
|
switch( dtDeltaScale ) {
|
|
|
|
|
|
case KDChartAxisParams::ValueScaleSecond:
|
|
|
|
|
|
dtAddSecs( dt, 1 * mult, dt );
|
|
|
|
|
|
break;
|
|
|
|
|
|
case KDChartAxisParams::ValueScaleMinute:
|
|
|
|
|
|
dtAddSecs( dt, 60 * mult, dt );
|
|
|
|
|
|
break;
|
|
|
|
|
|
case KDChartAxisParams::ValueScaleHour:
|
|
|
|
|
|
dtAddSecs( dt, 3600 * mult, dt );
|
|
|
|
|
|
break;
|
|
|
|
|
|
case KDChartAxisParams::ValueScaleDay:
|
|
|
|
|
|
dtAddDays( dt, 1 * mult, dt );
|
|
|
|
|
|
break;
|
|
|
|
|
|
case KDChartAxisParams::ValueScaleWeek:
|
|
|
|
|
|
dtAddDays( dt, 7 * mult, dt );
|
|
|
|
|
|
break;
|
|
|
|
|
|
case KDChartAxisParams::ValueScaleMonth:
|
|
|
|
|
|
dtAddMonths( dt,1 * mult, dt );
|
|
|
|
|
|
break;
|
|
|
|
|
|
case KDChartAxisParams::ValueScaleQuarter:
|
|
|
|
|
|
dtAddMonths( dt,3 * mult, dt );
|
|
|
|
|
|
break;
|
|
|
|
|
|
case KDChartAxisParams::ValueScaleYear:
|
|
|
|
|
|
dtAddYears( dt, 1 * mult, dt );
|
|
|
|
|
|
break;
|
|
|
|
|
|
default:
|
|
|
|
|
|
dtAddDays( dt, 1 * mult, dt );
|
|
|
|
|
|
break;
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
//if( autoDtLabels )
|
|
|
|
|
|
// labelTexts.append( "x" );
|
|
|
|
|
|
( ( KDChartAxisParams& ) para ).setTrueAxisDtLowHighDeltaScale(
|
|
|
|
|
|
dtLow, dtHigh,
|
|
|
|
|
|
dtDeltaScale );
|
|
|
|
|
|
// note: pDelimDelta will be calculated below,
|
|
|
|
|
|
// look for "COMMOM CALC OF NLABELS, DELIM DELTA..."
|
|
|
|
|
|
}
|
|
|
|
|
|
bDone = true;
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// let's generate some strings
|
|
|
|
|
|
if ( !bDone ) {
|
|
|
|
|
|
// default scenario for abscissa axes
|
|
|
|
|
|
uint count = bStatistical
|
|
|
|
|
|
? (data.usedRows() ? data.usedRows() : 1)
|
|
|
|
|
|
: (data.usedCols() ? data.usedCols() : 1);
|
|
|
|
|
|
//double start( 1.0 );
|
|
|
|
|
|
double start( 1.0 + (bSteadyCalc ? 0.0 : static_cast < double >(data.colsScrolledBy())) );
|
|
|
|
|
|
//tqDebug("colsScrolledBy: %i", data.colsScrolledBy());
|
|
|
|
|
|
//if(bVertAxis)
|
|
|
|
|
|
//tqDebug("vert nVal starting: %f",start);
|
|
|
|
|
|
//else
|
|
|
|
|
|
//tqDebug("horz nVal starting: %f",start);
|
|
|
|
|
|
//if(bSteadyCalc)
|
|
|
|
|
|
//tqDebug("bSteadyCalc");
|
|
|
|
|
|
//else
|
|
|
|
|
|
//tqDebug("not bSteadyCalc");
|
|
|
|
|
|
double delta( 1.0 );
|
|
|
|
|
|
double finis( start + delta * ( count - 1 ) );
|
|
|
|
|
|
const bool startIsDouble = TQVariant::Double == para.axisValueStart().type();
|
|
|
|
|
|
const bool endIsDouble = TQVariant::Double == para.axisValueEnd().type();
|
|
|
|
|
|
|
|
|
|
|
|
bool deltaIsAuto = true;
|
|
|
|
|
|
if ( !( KDCHART_AXIS_LABELS_AUTO_DELTA == para.axisValueDelta() ) ) {
|
|
|
|
|
|
delta = para.axisValueDelta();
|
|
|
|
|
|
deltaIsAuto = false;
|
|
|
|
|
|
}
|
|
|
|
|
|
if ( KDCHART_AXIS_LABELS_AUTO_LIMIT == para.axisValueStart() ) {
|
|
|
|
|
|
if ( ( KDCHART_AXIS_LABELS_AUTO_LIMIT == para.axisValueEnd() ) ) {
|
|
|
|
|
|
finis = start + delta * ( count - 1 );
|
|
|
|
|
|
} else {
|
|
|
|
|
|
if( endIsDouble ){
|
|
|
|
|
|
finis = para.axisValueEnd().toDouble();
|
|
|
|
|
|
start = finis - delta * ( count - 1 );
|
|
|
|
|
|
//tqDebug("1 changing: start: %f",start);
|
|
|
|
|
|
} else {
|
|
|
|
|
|
//
|
|
|
|
|
|
//
|
|
|
|
|
|
// F E A T U R E P L A N N E D F O R F U T U R E . . .
|
|
|
|
|
|
//
|
|
|
|
|
|
//
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
}else{
|
|
|
|
|
|
if ( startIsDouble ) {
|
|
|
|
|
|
start = para.axisValueStart().toDouble() + (bSteadyCalc ? 0.0 : static_cast < double >(data.colsScrolledBy()));
|
|
|
|
|
|
//tqDebug("2 changing: start: %f",start);
|
|
|
|
|
|
} else {
|
|
|
|
|
|
//
|
|
|
|
|
|
//
|
|
|
|
|
|
// F E A T U R E P L A N N E D F O R F U T U R E . . .
|
|
|
|
|
|
//
|
|
|
|
|
|
//
|
|
|
|
|
|
}
|
|
|
|
|
|
if ( !( KDCHART_AXIS_LABELS_AUTO_LIMIT == para.axisValueEnd() ) ) {
|
|
|
|
|
|
if (endIsDouble ) {
|
|
|
|
|
|
finis = para.axisValueEnd().toDouble();
|
|
|
|
|
|
if ( deltaIsAuto ) {
|
|
|
|
|
|
delta = ( finis - start ) / count;
|
|
|
|
|
|
} else {
|
|
|
|
|
|
count = static_cast < uint > (
|
|
|
|
|
|
( finis - start ) / delta );
|
|
|
|
|
|
}
|
|
|
|
|
|
} else {
|
|
|
|
|
|
// auto-rows like
|
|
|
|
|
|
// sunday, monday, tuesday, ...
|
|
|
|
|
|
//
|
|
|
|
|
|
//
|
|
|
|
|
|
// F E A T U R E P L A N N E D F O R F U T U R E . . .
|
|
|
|
|
|
//
|
|
|
|
|
|
//
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
else {
|
|
|
|
|
|
finis = start + delta * ( count - 1 );
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
TQString prefix( TQObject::tr( "Item " ) );
|
|
|
|
|
|
TQString postfix;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
if ( startIsDouble && endIsDouble ) {
|
|
|
|
|
|
int precis =
|
|
|
|
|
|
KDCHART_AXIS_LABELS_AUTO_DIGITS == para.axisDigitsBehindComma()
|
|
|
|
|
|
? 0
|
|
|
|
|
|
: para.axisDigitsBehindComma();
|
|
|
|
|
|
double s = start;
|
|
|
|
|
|
double f = finis;
|
|
|
|
|
|
//tqDebug("label loop: s: %f f: %f",s,f);
|
|
|
|
|
|
bool up = ( 0.0 < delta );
|
|
|
|
|
|
// check the text widths of one large(?) entry
|
|
|
|
|
|
// and hope all the entries will
|
|
|
|
|
|
// fit into the available space
|
|
|
|
|
|
double value = up ? s : f;
|
|
|
|
|
|
uint nLabels = 0;
|
|
|
|
|
|
while ( up ? ( value <= f ) : ( value >= s ) ) {
|
|
|
|
|
|
++nLabels;
|
|
|
|
|
|
value += delta * up ? 1.0 : -1.0;
|
|
|
|
|
|
}
|
|
|
|
|
|
calculateBasicTextFactors( nTxtHeight, para,
|
|
|
|
|
|
averageValueP1000,
|
|
|
|
|
|
basicPos, orig, delimLen, nLabels,
|
|
|
|
|
|
// start of return parameters
|
|
|
|
|
|
pDelimDelta,
|
|
|
|
|
|
pTextsX, pTextsY, pTextsW, pTextsH,
|
|
|
|
|
|
textAlign );
|
|
|
|
|
|
TQFont font( para.axisLabelsFont() );
|
|
|
|
|
|
if ( para.axisLabelsFontUseRelSize() )
|
|
|
|
|
|
font.setPixelSize( static_cast < int > ( nTxtHeight ) );
|
|
|
|
|
|
painter->setFont( font );
|
|
|
|
|
|
TQFontMetrics fm( painter->fontMetrics() );
|
|
|
|
|
|
|
|
|
|
|
|
if ( fm.width( prefix +
|
|
|
|
|
|
TQString::number( -fabs( ( s + f ) / 2.0 + delta ),
|
|
|
|
|
|
'f', precis ) )
|
|
|
|
|
|
> pTextsW ) {
|
|
|
|
|
|
prefix = "";
|
|
|
|
|
|
postfix = "";
|
|
|
|
|
|
}
|
|
|
|
|
|
// now transfer the strings into labelTexts
|
|
|
|
|
|
value = up ? s : f;
|
|
|
|
|
|
while ( up ? ( value <= f ) : ( value >= s ) ) {
|
|
|
|
|
|
labelTexts.append(
|
|
|
|
|
|
prefix + TQString::number( value, 'f', precis )
|
|
|
|
|
|
+ postfix );
|
|
|
|
|
|
value += delta * up ? 1.0 : -1.0;
|
|
|
|
|
|
}
|
|
|
|
|
|
} else {
|
|
|
|
|
|
// pending(KHZ): make sure this branch will ever be reached
|
|
|
|
|
|
// check the text widths largest entry
|
|
|
|
|
|
// to make sure it will fit into the available space
|
|
|
|
|
|
calculateBasicTextFactors( nTxtHeight, para,
|
|
|
|
|
|
averageValueP1000,
|
|
|
|
|
|
basicPos, orig, delimLen,
|
|
|
|
|
|
count,
|
|
|
|
|
|
// start of return parameters
|
|
|
|
|
|
pDelimDelta,
|
|
|
|
|
|
pTextsX, pTextsY, pTextsW, pTextsH,
|
|
|
|
|
|
textAlign );
|
|
|
|
|
|
TQFont font( para.axisLabelsFont() );
|
|
|
|
|
|
if ( para.axisLabelsFontUseRelSize() )
|
|
|
|
|
|
font.setPixelSize( static_cast < int > ( nTxtHeight ) );
|
|
|
|
|
|
painter->setFont( font );
|
|
|
|
|
|
TQFontMetrics fm( painter->fontMetrics() );
|
|
|
|
|
|
|
|
|
|
|
|
if ( fm.width( prefix + TQString::number( count - 1 ) )
|
|
|
|
|
|
> pTextsW ) {
|
|
|
|
|
|
prefix = "";
|
|
|
|
|
|
postfix = "";
|
|
|
|
|
|
}
|
|
|
|
|
|
// now transfer the strings into labelTexts
|
|
|
|
|
|
for ( uint i = 1; i <= count; ++i )
|
|
|
|
|
|
labelTexts.append(
|
|
|
|
|
|
prefix + TQString::number( i ) + postfix );
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
|
finishing: COMMOM CALC OF NLABELS, DELIM DELTA...
|
|
|
|
|
|
*/
|
|
|
|
|
|
uint nLabels = labelTexts.count()
|
|
|
|
|
|
? labelTexts.count()
|
|
|
|
|
|
: 0;
|
|
|
|
|
|
( ( KDChartAxisParams& ) para ).setAxisLabelTexts( &labelTexts );
|
|
|
|
|
|
|
|
|
|
|
|
if( !adjustTheValues ){
|
|
|
|
|
|
|
|
|
|
|
|
calculateBasicTextFactors( nTxtHeight, para, averageValueP1000,
|
|
|
|
|
|
basicPos, orig, delimLen, nLabels,
|
|
|
|
|
|
// start of return parameters
|
|
|
|
|
|
pDelimDelta,
|
|
|
|
|
|
pTextsX, pTextsY, pTextsW, pTextsH,
|
|
|
|
|
|
textAlign );
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
( ( KDChartAxisParams& ) para ).setTrueAxisDeltaPixels( pDelimDelta );
|
|
|
|
|
|
|
|
|
|
|
|
//tqDebug("\nsetting: para.trueAxisLow() %f para.trueAxisHigh() %f",para.trueAxisLow(),para.trueAxisHigh());
|
|
|
|
|
|
//tqDebug("\npDelimDelta: %f", pDelimDelta );
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
|
tqDebug( "Found label texts:" );
|
|
|
|
|
|
for ( TQStringList::Iterator it = labelTexts.begin();
|
|
|
|
|
|
it != labelTexts.end(); ++it )
|
|
|
|
|
|
tqDebug( ">>> %s", (*it).latin1() );
|
|
|
|
|
|
tqDebug( "\n" );
|
|
|
|
|
|
*/
|
|
|
|
|
|
//tqDebug("\nleaving KDChartAxesPainter::calculateLabelTexts() : nTxtHeight: "+TQString::number(nTxtHeight));
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
|
Calculates some label text factors needed
|
|
|
|
|
|
by function \c calculateLabelTexts()
|
|
|
|
|
|
|
|
|
|
|
|
\note When calling this function the actual area size for this
|
|
|
|
|
|
axis must be set, this means you may only call it when
|
|
|
|
|
|
\c KDChartPainter::setupGeometry() has been called before.
|
|
|
|
|
|
|
|
|
|
|
|
\param nTxtHeight the text height to be used for calculating
|
|
|
|
|
|
the return values
|
|
|
|
|
|
\param para the KDChartAxisParams that were specified for this axis
|
|
|
|
|
|
\param averageValueP1000 (average height+width of the prtbl. area) / 1000
|
|
|
|
|
|
\param basicPos the basic axis position returned by
|
|
|
|
|
|
KDChartAxisParams::basicAxisPos()
|
|
|
|
|
|
\param orig the axis start point
|
|
|
|
|
|
\param delimLen the length of one delimiter mark
|
|
|
|
|
|
\param nLabels the number of labels to be shown at this axis
|
|
|
|
|
|
\param (all others) the reference parameters to be returned
|
|
|
|
|
|
by this function
|
|
|
|
|
|
*/
|
|
|
|
|
|
/**** static ****/
|
|
|
|
|
|
void KDChartAxesPainter::calculateBasicTextFactors( double nTxtHeight,
|
|
|
|
|
|
const KDChartAxisParams& para,
|
|
|
|
|
|
double /*averageValueP1000*/,
|
|
|
|
|
|
KDChartAxisParams::AxisPos basicPos,
|
|
|
|
|
|
const TQPoint& orig,
|
|
|
|
|
|
double delimLen,
|
|
|
|
|
|
uint nLabels,
|
|
|
|
|
|
// start of return params
|
|
|
|
|
|
double& pDelimDelta,
|
|
|
|
|
|
double& pTextsX,
|
|
|
|
|
|
double& pTextsY,
|
|
|
|
|
|
double& pTextsW,
|
|
|
|
|
|
double& pTextsH,
|
|
|
|
|
|
int& textAlign )
|
|
|
|
|
|
{
|
|
|
|
|
|
switch ( basicPos ) {
|
|
|
|
|
|
case KDChartAxisParams::AxisPosBottom: {
|
|
|
|
|
|
bool bTouchEdges = para.axisLabelsTouchEdges();
|
|
|
|
|
|
double wid = para.axisTrueAreaRect().width();
|
|
|
|
|
|
double divi = bTouchEdges
|
|
|
|
|
|
? ( 1 < nLabels ? nLabels - 1 : 1 )
|
|
|
|
|
|
: ( nLabels ? nLabels : 10 );
|
|
|
|
|
|
pDelimDelta = wid / divi;
|
|
|
|
|
|
|
|
|
|
|
|
pTextsW = pDelimDelta - 4.0;
|
|
|
|
|
|
pTextsX = orig.x() + 2.0
|
|
|
|
|
|
- ( bTouchEdges
|
|
|
|
|
|
? pDelimDelta / 2.0
|
|
|
|
|
|
: 0.0 );
|
|
|
|
|
|
pTextsH = para.axisTrueAreaRect().height() - delimLen * 1.33;
|
|
|
|
|
|
pTextsY = orig.y()
|
|
|
|
|
|
+ delimLen * 1.33;
|
|
|
|
|
|
textAlign = TQt::AlignHCenter | TQt::AlignTop;
|
|
|
|
|
|
/*
|
|
|
|
|
|
tqDebug("pTextsW %f wid %f nLabels %u", pTextsW, wid, nLabels );
|
|
|
|
|
|
*/
|
|
|
|
|
|
}
|
|
|
|
|
|
break;
|
|
|
|
|
|
case KDChartAxisParams::AxisPosLeft: {
|
|
|
|
|
|
double hig = para.axisTrueAreaRect().height();
|
|
|
|
|
|
pDelimDelta = hig / ( 1 < nLabels ? nLabels - 1 : 1 );
|
|
|
|
|
|
|
|
|
|
|
|
pTextsX = para.axisTrueAreaRect().bottomLeft().x()
|
|
|
|
|
|
+ 2.0;
|
|
|
|
|
|
pTextsY = orig.y() - nTxtHeight / 2;
|
|
|
|
|
|
pTextsW = para.axisTrueAreaRect().width()
|
|
|
|
|
|
- delimLen * 1.33 - 2.0;
|
|
|
|
|
|
pTextsH = nTxtHeight;
|
|
|
|
|
|
textAlign = TQt::AlignRight | TQt::AlignVCenter;
|
|
|
|
|
|
}
|
|
|
|
|
|
break;
|
|
|
|
|
|
case KDChartAxisParams::AxisPosTop: {
|
|
|
|
|
|
bool bTouchEdges = para.axisLabelsTouchEdges();
|
|
|
|
|
|
double wid = para.axisTrueAreaRect().width();
|
|
|
|
|
|
double divi = bTouchEdges
|
|
|
|
|
|
? ( 1 < nLabels ? nLabels - 1 : 1 )
|
|
|
|
|
|
: ( nLabels ? nLabels : 10 );
|
|
|
|
|
|
pDelimDelta = wid / divi;
|
|
|
|
|
|
|
|
|
|
|
|
pTextsW = pDelimDelta - 4.0;
|
|
|
|
|
|
pDelimDelta = wid / divi;
|
|
|
|
|
|
|
|
|
|
|
|
pTextsX = orig.x() + 2.0
|
|
|
|
|
|
- ( bTouchEdges
|
|
|
|
|
|
? pDelimDelta / 2.0
|
|
|
|
|
|
: 0.0 );
|
|
|
|
|
|
pTextsH = para.axisTrueAreaRect().height() - delimLen * 1.33;
|
|
|
|
|
|
pTextsY = para.axisTrueAreaRect().topLeft().y();
|
|
|
|
|
|
textAlign = TQt::AlignHCenter | TQt::AlignBottom;
|
|
|
|
|
|
}
|
|
|
|
|
|
break;
|
|
|
|
|
|
case KDChartAxisParams::AxisPosRight: {
|
|
|
|
|
|
double hig = para.axisTrueAreaRect().height();
|
|
|
|
|
|
pDelimDelta = hig / ( 1 < nLabels ? nLabels - 1 : 1 );
|
|
|
|
|
|
|
|
|
|
|
|
pTextsX = para.axisTrueAreaRect().bottomLeft().x()
|
|
|
|
|
|
+ delimLen * 1.33;
|
|
|
|
|
|
pTextsY = orig.y() - nTxtHeight / 2;
|
|
|
|
|
|
pTextsW = para.axisTrueAreaRect().width()
|
|
|
|
|
|
- delimLen * 1.33 - 2.0;
|
|
|
|
|
|
pTextsH = nTxtHeight;
|
|
|
|
|
|
textAlign = TQt::AlignLeft | TQt::AlignVCenter;
|
|
|
|
|
|
}
|
|
|
|
|
|
break;
|
|
|
|
|
|
default: {
|
|
|
|
|
|
tqDebug( "IMPLEMENTATION ERROR: KDChartAxesPainter::calculateBasicTextFactors() unhandled enum value." );
|
|
|
|
|
|
// NOOP since the 'basicPos' does not support more that these four values.
|
|
|
|
|
|
}
|
|
|
|
|
|
break;
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
|
Takes double \c nVal and returns a TQString showing the amount of digits
|
|
|
|
|
|
behind the comma that was specified by \c behindComma (or calculated
|
|
|
|
|
|
automatically by removing trailing zeroes, resp.).
|
|
|
|
|
|
To make sure the resulting string looks fine together with other strings
|
|
|
|
|
|
of the same label row please specify \c nDelta indicating the step width
|
|
|
|
|
|
from one label text to the other.
|
|
|
|
|
|
To prevent the function from having to re-calculate the number of
|
|
|
|
|
|
digits to keep behind the comma, provide it with a temporary helper
|
|
|
|
|
|
variable "trueBehindComma" that has to be initialized with a value
|
|
|
|
|
|
smaller than zero.
|
|
|
|
|
|
|
|
|
|
|
|
\note This function is reserved for internal use.
|
|
|
|
|
|
*/
|
|
|
|
|
|
TQString KDChartAxesPainter::truncateBehindComma( const double nVal,
|
|
|
|
|
|
const int behindComma,
|
|
|
|
|
|
const double nDelta,
|
|
|
|
|
|
int& trueBehindComma )
|
|
|
|
|
|
{
|
|
|
|
|
|
const int nTrustedPrecision = 6; // when using 15 we got 1.850000 rounded to 1.849999999999999
|
|
|
|
|
|
|
|
|
|
|
|
const bool bUseAutoDigits = KDCHART_AXIS_LABELS_AUTO_DIGITS == behindComma;
|
|
|
|
|
|
const bool bAutoDelta = KDCHART_AXIS_LABELS_AUTO_DELTA == nDelta;
|
|
|
|
|
|
TQString sVal;
|
|
|
|
|
|
sVal.setNum( nVal, 'f', bUseAutoDigits ? nTrustedPrecision
|
|
|
|
|
|
: TQMIN(behindComma, nTrustedPrecision) );
|
|
|
|
|
|
//tqDebug("nVal: %f sVal: "+sVal, nVal );
|
|
|
|
|
|
//tqDebug( TQString(" %1").arg(sVal));
|
|
|
|
|
|
if ( bUseAutoDigits ) {
|
|
|
|
|
|
int comma = sVal.find( '.' );
|
|
|
|
|
|
if ( -1 < comma ) {
|
|
|
|
|
|
if ( bAutoDelta ) {
|
|
|
|
|
|
int i = sVal.length();
|
|
|
|
|
|
while ( 1 < i
|
|
|
|
|
|
&& '0' == sVal[ i - 1 ] )
|
|
|
|
|
|
--i;
|
|
|
|
|
|
sVal.truncate( i );
|
|
|
|
|
|
if ( '.' == sVal[ i - 1 ] )
|
|
|
|
|
|
sVal.truncate( i - 1 );
|
|
|
|
|
|
} else {
|
|
|
|
|
|
if ( 0 > trueBehindComma ) {
|
|
|
|
|
|
TQString sDelta = TQString::number( nDelta, 'f', nTrustedPrecision );
|
|
|
|
|
|
int i = sDelta.length();
|
|
|
|
|
|
while ( 1 < i
|
|
|
|
|
|
&& '0' == sDelta[ i - 1 ] )
|
|
|
|
|
|
--i;
|
|
|
|
|
|
sDelta.truncate( i );
|
|
|
|
|
|
if ( '.' == sDelta[ i - 1 ] )
|
|
|
|
|
|
trueBehindComma = 0;
|
|
|
|
|
|
else {
|
|
|
|
|
|
int deltaComma = sDelta.find( '.' );
|
|
|
|
|
|
if ( -1 < deltaComma )
|
|
|
|
|
|
trueBehindComma = sDelta.length() - deltaComma - 1;
|
|
|
|
|
|
else
|
|
|
|
|
|
trueBehindComma = 0;
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
// now we cut off the too-many digits behind the comma
|
|
|
|
|
|
int nPos = comma + ( trueBehindComma ? trueBehindComma + 1 : 0 );
|
|
|
|
|
|
sVal.truncate( nPos );
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
//tqDebug( TQString(" - %1").arg(trueBehindComma));
|
|
|
|
|
|
return sVal;
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
#if 0
|
|
|
|
|
|
|
|
|
|
|
|
#if defined ( TQ_WS_WIN)
|
|
|
|
|
|
#define trunc(x) ((int)(x))
|
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
#else
|
|
|
|
|
|
|
|
|
|
|
|
// Ugly hack because Solaris (among others?) doesn't have trunc(),
|
|
|
|
|
|
// since the libs are not C99. I could do a complex #if expression,
|
|
|
|
|
|
// but instead I will just define trunc() here.
|
|
|
|
|
|
|
|
|
|
|
|
double trunc(double x)
|
|
|
|
|
|
{
|
|
|
|
|
|
return x >= 0.0 ? floor(x) : -floor(-x);
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
TQString KDChartAxesPainter::applyLabelsFormat( const double nVal_,
|
|
|
|
|
|
int divPow10,
|
|
|
|
|
|
int behindComma,
|
|
|
|
|
|
double nDelta_,
|
|
|
|
|
|
int& trueBehindComma,
|
|
|
|
|
|
KDChartEnums::NumberNotation notation,
|
|
|
|
|
|
const TQString& decimalPoint,
|
|
|
|
|
|
const TQString& thousandsPoint,
|
|
|
|
|
|
const TQString& prefix,
|
|
|
|
|
|
const TQString& postfix,
|
|
|
|
|
|
int totalLen,
|
|
|
|
|
|
const TQChar& padFill,
|
|
|
|
|
|
bool blockAlign )
|
|
|
|
|
|
{
|
|
|
|
|
|
double nVal = nVal_ / fastPow10( divPow10 );
|
|
|
|
|
|
double nDelta = nDelta_;
|
|
|
|
|
|
|
|
|
|
|
|
double valLog10 = 0.0;
|
|
|
|
|
|
if( notation == KDChartEnums::NumberNotationScientific ||
|
|
|
|
|
|
notation == KDChartEnums::NumberNotationScientificBig ){
|
|
|
|
|
|
valLog10 = (nVal != 0.0) ? trunc( log10(TQABS(nVal)) ) : 0.0;
|
|
|
|
|
|
//tqDebug("nVal old: %f valLog10: %f",nVal,valLog10);
|
|
|
|
|
|
nVal /= fastPow10( valLog10 );
|
|
|
|
|
|
nDelta /= fastPow10( valLog10 );
|
|
|
|
|
|
//tqDebug("nVal new: %f",nVal);
|
|
|
|
|
|
}
|
|
|
|
|
|
TQString sVal = truncateBehindComma( nVal,
|
|
|
|
|
|
behindComma,
|
|
|
|
|
|
nDelta,
|
|
|
|
|
|
trueBehindComma );
|
|
|
|
|
|
//tqDebug("sVal : "+sVal+" behindComma: %i",behindComma);
|
|
|
|
|
|
|
|
|
|
|
|
int posComma = sVal.find( '.' );
|
|
|
|
|
|
if( 0 <= posComma ){
|
|
|
|
|
|
sVal.replace( posComma, 1, decimalPoint);
|
|
|
|
|
|
}else{
|
|
|
|
|
|
posComma = sVal.length();
|
|
|
|
|
|
}
|
|
|
|
|
|
if( notation == KDChartEnums::NumberNotationScientific ||
|
|
|
|
|
|
notation == KDChartEnums::NumberNotationScientificBig ){
|
|
|
|
|
|
if( notation == KDChartEnums::NumberNotationScientific )
|
|
|
|
|
|
sVal.append( "e" );
|
|
|
|
|
|
else
|
|
|
|
|
|
sVal.append( "E" );
|
|
|
|
|
|
sVal.append( TQString::number( valLog10, 'f', 0 ) );
|
|
|
|
|
|
} else {
|
|
|
|
|
|
if( thousandsPoint.length() ){
|
|
|
|
|
|
const int minLen = (0 < sVal.length() && '-' == sVal[0])
|
|
|
|
|
|
? 4
|
|
|
|
|
|
: 3;
|
|
|
|
|
|
int n = posComma; // number of digits at the left side of the comma
|
|
|
|
|
|
while( minLen < n ){
|
|
|
|
|
|
n -= 3;
|
|
|
|
|
|
sVal.insert(n, thousandsPoint);
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
sVal.append( postfix );
|
|
|
|
|
|
int nFill = totalLen - (sVal.length() + prefix.length());
|
|
|
|
|
|
if( 0 > nFill )
|
|
|
|
|
|
nFill = 0;
|
|
|
|
|
|
if( !blockAlign )
|
|
|
|
|
|
sVal.prepend( prefix );
|
|
|
|
|
|
for(int i=0; i < nFill; ++i)
|
|
|
|
|
|
sVal.prepend( padFill );
|
|
|
|
|
|
if( blockAlign )
|
|
|
|
|
|
sVal.prepend( prefix );
|
|
|
|
|
|
if ( totalLen > 0 )
|
|
|
|
|
|
sVal.truncate( totalLen );
|
|
|
|
|
|
/*Pending Michel: Force non fractional values
|
|
|
|
|
|
*In case it is a fractional value
|
|
|
|
|
|
*and the user has set axisLabelsDigitsBehindComma() == 0
|
|
|
|
|
|
*return an empty string
|
|
|
|
|
|
*/
|
|
|
|
|
|
if ( behindComma == 0 && TQString::number(nVal).find('.') > 0 )
|
|
|
|
|
|
sVal = TQString();//sVal = "";
|
|
|
|
|
|
return sVal;
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
|
Calculates the factors to be used for calculating ordinate labels texts.
|
|
|
|
|
|
|
|
|
|
|
|
\note This function is reserved for internal use.
|
|
|
|
|
|
*/
|
|
|
|
|
|
void KDChartAxesPainter::calculateOrdinateFactors(
|
|
|
|
|
|
const KDChartAxisParams& para,
|
|
|
|
|
|
bool isLogarithmic,
|
|
|
|
|
|
double& nDist,
|
|
|
|
|
|
double& nDivisor,
|
|
|
|
|
|
double& nRound,
|
|
|
|
|
|
double& nDelta,
|
|
|
|
|
|
double& nSubDelimFactor,
|
|
|
|
|
|
double& nLow,
|
|
|
|
|
|
double& nHigh,
|
|
|
|
|
|
bool findNextRound )
|
|
|
|
|
|
{
|
|
|
|
|
|
if ( findNextRound ) {
|
|
|
|
|
|
if ( 1.0 > nRound )
|
|
|
|
|
|
nRound = 1.0;
|
|
|
|
|
|
else
|
|
|
|
|
|
if ( 2.0 > nRound )
|
|
|
|
|
|
nRound = 2.0;
|
|
|
|
|
|
else
|
|
|
|
|
|
if ( 2.5 > nRound )
|
|
|
|
|
|
nRound = 2.5;
|
|
|
|
|
|
else
|
|
|
|
|
|
if ( 5.0 > nRound )
|
|
|
|
|
|
nRound = 5.0;
|
|
|
|
|
|
else {
|
|
|
|
|
|
nDivisor *= 10.0;
|
|
|
|
|
|
nRound = 1.0;
|
|
|
|
|
|
}
|
|
|
|
|
|
} else {
|
|
|
|
|
|
nDivisor = 1.0;
|
|
|
|
|
|
TQString sDistDigis2;
|
|
|
|
|
|
sDistDigis2.setNum( nDist, 'f', 24);
|
|
|
|
|
|
if ( 1.0 > nDist ) {
|
|
|
|
|
|
sDistDigis2.remove( 0, 2 );
|
|
|
|
|
|
nDivisor = 0.01;
|
|
|
|
|
|
while ( 0 < sDistDigis2.length()
|
|
|
|
|
|
&& '0' == sDistDigis2[ 0 ] ) {
|
|
|
|
|
|
nDivisor *= 0.1;
|
|
|
|
|
|
sDistDigis2.remove( 0, 1 );
|
|
|
|
|
|
}
|
|
|
|
|
|
} else {
|
|
|
|
|
|
if ( 10.0 > nDist ) {
|
|
|
|
|
|
nDivisor = 0.1;
|
|
|
|
|
|
// remove comma, if present
|
|
|
|
|
|
sDistDigis2.remove( 1, 1 );
|
|
|
|
|
|
} else
|
|
|
|
|
|
if ( 100.0 > nDist )
|
|
|
|
|
|
nDivisor = 1.0;
|
|
|
|
|
|
else {
|
|
|
|
|
|
int comma = sDistDigis2.find( '.' );
|
|
|
|
|
|
if ( -1 < comma )
|
|
|
|
|
|
sDistDigis2.truncate( comma );
|
|
|
|
|
|
nDivisor = fastPow10( (int)sDistDigis2.length() - 2 );
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
sDistDigis2.truncate( 2 );
|
|
|
|
|
|
bool bOk;
|
|
|
|
|
|
double nDistDigis2( sDistDigis2.toDouble( &bOk ) );
|
|
|
|
|
|
if ( !bOk )
|
|
|
|
|
|
nDistDigis2 = 10.0;
|
|
|
|
|
|
if ( 75.0 <= nDistDigis2 )
|
|
|
|
|
|
nRound = 5.0;
|
|
|
|
|
|
else
|
|
|
|
|
|
if ( 40.0 <= nDistDigis2 )
|
|
|
|
|
|
nRound = 2.5;
|
|
|
|
|
|
else
|
|
|
|
|
|
if ( 20.0 <= nDistDigis2 )
|
|
|
|
|
|
nRound = 2.0;
|
|
|
|
|
|
else
|
|
|
|
|
|
nRound = 1.0;
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
nDelta = nRound * nDivisor;
|
|
|
|
|
|
|
|
|
|
|
|
// make sure its a whole number > 0 if its a log axis. Just round up.
|
|
|
|
|
|
if( isLogarithmic )
|
|
|
|
|
|
nDelta = static_cast < int > ( nDelta ) < nDelta
|
|
|
|
|
|
? static_cast < int > ( nDelta ) + 1
|
|
|
|
|
|
: static_cast < int > ( nDelta );
|
|
|
|
|
|
|
|
|
|
|
|
bool bInvertedAxis = ( 0.0 > nDist );
|
|
|
|
|
|
if( bInvertedAxis )
|
|
|
|
|
|
nDelta *= -1.0;
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
|
tqDebug(" n D i s t : %f", nDist );
|
|
|
|
|
|
tqDebug(" n D i v i s o r : %f", nDivisor);
|
|
|
|
|
|
tqDebug(" n R o u n d : %f", nRound );
|
|
|
|
|
|
tqDebug(" n D e l t a : %f", nDelta );
|
|
|
|
|
|
tqDebug(" nHigh : %f", nHigh );
|
|
|
|
|
|
tqDebug(" nLow : %f", nLow );
|
|
|
|
|
|
*/
|
|
|
|
|
|
if( KDCHART_AXIS_LABELS_AUTO_LIMIT == para.axisValueStart()
|
|
|
|
|
|
|| !para.axisValueStartIsExact() ) {
|
|
|
|
|
|
double orgLow( nLow );
|
|
|
|
|
|
modf( nLow / nDelta, &nLow );
|
|
|
|
|
|
nLow *= nDelta;
|
|
|
|
|
|
if( bInvertedAxis ){
|
|
|
|
|
|
if ( nLow < orgLow )
|
|
|
|
|
|
nLow += nDelta;
|
|
|
|
|
|
if ( 0.0 > nLow && 0.0 <= orgLow )
|
|
|
|
|
|
nLow = 0.0;
|
|
|
|
|
|
}else{
|
|
|
|
|
|
if ( nLow > orgLow )
|
|
|
|
|
|
nLow -= nDelta;
|
|
|
|
|
|
if ( 0.0 < nLow && 0.0 >= orgLow )
|
|
|
|
|
|
nLow = 0.0;
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
if ( KDCHART_AXIS_LABELS_AUTO_LIMIT == para.axisValueEnd() ) {
|
|
|
|
|
|
double orgHigh( nHigh );
|
|
|
|
|
|
modf( nHigh / nDelta, &nHigh );
|
|
|
|
|
|
nHigh *= nDelta;
|
|
|
|
|
|
if( bInvertedAxis ){
|
|
|
|
|
|
if ( nHigh > orgHigh )
|
|
|
|
|
|
nHigh -= nDelta;
|
|
|
|
|
|
if ( 0.0 < nHigh && 0.0 >= orgHigh )
|
|
|
|
|
|
nHigh = 0.0;
|
|
|
|
|
|
}else{
|
|
|
|
|
|
if ( nHigh < orgHigh )
|
|
|
|
|
|
nHigh += nDelta;
|
|
|
|
|
|
if ( 0.0 > nHigh && 0.0 <= orgHigh )
|
|
|
|
|
|
nHigh = 0.0;
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
//tqDebug(" n H i g h : %f", nHigh );
|
|
|
|
|
|
//tqDebug(" n L o w : %f\n\n", nLow );
|
|
|
|
|
|
|
|
|
|
|
|
if ( 1.0 == nRound )
|
|
|
|
|
|
nSubDelimFactor = 0.5;
|
|
|
|
|
|
else
|
|
|
|
|
|
if ( 2.0 == nRound )
|
|
|
|
|
|
nSubDelimFactor = 0.25;
|
|
|
|
|
|
else
|
|
|
|
|
|
if ( 2.5 == nRound )
|
|
|
|
|
|
nSubDelimFactor = 0.2;
|
|
|
|
|
|
else
|
|
|
|
|
|
if ( 5.0 == nRound )
|
|
|
|
|
|
nSubDelimFactor = 0.2;
|
|
|
|
|
|
else {
|
|
|
|
|
|
// Should not happen
|
|
|
|
|
|
tqDebug( "IMPLEMENTATION ERROR: Unknown nRound in calculateOrdinateFactors()" );
|
|
|
|
|
|
nSubDelimFactor = 1.0;
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
nDist = nHigh - nLow;
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**** static ****/
|
|
|
|
|
|
void KDChartAxesPainter::saveDrawLine( TQPainter& painter,
|
|
|
|
|
|
TQPoint pA,
|
|
|
|
|
|
TQPoint pZ,
|
|
|
|
|
|
TQPen pen )
|
|
|
|
|
|
{
|
|
|
|
|
|
const TQPen oldPen( painter.pen() );
|
|
|
|
|
|
bool bNice = ( pen.color() == oldPen.color() )
|
|
|
|
|
|
&& ( pen.width() == oldPen.width() )
|
|
|
|
|
|
&& ( pen.style() == oldPen.style() );
|
|
|
|
|
|
if ( !bNice )
|
|
|
|
|
|
painter.setPen( pen );
|
|
|
|
|
|
painter.drawLine( pA, pZ );
|
|
|
|
|
|
if ( !bNice )
|
|
|
|
|
|
painter.setPen( oldPen );
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**** static ****/
|
|
|
|
|
|
void KDChartAxesPainter::dtAddSecs( const TQDateTime& org, const int secs, TQDateTime& dest )
|
|
|
|
|
|
{
|
|
|
|
|
|
//tqDebug("entering KDChartAxesPainter::dtAddSecs() ..");
|
|
|
|
|
|
int s = org.time().second();
|
|
|
|
|
|
int m = org.time().minute();
|
|
|
|
|
|
int h = org.time().hour();
|
|
|
|
|
|
int days = 0;
|
|
|
|
|
|
if( -1 < secs ){
|
|
|
|
|
|
int mins = (s + secs) / 60;
|
|
|
|
|
|
if( 0 == mins )
|
|
|
|
|
|
s += secs;
|
|
|
|
|
|
else{
|
|
|
|
|
|
s = (s + secs) % 60;
|
|
|
|
|
|
int hours = (m + mins) / 60;
|
|
|
|
|
|
if( 0 == hours )
|
|
|
|
|
|
m += mins;
|
|
|
|
|
|
else{
|
|
|
|
|
|
m = (m + mins) % 60;
|
|
|
|
|
|
days = (h + hours) / 24;
|
|
|
|
|
|
if( 0 == days )
|
|
|
|
|
|
h += hours;
|
|
|
|
|
|
else{
|
|
|
|
|
|
h = (h + hours) % 24;
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
dest.setTime( TQTime(h,m,s) );
|
|
|
|
|
|
dest.setDate( org.date() );
|
|
|
|
|
|
if( days )
|
|
|
|
|
|
dtAddDays( dest, days, dest );
|
|
|
|
|
|
//tqDebug(".. KDChartAxesPainter::dtAddSecs() done.");
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**** static ****/
|
|
|
|
|
|
void KDChartAxesPainter::dtAddDays( const TQDateTime& org, const int days, TQDateTime& dest )
|
|
|
|
|
|
{
|
|
|
|
|
|
//tqDebug("entering KDChartAxesPainter::dtAddDays() ..");
|
|
|
|
|
|
int d = org.date().day();
|
|
|
|
|
|
int m = org.date().month();
|
|
|
|
|
|
int y = org.date().year();
|
|
|
|
|
|
int dd = (-1 < days) ? 1 : -1;
|
|
|
|
|
|
int di = 0;
|
|
|
|
|
|
while( di != days ){
|
|
|
|
|
|
d += dd;
|
|
|
|
|
|
// underrunning day?
|
|
|
|
|
|
if( 1 > d ){
|
|
|
|
|
|
if( 1 < m ){
|
|
|
|
|
|
--m;
|
|
|
|
|
|
d = TQDate( y,m,1 ).daysInMonth();
|
|
|
|
|
|
}
|
|
|
|
|
|
else{
|
|
|
|
|
|
--y;
|
|
|
|
|
|
m = 12;
|
|
|
|
|
|
d = 31;
|
|
|
|
|
|
}
|
|
|
|
|
|
// overrunning day?
|
|
|
|
|
|
}else if( TQDate( y,m,1 ).daysInMonth() < d ){
|
|
|
|
|
|
if( 12 > m )
|
|
|
|
|
|
++m;
|
|
|
|
|
|
else{
|
|
|
|
|
|
++y;
|
|
|
|
|
|
m = 1;
|
|
|
|
|
|
}
|
|
|
|
|
|
d = 1;
|
|
|
|
|
|
}
|
|
|
|
|
|
di += dd;
|
|
|
|
|
|
}
|
|
|
|
|
|
dest = TQDateTime( TQDate( y,m,d ), org.time() );
|
|
|
|
|
|
//tqDebug(".. KDChartAxesPainter::dtAddDays() done.");
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**** static ****/
|
|
|
|
|
|
void KDChartAxesPainter::dtAddMonths( const TQDateTime& org, const int months, TQDateTime& dest )
|
|
|
|
|
|
{
|
|
|
|
|
|
//tqDebug("entering KDChartAxesPainter::dtAddMonths() ..");
|
|
|
|
|
|
int d = org.date().day();
|
|
|
|
|
|
int m = org.date().month();
|
|
|
|
|
|
int y = org.date().year();
|
|
|
|
|
|
int md = (-1 < months) ? 1 : -1;
|
|
|
|
|
|
int mi = 0;
|
|
|
|
|
|
while( mi != months ){
|
|
|
|
|
|
m += md;
|
|
|
|
|
|
if( 1 > m ){
|
|
|
|
|
|
--y;
|
|
|
|
|
|
m = 12;
|
|
|
|
|
|
}else if( 12 < m ){
|
|
|
|
|
|
++y;
|
|
|
|
|
|
m = 1;
|
|
|
|
|
|
}
|
|
|
|
|
|
mi += md;
|
|
|
|
|
|
}
|
|
|
|
|
|
// TQMIN takes care for intercalary day
|
|
|
|
|
|
dest = TQDateTime( TQDate( y,m,TQMIN( d, TQDate( y,m,1 ).daysInMonth() ) ),
|
|
|
|
|
|
org.time() );
|
|
|
|
|
|
//tqDebug(".. KDChartAxesPainter::dtAddMonths() done.");
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**** static ****/
|
|
|
|
|
|
void KDChartAxesPainter::dtAddYears( const TQDateTime& org, const int years, TQDateTime& dest )
|
|
|
|
|
|
{
|
|
|
|
|
|
//tqDebug("entering KDChartAxesPainter::dtAddYears() ..");
|
|
|
|
|
|
int d = org.date().day();
|
|
|
|
|
|
int m = org.date().month();
|
|
|
|
|
|
int y = org.date().year() + years;
|
|
|
|
|
|
dest.setTime( org.time() );
|
|
|
|
|
|
// TQMIN takes care for intercalary day
|
|
|
|
|
|
dest = TQDateTime( TQDate( y,m,TQMIN( d, TQDate( y,m,d ).daysInMonth() ) ),
|
|
|
|
|
|
org.time() );
|
|
|
|
|
|
//tqDebug(".. KDChartAxesPainter::dtAddYears() done.");
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void KDChartAxesPainter::calculateAbscissaInfos( const KDChartParams& params,
|
|
|
|
|
|
const KDChartTableDataBase& data,
|
|
|
|
|
|
uint datasetStart,
|
|
|
|
|
|
uint datasetEnd,
|
|
|
|
|
|
double logWidth,
|
|
|
|
|
|
const TQRect& dataRect,
|
|
|
|
|
|
abscissaInfos& infos )
|
|
|
|
|
|
{
|
|
|
|
|
|
if( params.axisParams( KDChartAxisParams::AxisPosBottom ).axisVisible()
|
|
|
|
|
|
&& ( KDChartAxisParams::AxisTypeUnknown
|
|
|
|
|
|
!= params.axisParams( KDChartAxisParams::AxisPosBottom ).axisType() ) )
|
|
|
|
|
|
infos.abscissaPara = ¶ms.axisParams( KDChartAxisParams::AxisPosBottom );
|
|
|
|
|
|
else
|
|
|
|
|
|
if( params.axisParams( KDChartAxisParams::AxisPosBottom2 ).axisVisible()
|
|
|
|
|
|
&& ( KDChartAxisParams::AxisTypeUnknown
|
|
|
|
|
|
!= params.axisParams( KDChartAxisParams::AxisPosBottom2 ).axisType() ) )
|
|
|
|
|
|
infos.abscissaPara = ¶ms.axisParams( KDChartAxisParams::AxisPosBottom2 );
|
|
|
|
|
|
else
|
|
|
|
|
|
if( params.axisParams( KDChartAxisParams::AxisPosTop ).axisVisible()
|
|
|
|
|
|
&& ( KDChartAxisParams::AxisTypeUnknown
|
|
|
|
|
|
!= params.axisParams( KDChartAxisParams::AxisPosTop ).axisType() ) )
|
|
|
|
|
|
infos.abscissaPara = ¶ms.axisParams( KDChartAxisParams::AxisPosTop );
|
|
|
|
|
|
else
|
|
|
|
|
|
if( params.axisParams( KDChartAxisParams::AxisPosTop2 ).axisVisible()
|
|
|
|
|
|
&& ( KDChartAxisParams::AxisTypeUnknown
|
|
|
|
|
|
!= params.axisParams( KDChartAxisParams::AxisPosTop2 ).axisType() ) )
|
|
|
|
|
|
infos.abscissaPara = ¶ms.axisParams( KDChartAxisParams::AxisPosTop2 );
|
|
|
|
|
|
else
|
|
|
|
|
|
// default is bottom axis:
|
|
|
|
|
|
infos.abscissaPara = ¶ms.axisParams( KDChartAxisParams::AxisPosBottom );
|
|
|
|
|
|
|
|
|
|
|
|
if( infos.abscissaPara->axisLabelsTouchEdges() )
|
|
|
|
|
|
infos.bCenterThePoints = false;
|
|
|
|
|
|
|
|
|
|
|
|
infos.bAbscissaDecreasing = infos.abscissaPara->axisValuesDecreasing();
|
|
|
|
|
|
infos.bAbscissaIsLogarithmic
|
|
|
|
|
|
= KDChartAxisParams::AxisCalcLogarithmic == infos.abscissaPara->axisCalcMode();
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// Number of values: If -1, use all values, otherwise use the
|
|
|
|
|
|
// specified number of values.
|
|
|
|
|
|
infos.numValues = 0;
|
|
|
|
|
|
if ( params.numValues() > -1 )
|
|
|
|
|
|
infos.numValues = params.numValues();
|
|
|
|
|
|
else
|
|
|
|
|
|
infos.numValues = data.usedCols();
|
|
|
|
|
|
|
|
|
|
|
|
TQVariant::Type type2Ref = TQVariant::Invalid;
|
|
|
|
|
|
infos.bCellsHaveSeveralCoordinates =
|
|
|
|
|
|
data.cellsHaveSeveralCoordinates( datasetStart, datasetEnd,
|
|
|
|
|
|
&type2Ref );
|
|
|
|
|
|
|
|
|
|
|
|
infos.numLabels = (infos.abscissaPara &&
|
|
|
|
|
|
infos.abscissaPara->axisLabelTexts())
|
|
|
|
|
|
? infos.abscissaPara->axisLabelTexts()->count()
|
|
|
|
|
|
: infos.numValues;
|
|
|
|
|
|
if( 0 >= infos.numLabels )
|
|
|
|
|
|
infos.numLabels = 1;
|
|
|
|
|
|
|
|
|
|
|
|
infos.bAbscissaHasTrueAxisValues =
|
|
|
|
|
|
infos.abscissaPara && (0.0 != infos.abscissaPara->trueAxisDelta());
|
|
|
|
|
|
infos.abscissaStart = infos.bAbscissaHasTrueAxisValues
|
|
|
|
|
|
? infos.abscissaPara->trueAxisLow()
|
|
|
|
|
|
: 0.0;
|
|
|
|
|
|
infos.abscissaEnd = infos.bAbscissaHasTrueAxisValues
|
|
|
|
|
|
? infos.abscissaPara->trueAxisHigh()
|
|
|
|
|
|
: 1.0 * (infos.numLabels - 1);
|
|
|
|
|
|
infos.abscissaSpan = fabs( infos.abscissaEnd - infos.abscissaStart );
|
|
|
|
|
|
infos.abscissaDelta = infos.bAbscissaHasTrueAxisValues
|
|
|
|
|
|
? infos.abscissaPara->trueAxisDelta()
|
|
|
|
|
|
: ( ( 0.0 != infos.abscissaSpan )
|
|
|
|
|
|
? ( infos.abscissaSpan / infos.numLabels )
|
|
|
|
|
|
: infos.abscissaSpan );
|
|
|
|
|
|
|
|
|
|
|
|
//tqDebug( bAbscissaDecreasing ? "bAbscissaDecreasing = TRUE" : "bAbscissaDecreasing = FALSE");
|
|
|
|
|
|
//tqDebug( abscissaHasTrueAxisValues ? "abscissaHasTrueAxisValues = TRUE" : "abscissaHasTrueAxisValues = FALSE");
|
|
|
|
|
|
//tqDebug( "abscissaDelta = %f", abscissaDelta);
|
|
|
|
|
|
|
|
|
|
|
|
infos.bAbscissaHasTrueAxisDtValues =
|
|
|
|
|
|
(TQVariant::DateTime == type2Ref) &&
|
|
|
|
|
|
infos.abscissaPara &&
|
|
|
|
|
|
infos.abscissaPara->trueAxisDtLow().isValid();
|
|
|
|
|
|
if( infos.bAbscissaHasTrueAxisDtValues ){
|
|
|
|
|
|
infos.numLabels = 200;
|
|
|
|
|
|
infos.bCenterThePoints = false;
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
infos.dtLowPos = infos.bAbscissaHasTrueAxisDtValues
|
|
|
|
|
|
? infos.abscissaPara->axisDtLowPosX() - dataRect.x()
|
|
|
|
|
|
: 0.0;
|
|
|
|
|
|
infos.dtHighPos = infos.bAbscissaHasTrueAxisDtValues
|
|
|
|
|
|
? infos.abscissaPara->axisDtHighPosX() - dataRect.x()
|
|
|
|
|
|
: logWidth;
|
|
|
|
|
|
infos.abscissaDtStart = infos.bAbscissaHasTrueAxisDtValues
|
|
|
|
|
|
? infos.abscissaPara->trueAxisDtLow()
|
|
|
|
|
|
: TQDateTime();
|
|
|
|
|
|
infos.abscissaDtEnd = infos.bAbscissaHasTrueAxisDtValues
|
|
|
|
|
|
? infos.abscissaPara->trueAxisDtHigh()
|
|
|
|
|
|
: TQDateTime();
|
|
|
|
|
|
|
|
|
|
|
|
//Pending Michel case when same hh:mm:ss but different msecs
|
|
|
|
|
|
infos.bScaleLessThanDay = ( infos.bAbscissaHasTrueAxisDtValues
|
|
|
|
|
|
? infos.abscissaPara->trueAxisDtDeltaScale()
|
|
|
|
|
|
: KDChartAxisParams::ValueScaleDay )
|
|
|
|
|
|
< KDChartAxisParams::ValueScaleDay;
|
|
|
|
|
|
if ( infos.abscissaDtStart.time() == infos.abscissaDtEnd.time() && infos.bScaleLessThanDay )
|
|
|
|
|
|
infos.dtHighPos = logWidth;
|
|
|
|
|
|
|
|
|
|
|
|
// adjust the milli seconds:
|
|
|
|
|
|
infos.abscissaDtStart.setTime(
|
|
|
|
|
|
TQTime( infos.abscissaDtStart.time().hour(),
|
|
|
|
|
|
infos.abscissaDtStart.time().minute(),
|
|
|
|
|
|
infos.abscissaDtStart.time().second(),
|
|
|
|
|
|
0 ) );
|
|
|
|
|
|
infos.abscissaDtEnd.setTime(
|
|
|
|
|
|
TQTime( infos.abscissaDtEnd.time().hour(),
|
|
|
|
|
|
infos.abscissaDtEnd.time().minute(),
|
|
|
|
|
|
infos.abscissaDtEnd.time().second(),
|
|
|
|
|
|
999 ) );
|
|
|
|
|
|
//tqDebug( infos.abscissaPara->trueAxisDtLow().toString("yyyy-MM-dd-hh:mm:ss.zzz"));
|
|
|
|
|
|
//tqDebug( infos.abscissaPara->trueAxisDtHigh().toString("yyyy-MM-dd-hh:mm:ss.zzz"));
|
|
|
|
|
|
//tqDebug(infos.abscissaDtStart.toString("yyyy-MM-dd-hh:mm:ss.zzz"));
|
|
|
|
|
|
//tqDebug(infos.abscissaDtEnd.toString("yyyy-MM-dd-hh:mm:ss.zzz"));
|
|
|
|
|
|
/*
|
|
|
|
|
|
infos.bScaleLessThanDay = ( infos.bAbscissaHasTrueAxisDtValues
|
|
|
|
|
|
? infos.abscissaPara->trueAxisDtDeltaScale()
|
|
|
|
|
|
: KDChartAxisParams::ValueScaleDay )
|
|
|
|
|
|
< KDChartAxisParams::ValueScaleDay;
|
|
|
|
|
|
*/
|
|
|
|
|
|
if( infos.bAbscissaHasTrueAxisDtValues ){
|
|
|
|
|
|
if( infos.bScaleLessThanDay ){
|
|
|
|
|
|
infos.abscissaDtSpan = infos.abscissaDtStart.secsTo( infos.abscissaDtEnd );
|
|
|
|
|
|
|
|
|
|
|
|
/* NOTE: We do *not* add the milli seconds because they aren't covered
|
|
|
|
|
|
by the span indicated by infos.dtHighPos - infos.dtLowPos.
|
|
|
|
|
|
if( infos.abscissaDtStart.time().msec() || infos.abscissaDtEnd.time().msec() )
|
|
|
|
|
|
infos.abscissaDtSpan =
|
|
|
|
|
|
( infos.abscissaDtEnd.time().msec() -
|
|
|
|
|
|
infos.abscissaDtStart.time().msec() ) / 1000.0;
|
|
|
|
|
|
*/
|
|
|
|
|
|
}
|
|
|
|
|
|
else{
|
|
|
|
|
|
infos.abscissaDtSpan = infos.abscissaDtStart.daysTo( infos.abscissaDtEnd );
|
|
|
|
|
|
if( infos.abscissaDtStart.time().msec() || infos.abscissaDtEnd.time().msec() )
|
|
|
|
|
|
infos.abscissaDtSpan +=
|
|
|
|
|
|
( infos.abscissaDtEnd.time().msec() -
|
|
|
|
|
|
infos.abscissaDtStart.time().msec() ) / (86400.0 * 1000.0);
|
|
|
|
|
|
if( infos.abscissaDtEnd.time().second() )
|
|
|
|
|
|
infos.abscissaDtSpan += infos.abscissaDtEnd.time().second() / 86400.0;
|
|
|
|
|
|
if( infos.abscissaDtEnd.time().minute() )
|
|
|
|
|
|
infos.abscissaDtSpan += infos.abscissaDtEnd.time().minute() / 1440.0;
|
|
|
|
|
|
if( infos.abscissaDtEnd.time().hour() )
|
|
|
|
|
|
infos.abscissaDtSpan += infos.abscissaDtEnd.time().hour() / 24.0;
|
|
|
|
|
|
}
|
|
|
|
|
|
}else
|
|
|
|
|
|
infos.abscissaDtSpan = 10.0;
|
|
|
|
|
|
if( 0 == infos.abscissaDtSpan || 0.0 == infos.abscissaDtSpan )
|
|
|
|
|
|
infos.abscissaDtSpan = 1.0;
|
|
|
|
|
|
|
|
|
|
|
|
infos.abscissaDtPixelsPerScaleUnit = (infos.dtHighPos - infos.dtLowPos)/ infos.abscissaDtSpan;
|
|
|
|
|
|
|
|
|
|
|
|
if( infos.bAbscissaHasTrueAxisDtValues )
|
|
|
|
|
|
infos.abscissaDelta = 20.0;
|
|
|
|
|
|
|
|
|
|
|
|
infos.pointDist
|
|
|
|
|
|
= ( infos.abscissaPara && (0.0 != infos.abscissaPara->trueAxisDeltaPixels()) )
|
|
|
|
|
|
? infos.abscissaPara->trueAxisDeltaPixels()
|
|
|
|
|
|
: ( logWidth /
|
|
|
|
|
|
(
|
|
|
|
|
|
(1 > ((double)(infos.numLabels) - (infos.bCenterThePoints ? 0.0 : 1.0)))
|
|
|
|
|
|
? ((double)(infos.numLabels) - (infos.bCenterThePoints ? 0.0 : 1.0))
|
|
|
|
|
|
: 1 ) );
|
|
|
|
|
|
|
|
|
|
|
|
infos.abscissaPixelsPerUnit = ( 0.0 != infos.abscissaDelta )
|
|
|
|
|
|
? ( infos.pointDist / infos.abscissaDelta )
|
|
|
|
|
|
: infos.pointDist;
|
|
|
|
|
|
|
|
|
|
|
|
//const double infos.abscissaZeroPos2 = -1.0 * infos.abscissaPixelsPerUnit * infos.abscissaStart;
|
|
|
|
|
|
infos.abscissaZeroPos = infos.abscissaPara->axisZeroLineStartX() - dataRect.x();
|
|
|
|
|
|
//tqDebug("abscissaZeroPos %f abscissaZeroPos2 %f",abscissaZeroPos,abscissaZeroPos2);
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
|
tqDebug(abscissaPara ?
|
|
|
|
|
|
"\nabscissaPara: OK" :
|
|
|
|
|
|
"\nabscissaPara: leer");
|
|
|
|
|
|
tqDebug(abscissaHasTrueAxisValues ?
|
|
|
|
|
|
"abscissaHasTrueAxisValues: TRUE" :
|
|
|
|
|
|
"abscissaHasTrueAxisValues: FALSE");
|
|
|
|
|
|
tqDebug("abscissaStart: %f", abscissaStart);
|
|
|
|
|
|
tqDebug("abscissaEnd : %f", abscissaEnd);
|
|
|
|
|
|
tqDebug("abscissaPara->trueAxisDelta(): %f", abscissaPara->trueAxisDelta());
|
|
|
|
|
|
tqDebug("numValues : %u, numLabels : %u", numValues, numLabels);
|
|
|
|
|
|
*/
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
bool KDChartAxesPainter::calculateAbscissaAxisValue( const TQVariant& value,
|
|
|
|
|
|
abscissaInfos& ai,
|
|
|
|
|
|
int colNumber,
|
|
|
|
|
|
double& xValue )
|
|
|
|
|
|
{
|
|
|
|
|
|
if( ai.bCellsHaveSeveralCoordinates ) {
|
|
|
|
|
|
if( TQVariant::Double == value.type() ) {
|
|
|
|
|
|
double dVal = value.toDouble();
|
|
|
|
|
|
if( ai.bAbscissaIsLogarithmic ){
|
|
|
|
|
|
if( 0.0 < dVal )
|
|
|
|
|
|
xValue = ai.abscissaPixelsPerUnit * log10( dVal );
|
|
|
|
|
|
else
|
|
|
|
|
|
xValue = -10250.0;
|
|
|
|
|
|
}else{
|
|
|
|
|
|
xValue = ai.abscissaPixelsPerUnit * dVal;
|
|
|
|
|
|
}
|
|
|
|
|
|
xValue *= ai.bAbscissaDecreasing ? -1.0 : 1.0;
|
|
|
|
|
|
xValue += ai.abscissaZeroPos;
|
|
|
|
|
|
}
|
|
|
|
|
|
else if( ai.bAbscissaHasTrueAxisDtValues &&
|
|
|
|
|
|
TQVariant::DateTime == value.type() ) {
|
|
|
|
|
|
const TQDateTime dtVal = value.toDateTime();
|
|
|
|
|
|
double dT = ( ai.bScaleLessThanDay )
|
|
|
|
|
|
? ai.abscissaDtStart.secsTo( dtVal )
|
|
|
|
|
|
: ai.abscissaDtStart.daysTo( dtVal );
|
|
|
|
|
|
/*
|
|
|
|
|
|
tqDebug("abscissaDtStart: %i %i %i %i:%i:%i.%i",
|
|
|
|
|
|
ai.abscissaDtStart.date().year(),
|
|
|
|
|
|
ai.abscissaDtStart.date().month(),
|
|
|
|
|
|
ai.abscissaDtStart.date().day(),
|
|
|
|
|
|
ai.abscissaDtStart.time().hour(),
|
|
|
|
|
|
ai.abscissaDtStart.time().minute(),
|
|
|
|
|
|
ai.abscissaDtStart.time().second(),
|
|
|
|
|
|
ai.abscissaDtStart.time().msec());
|
|
|
|
|
|
*/
|
|
|
|
|
|
//tqDebug("days to = %f",dT);
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
|
tqDebug(" dtVal: %i %i %i %i:%i:%i.%i",
|
|
|
|
|
|
dtVal.date().year(),
|
|
|
|
|
|
dtVal.date().month(),
|
|
|
|
|
|
dtVal.date().day(),
|
|
|
|
|
|
dtVal.time().hour(),
|
|
|
|
|
|
dtVal.time().minute(),
|
|
|
|
|
|
dtVal.time().second(),
|
|
|
|
|
|
dtVal.time().msec());
|
|
|
|
|
|
*/
|
|
|
|
|
|
xValue = ai.abscissaDtPixelsPerScaleUnit * dT;
|
|
|
|
|
|
if( dtVal.time().msec() )
|
|
|
|
|
|
xValue += (ai.abscissaDtPixelsPerScaleUnit * dtVal.time().msec())
|
|
|
|
|
|
/ ( ai.bScaleLessThanDay
|
|
|
|
|
|
? 1000.0
|
|
|
|
|
|
: (1000.0 * 86400.0) );
|
|
|
|
|
|
//tqDebug("xValue: %f",xValue);
|
|
|
|
|
|
if( !ai.bScaleLessThanDay ){
|
|
|
|
|
|
if( dtVal.time().second() )
|
|
|
|
|
|
xValue += (ai.abscissaDtPixelsPerScaleUnit * dtVal.time().second())
|
|
|
|
|
|
/ 86400.0;
|
|
|
|
|
|
if( dtVal.time().minute() )
|
|
|
|
|
|
xValue += (ai.abscissaDtPixelsPerScaleUnit * dtVal.time().minute())
|
|
|
|
|
|
/ 1440.0;
|
|
|
|
|
|
if( dtVal.time().hour() )
|
|
|
|
|
|
xValue += (ai.abscissaDtPixelsPerScaleUnit * dtVal.time().hour())
|
|
|
|
|
|
/ 24.0;
|
|
|
|
|
|
}
|
|
|
|
|
|
xValue *= ai.bAbscissaDecreasing ? -1.0 : 1.0;
|
|
|
|
|
|
xValue += ai.dtLowPos;
|
|
|
|
|
|
// tqDebug("xValue = dtLowPos + abscissaDtPixelsPerScaleUnit * dT\n%f = %f + %f * %f",
|
|
|
|
|
|
// xValue, dtLowPos, abscissaDtPixelsPerScaleUnit, dT);
|
|
|
|
|
|
}
|
|
|
|
|
|
else
|
|
|
|
|
|
return false;
|
|
|
|
|
|
} else
|
|
|
|
|
|
xValue = ai.pointDist * ( double ) colNumber;
|
|
|
|
|
|
return true;
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*************************************************************************/
|
|
|
|
|
|
/*************************************************************************/
|
|
|
|
|
|
/*************************************************************************/
|
|
|
|
|
|
/*** ***/
|
|
|
|
|
|
/*** Framework for data drawing using cartesian axes (Bar, Line, ...) ***/
|
|
|
|
|
|
/*** ***/
|
|
|
|
|
|
/*************************************************************************/
|
|
|
|
|
|
/*************************************************************************/
|
|
|
|
|
|
/*************************************************************************/
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
|
Paints the actual data area and registers the region for the data
|
|
|
|
|
|
points if \a regions is not 0.
|
|
|
|
|
|
|
|
|
|
|
|
\param painter the TQPainter onto which the chart should be painted
|
|
|
|
|
|
\param data the data that will be displayed as a chart
|
|
|
|
|
|
\param paint2nd specifies whether the main chart or the additional chart is to be drawn now
|
|
|
|
|
|
\param regions a pointer to a list of regions that will be filled
|
|
|
|
|
|
with regions representing the data segments, if not null
|
|
|
|
|
|
*/
|
|
|
|
|
|
void KDChartAxesPainter::paintData( TQPainter* painter,
|
|
|
|
|
|
KDChartTableDataBase* data,
|
|
|
|
|
|
bool paint2nd,
|
|
|
|
|
|
KDChartDataRegionList* regions )
|
|
|
|
|
|
{
|
|
|
|
|
|
bool bNormalMode = isNormalMode();
|
|
|
|
|
|
|
|
|
|
|
|
uint chart = paint2nd ? 1 : 0;
|
|
|
|
|
|
|
|
|
|
|
|
// find out the ordinate axis (or axes, resp.) belonging to this chart
|
|
|
|
|
|
// (up to 4 ordinates might be in use: 2 left ones and 2 right ones)
|
|
|
|
|
|
uint axesCount;
|
|
|
|
|
|
KDChartParams::AxesArray ordinateAxes;
|
|
|
|
|
|
ordinateAxes.resize( KDCHART_CNT_ORDINATES );
|
|
|
|
|
|
if( !params()->chartAxes( chart, axesCount, ordinateAxes ) ) {
|
|
|
|
|
|
// no axis - no fun!
|
|
|
|
|
|
return;
|
|
|
|
|
|
// We cannot draw data without an axis having calculated high/low
|
|
|
|
|
|
// values and position of the zero line before.
|
|
|
|
|
|
|
|
|
|
|
|
// PENDING(khz) Allow drawing without having a visible axis!
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
//const KDChartParams::ChartType params_chartType
|
|
|
|
|
|
// = paint2nd ? params()->additionalChartType() : params()->chartType();
|
|
|
|
|
|
|
|
|
|
|
|
double logWidth = _dataRect.width();
|
|
|
|
|
|
double areaWidthP1000 = logWidth / 1000.0;
|
|
|
|
|
|
|
|
|
|
|
|
int nClipShiftUp = clipShiftUp(bNormalMode, areaWidthP1000);
|
|
|
|
|
|
TQRect ourClipRect( _dataRect );
|
|
|
|
|
|
if ( 0 < ourClipRect.top() ) {
|
|
|
|
|
|
ourClipRect.setTop( ourClipRect.top() - nClipShiftUp );
|
|
|
|
|
|
ourClipRect.setHeight( ourClipRect.height() + nClipShiftUp - 1 );
|
|
|
|
|
|
} else
|
|
|
|
|
|
ourClipRect.setHeight( ourClipRect.height() + nClipShiftUp / 2 - 1 );
|
|
|
|
|
|
|
|
|
|
|
|
// protect axes ?
|
|
|
|
|
|
//ourClipRect.setBottom( ourClipRect.bottom() - 1 );
|
|
|
|
|
|
//ourClipRect.setLeft( ourClipRect.left() + 1 );
|
|
|
|
|
|
//ourClipRect.setRight( ourClipRect.right() - 1 );
|
|
|
|
|
|
|
|
|
|
|
|
const TQWMatrix & world = painter->worldMatrix();
|
|
|
|
|
|
ourClipRect = world.mapRect( ourClipRect );
|
|
|
|
|
|
painter->setClipRect( ourClipRect );
|
|
|
|
|
|
painter->translate( _dataRect.x(), _dataRect.y() );
|
|
|
|
|
|
|
|
|
|
|
|
painter->setPen( params()->outlineDataColor() );
|
|
|
|
|
|
|
|
|
|
|
|
// find out which datasets are to be represented by this chart
|
|
|
|
|
|
uint chartDatasetStart, chartDatasetEnd;
|
|
|
|
|
|
findChartDatasets( data, paint2nd, chart, chartDatasetStart, chartDatasetEnd );
|
|
|
|
|
|
|
|
|
|
|
|
// Note: 'aI' is *not* the axis number!
|
|
|
|
|
|
for( uint aI = 0; aI < axesCount; ++aI ) {
|
|
|
|
|
|
// 'axis' is the REAL axis number!
|
|
|
|
|
|
uint axis = ordinateAxes.at( aI );
|
|
|
|
|
|
|
|
|
|
|
|
const KDChartAxisParams* axisPara = ¶ms()->axisParams( axis );
|
|
|
|
|
|
|
|
|
|
|
|
uint datasetStart, datasetEnd;
|
|
|
|
|
|
uint axisDatasetStart, axisDatasetEnd;
|
|
|
|
|
|
uint dummy;
|
|
|
|
|
|
if( params()->axisDatasets( axis,
|
|
|
|
|
|
axisDatasetStart,
|
|
|
|
|
|
axisDatasetEnd, dummy )
|
|
|
|
|
|
&& ( KDCHART_ALL_DATASETS != axisDatasetStart ) ) {
|
|
|
|
|
|
|
|
|
|
|
|
if( KDCHART_NO_DATASET == axisDatasetStart ){
|
|
|
|
|
|
//==========
|
|
|
|
|
|
continue; // NO DATASETS --> STOP PROCESSING THIS AXIS
|
|
|
|
|
|
//==========
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
if( axisDatasetStart >= chartDatasetStart
|
|
|
|
|
|
&& axisDatasetStart <= chartDatasetEnd )
|
|
|
|
|
|
datasetStart = TQMAX( axisDatasetStart, chartDatasetStart );
|
|
|
|
|
|
else if( axisDatasetStart <= chartDatasetStart
|
|
|
|
|
|
&& axisDatasetEnd >= chartDatasetStart )
|
|
|
|
|
|
datasetStart = chartDatasetStart;
|
|
|
|
|
|
else
|
|
|
|
|
|
datasetStart = 20;
|
|
|
|
|
|
if( axisDatasetEnd >= chartDatasetStart
|
|
|
|
|
|
&& axisDatasetEnd <= chartDatasetEnd )
|
|
|
|
|
|
datasetEnd = TQMIN( axisDatasetEnd, chartDatasetEnd );
|
|
|
|
|
|
else if( axisDatasetEnd >= chartDatasetEnd
|
|
|
|
|
|
&& axisDatasetStart <= chartDatasetEnd )
|
|
|
|
|
|
datasetEnd = chartDatasetEnd;
|
|
|
|
|
|
else
|
|
|
|
|
|
datasetEnd = 0;
|
|
|
|
|
|
} else {
|
|
|
|
|
|
datasetStart = chartDatasetStart;
|
|
|
|
|
|
datasetEnd = chartDatasetEnd;
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
//tqDebug("\n=========================================================="
|
|
|
|
|
|
// "\naxis %u axisDatasetStart %u axisDatasetEnd %u / chartDatasetStart %u chartDatasetEnd %u",
|
|
|
|
|
|
//axis, axisDatasetStart, axisDatasetEnd, chartDatasetStart, chartDatasetEnd );
|
|
|
|
|
|
|
|
|
|
|
|
double logHeight = axisPara->axisTrueAreaRect().height();
|
|
|
|
|
|
double axisYOffset = axisPara->axisTrueAreaRect().y() - _dataRect.y();
|
|
|
|
|
|
|
|
|
|
|
|
//tqDebug("\n==========================================================\naxis %u logHeight %f axisDatasetStart %u chartDatasetStart %u axisDatasetEnd %u chartDatasetEnd %u",
|
|
|
|
|
|
//axis, logHeight, axisDatasetStart, chartDatasetStart, axisDatasetEnd, chartDatasetEnd );
|
|
|
|
|
|
//if( KDCHART_ALL_DATASETS == axisDatasetStart )
|
|
|
|
|
|
// tqDebug(" ALL DATASETS");
|
|
|
|
|
|
//if( KDCHART_NO_DATASET == axisDatasetStart )
|
|
|
|
|
|
// tqDebug(" N O DATESETS");
|
|
|
|
|
|
|
|
|
|
|
|
double maxColumnValue = axisPara->trueAxisHigh();
|
|
|
|
|
|
double minColumnValue = axisPara->trueAxisLow();
|
|
|
|
|
|
double columnValueDistance = maxColumnValue - minColumnValue;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// call the chart type specific data painter:
|
|
|
|
|
|
specificPaintData( painter,
|
|
|
|
|
|
ourClipRect,
|
|
|
|
|
|
data,
|
|
|
|
|
|
regions,
|
|
|
|
|
|
axisPara,
|
|
|
|
|
|
bNormalMode,
|
|
|
|
|
|
chart,
|
|
|
|
|
|
logWidth,
|
|
|
|
|
|
areaWidthP1000,
|
|
|
|
|
|
logHeight,
|
|
|
|
|
|
axisYOffset,
|
|
|
|
|
|
minColumnValue,
|
|
|
|
|
|
maxColumnValue,
|
|
|
|
|
|
columnValueDistance,
|
|
|
|
|
|
chartDatasetStart,
|
|
|
|
|
|
chartDatasetEnd,
|
|
|
|
|
|
datasetStart,
|
|
|
|
|
|
datasetEnd );
|
|
|
|
|
|
}
|
|
|
|
|
|
painter->translate( - _dataRect.x(), - _dataRect.y() );
|
|
|
|
|
|
}
|
