You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
koffice/kchart/kdchart/KDChartPolarPainter.cpp

806 lines
35 KiB

/* -*- Mode: C++ -*-
KDChart - a multi-platform charting engine
*/
/****************************************************************************
** Copyright (C) 2001-2003 Klarälvdalens Datakonsult AB. All rights reserved.
**
** This file is part of the KDChart library.
**
** This file may be distributed and/or modified under the terms of the
** GNU General Public License version 2 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file.
**
** Licensees holding valid commercial KDChart licenses may use this file in
** accordance with the KDChart Commercial License Agreement provided with
** the Software.
**
** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
**
** See http://www.klaralvdalens-datakonsult.se/?page=products for
** information about KDChart Commercial License Agreements.
**
** Contact info@klaralvdalens-datakonsult.se if any conditions of this
** licensing are not clear to you.
**
**********************************************************************/
#include "KDChartPolarPainter.h"
#include <KDChartParams.h>
#include <KDChartAxisParams.h>
#include "KDChartAxesPainter.h"
#include "KDDrawText.h"
#include <tqpainter.h>
/**
\class KDChartPolarPainter KDChartPolarPainter.h
\brief A chart painter implementation that can paint polar charts.
*/
/**
Constructor. Sets up internal data structures as necessary.
\param params the KDChartParams structure that defines the chart
\param data the data that will be displayed as a chart
*/
KDChartPolarPainter::KDChartPolarPainter( KDChartParams* params ) :
KDChartPainter( params )
{
// This constructor intentionally left blank so far; we cannot setup the
// geometry yet since we do not know the size of the painter.
}
/**
Destructor.
*/
KDChartPolarPainter::~KDChartPolarPainter()
{
// intentionally left blank
}
/**
Paints the actual data area. Data regions will only be added if \a
regions is not 0 and the chart is configured to be drawn with
markers.
\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 KDChartPolarPainter::paintData( TQPainter* painter,
KDChartTableDataBase* data,
bool paint2nd,
KDChartDataRegionList* regions )
{
uint chart = paint2nd ? 1 : 0;
TQRect ourClipRect( _dataRect );
ourClipRect.setBottom( ourClipRect.bottom() - 1 ); // protect axes
ourClipRect.setLeft( ourClipRect.left() + 1 );
ourClipRect.setRight( ourClipRect.right() - 1 );
//
// PENDING(khz) adjust the clip rect if neccessary...
//
const TQWMatrix & world = painter->worldMatrix();
ourClipRect =
#if COMPAT_TQT_VERSION >= 0x030000
world.mapRect( ourClipRect );
#else
world.map( ourClipRect );
#endif
painter->setClipRect( ourClipRect );
uint datasetStart, datasetEnd;
findChartDatasets( data, paint2nd, chart, datasetStart, datasetEnd );
painter->translate( _dataRect.x(), _dataRect.y() );
// Number of values: If -1, use all values, otherwise use the
// specified number of values.
int numValues = 0;
if ( params()->numValues() != -1 )
numValues = params()->numValues();
else
numValues = data->usedCols();
// compute position
int size = TQMIN( _dataRect.width(), _dataRect.height() ); // initial size
const double minSizeP1000 = size / 1000.0;
int x = ( _dataRect.width() == size ) ? 0 : ( ( _dataRect.width() - size ) / 2 );
int y = ( _dataRect.height() == size ) ? 0 : ( ( _dataRect.height() - size ) / 2 );
TQRect position( x, y, size, size );
TQPoint center( position.width() / 2 + position.x(),
position.height() / 2 + position.y() );
double maxValue;
switch ( params()->polarChartSubType() ) {
case KDChartParams::PolarNormal:
maxValue = data->maxValue();
break;
case KDChartParams::PolarPercent:
maxValue = 100.0;
break;
default:
maxValue = TQMAX( data->maxColSum(), 0.0 );
}
double pixelsPerUnit = 0.0;
// the / 2 in the next line is there because we need the space in
// both directions
pixelsPerUnit = (position.height() / maxValue / 2) * 1000 / 1250;
TQMap < int, double > currentValueSums;
if ( params()->polarChartSubType() == KDChartParams::PolarStacked
|| params()->polarChartSubType() == KDChartParams::PolarPercent )
// this array is only used for stacked and percent polar
// charts, no need to waste time initializing it for normal
// ones
for ( int value = 0; value < numValues; value++ )
currentValueSums[ value ] = 0.0;
TQMap < int, double > totalValueSums;
/*
axes schema: use AxisPosSagittal for sagittal 'axis' lines
use AxisPosCircular for circular 'axis'
*/
const KDChartAxisParams & paraSagittal = params()->axisParams( KDChartAxisParams::AxisPosSagittal );
const KDChartAxisParams & paraCircular = params()->axisParams( KDChartAxisParams::AxisPosCircular );
int sagittalLineWidth = 0 <= paraSagittal.axisLineWidth()
? paraSagittal.axisLineWidth()
: -1 * static_cast < int > ( paraSagittal.axisLineWidth()
* minSizeP1000 );
( ( KDChartAxisParams& ) paraSagittal ).setAxisTrueLineWidth( sagittalLineWidth );
int sagittalGridLineWidth
= ( KDCHART_AXIS_GRID_AUTO_LINEWIDTH
== paraSagittal.axisGridLineWidth() )
? sagittalLineWidth
: ( ( 0 <= paraSagittal.axisGridLineWidth() )
? paraSagittal.axisGridLineWidth()
: -1 * static_cast < int > ( paraSagittal.axisGridLineWidth()
* minSizeP1000 ) );
int circularLineWidth = 0 <= paraCircular.axisLineWidth()
? paraCircular.axisLineWidth()
: -1 * static_cast < int > ( paraCircular.axisLineWidth()
* minSizeP1000 );
( ( KDChartAxisParams& ) paraCircular ).setAxisTrueLineWidth( circularLineWidth );
int circularGridLineWidth
= ( KDCHART_AXIS_GRID_AUTO_LINEWIDTH
== paraCircular.axisGridLineWidth() )
? circularLineWidth
: ( ( 0 <= paraCircular.axisGridLineWidth() )
? paraCircular.axisGridLineWidth()
: -1 * static_cast < int > ( paraCircular.axisGridLineWidth()
* minSizeP1000 ) );
TQFont actFont;
int labels = 0;
double currentRadiusPPU = position.height() / 2.0;
// draw the "axis" circles
if( paraCircular.axisShowGrid()
|| paraCircular.axisVisible()
|| paraCircular.axisLabelsVisible() ) {
double radiusPPU = maxValue * pixelsPerUnit;
double pDelimDelta = 0.0;
// calculate label texts
TQStringList* labelTexts = 0;
((KDChartParams*)params())->setAxisArea( KDChartAxisParams::AxisPosCircular,
TQRect( 0,
0,
static_cast<int>( radiusPPU ),
static_cast<int>( radiusPPU ) ) );
double delimLen = 20.0 * minSizeP1000; // per mille of area
KDChartAxisParams::AxisPos basicPos;
TQPoint orig, dest;
double dDummy;
double nSubDelimFactor = 0.0;
double nTxtHeight = 0.0;
double pTextsX = 0.0;
double pTextsY = 0.0;
double pTextsW = 0.0;
double pTextsH = 0.0;
int textAlign = TQt::AlignHCenter | TQt::AlignVCenter;
bool isLogarithmic = false;
bool isDateTime = false;
bool autoDtLabels = false;
TQDateTime dtLow;
TQDateTime dtHigh;
KDChartAxisParams::ValueScale dtDeltaScale;
KDChartAxesPainter::calculateLabelTexts(
painter,
*data,
*params(),
KDChartAxisParams::AxisPosCircular,
minSizeP1000,
delimLen,
// start of reference parameters
basicPos,
orig,
dest,
dDummy,dDummy,dDummy,dDummy,
nSubDelimFactor,
pDelimDelta,
nTxtHeight,
pTextsX,
pTextsY,
pTextsW,
pTextsH,
textAlign,
isLogarithmic,
isDateTime,
autoDtLabels,
dtLow,
dtHigh,
dtDeltaScale );
labelTexts = ( TQStringList* ) paraCircular.axisLabelTexts();
if( paraCircular.axisLabelsVisible() ) {
//tqDebug("\nnTxtHeight: "+TQString::number(nTxtHeight));
// calculate font size
actFont = paraCircular.axisLabelsFont();
if ( paraCircular.axisLabelsFontUseRelSize() ) {
//tqDebug("paraCircular.axisLabelsFontUseRelSize() is TRUE");
actFont.setPointSizeFloat( nTxtHeight );
}
TQFontMetrics fm( actFont );
TQString strMax;
int maxLabelsWidth = 0;
for ( TQStringList::Iterator it = labelTexts->begin();
it != labelTexts->end();
++it ) {
if ( fm.width( *it ) > maxLabelsWidth ) {
maxLabelsWidth = fm.width( *it );
strMax = *it;
}
}
while ( fm.width( strMax ) > pTextsW
&& 6.0 < nTxtHeight ) {
nTxtHeight -= 0.5;
actFont.setPointSizeFloat( nTxtHeight );
fm = TQFontMetrics( actFont );
}
painter->setFont( actFont );
}
double radiusDelta = pDelimDelta;
labels = labelTexts
? labelTexts->count()
: 0;
if( labels )
currentRadiusPPU = -radiusDelta;
for( int iLabel = 0; iLabel < labels; ++iLabel ) {
//while( currentRadius < maxValue ) {
//double currentRadiusPPU = currentRadius;
currentRadiusPPU += radiusDelta;
double currentRadiusPPU2 = currentRadiusPPU * 2;
int circularAxisAngle = ( currentRadiusPPU != 0.0 ) ? ( static_cast < int > (4.0 * radiusPPU / currentRadiusPPU) ) : 0;
if( paraCircular.axisShowGrid() ) {
painter->setPen( TQPen( paraCircular.axisGridColor(),
circularGridLineWidth ) );
painter->drawEllipse( static_cast<int>( center.x() - currentRadiusPPU ),
static_cast<int>( center.y() - currentRadiusPPU ),
static_cast<int>( currentRadiusPPU2 ), static_cast<int>( currentRadiusPPU2 ) );
}
if( paraCircular.axisVisible() ) {
painter->setPen( TQPen( paraCircular.axisLineColor(),
circularLineWidth ) );
if( params()->polarDelimAtPos( KDChartEnums::PosTopCenter ) )
painter->drawArc( static_cast<int>( center.x() - currentRadiusPPU ),
static_cast<int>( center.y() - currentRadiusPPU ),
static_cast<int>( currentRadiusPPU2 ), static_cast<int>( currentRadiusPPU2 ),
(90 - circularAxisAngle/2) * 16,
circularAxisAngle * 16 );
if( params()->polarDelimAtPos( KDChartEnums::PosBottomCenter ) )
painter->drawArc( static_cast<int>( center.x() - currentRadiusPPU ),
static_cast<int>( center.y() - currentRadiusPPU ),
static_cast<int>( currentRadiusPPU2 ), static_cast<int>( currentRadiusPPU2 ),
(270 - circularAxisAngle/2) * 16,
circularAxisAngle * 16 );
if( params()->polarDelimAtPos( KDChartEnums::PosCenterRight ) )
painter->drawArc( static_cast<int>( center.x() - currentRadiusPPU ),
static_cast<int>( center.y() - currentRadiusPPU ),
static_cast<int>( currentRadiusPPU2 ), static_cast<int>( currentRadiusPPU2 ),
(0 - circularAxisAngle/2) * 16,
circularAxisAngle * 16 );
if( params()->polarDelimAtPos( KDChartEnums::PosCenterLeft ) )
painter->drawArc( static_cast<int>( center.x() - currentRadiusPPU ),
static_cast<int>( center.y() - currentRadiusPPU ),
static_cast<int>( currentRadiusPPU2 ), static_cast<int>( currentRadiusPPU2 ),
(180 - circularAxisAngle/2) * 16,
circularAxisAngle * 16 );
if( params()->polarDelimAtPos( KDChartEnums::PosTopRight ) )
painter->drawArc( static_cast<int>( center.x() - currentRadiusPPU ),
static_cast<int>( center.y() - currentRadiusPPU ),
static_cast<int>( currentRadiusPPU2 ), static_cast<int>( currentRadiusPPU2 ),
(45 - circularAxisAngle/2) * 16,
circularAxisAngle * 16 );
if( params()->polarDelimAtPos( KDChartEnums::PosBottomLeft ) )
painter->drawArc( static_cast<int>( center.x() - currentRadiusPPU ),
static_cast<int>( center.y() - currentRadiusPPU ),
static_cast<int>( currentRadiusPPU2 ), static_cast<int>( currentRadiusPPU2 ),
(225 - circularAxisAngle/2) * 16,
circularAxisAngle * 16 );
if( params()->polarDelimAtPos( KDChartEnums::PosBottomRight ) )
painter->drawArc( static_cast<int>( center.x() - currentRadiusPPU ),
static_cast<int>( center.y() - currentRadiusPPU ),
static_cast<int>( currentRadiusPPU2 ), static_cast<int>( currentRadiusPPU2 ),
(315 - circularAxisAngle/2) * 16,
circularAxisAngle * 16 );
if( params()->polarDelimAtPos( KDChartEnums::PosTopLeft ) )
painter->drawArc( static_cast<int>( center.x() - currentRadiusPPU ),
static_cast<int>( center.y() - currentRadiusPPU ),
static_cast<int>( currentRadiusPPU2 ), static_cast<int>( currentRadiusPPU2 ),
(135 - circularAxisAngle/2) * 16,
circularAxisAngle * 16 );
}
if( paraCircular.axisLabelsVisible() ) {
const bool rotate = params()->polarRotateCircularLabels();
painter->setPen( TQPen( paraCircular.axisLabelsColor(),
circularLineWidth ) );
const TQString& txt = (*labelTexts)[ iLabel ];
if( params()->polarLabelsAtPos( KDChartEnums::PosTopCenter ) )
paintCircularAxisLabel( painter, rotate, 90, center, currentRadiusPPU, txt,
TQt::AlignBottom | TQt::AlignHCenter, iLabel );
if( params()->polarLabelsAtPos( KDChartEnums::PosBottomCenter ) )
paintCircularAxisLabel( painter, rotate, 270, center, currentRadiusPPU, txt,
TQt::AlignTop | TQt::AlignHCenter, iLabel );
if( params()->polarLabelsAtPos( KDChartEnums::PosCenterRight ) )
paintCircularAxisLabel( painter, rotate, 0, center, currentRadiusPPU, txt,
TQt::AlignVCenter | TQt::AlignRight, iLabel );
if( params()->polarLabelsAtPos( KDChartEnums::PosCenterLeft ) )
paintCircularAxisLabel( painter, rotate, 180, center, currentRadiusPPU, txt,
TQt::AlignVCenter | TQt::AlignLeft, iLabel );
if( params()->polarLabelsAtPos( KDChartEnums::PosTopRight ) )
paintCircularAxisLabel( painter, rotate, 45, center, currentRadiusPPU, txt,
TQt::AlignBottom | TQt::AlignRight, iLabel );
if( params()->polarLabelsAtPos( KDChartEnums::PosBottomLeft ) )
paintCircularAxisLabel( painter, rotate, 225, center, currentRadiusPPU, txt,
TQt::AlignTop | TQt::AlignLeft, iLabel );
if( params()->polarLabelsAtPos( KDChartEnums::PosBottomRight ) )
paintCircularAxisLabel( painter, rotate, 315, center, currentRadiusPPU, txt,
TQt::AlignTop | TQt::AlignRight, iLabel );
if( params()->polarLabelsAtPos( KDChartEnums::PosTopLeft ) )
paintCircularAxisLabel( painter, rotate, 135, center, currentRadiusPPU, txt,
TQt::AlignBottom | TQt::AlignLeft, iLabel );
}
}
}
double circularSpan = params()->polarChartSubType() == KDChartParams::PolarPercent
? 100.0
: paraCircular.trueAxisHigh() - paraCircular.trueAxisLow();
double radius = currentRadiusPPU;
if( !labels
|| params()->polarChartSubType() == KDChartParams::PolarPercent )
radius = (position.width() / 2.0) * 1000.0 / 1250.0;
if( params()->polarChartSubType() != KDChartParams::PolarPercent )
pixelsPerUnit = labels ? currentRadiusPPU / circularSpan
: (position.height() / maxValue / 2.0) * 1000.0 / 1250.0;
else
pixelsPerUnit = (position.height() / 100.0 / 2.0) * 1000.0 / 1250.0;
// draw the sagittal grid and axis lines
if( paraSagittal.axisShowGrid()
|| paraSagittal.axisVisible()
|| paraSagittal.axisLabelsVisible() ) {
// calculate label texts
TQStringList* labelTexts = 0;
bool onlyDefaultLabels = true;
if( paraSagittal.axisLabelsVisible() ) {
((KDChartParams*)params())->setAxisArea( KDChartAxisParams::AxisPosSagittal,
TQRect( 0,
0,
static_cast < int > ( 2.0 * M_PI * radius ),
static_cast < int > ( 0.5 * radius ) ) );
double delimLen = 20.0 * minSizeP1000; // per mille of area
KDChartAxisParams::AxisPos basicPos;
TQPoint orig, dest;
double dDummy;
double nSubDelimFactor = 0.0;
double pDelimDelta = 0.0;
double nTxtHeight = 0.0;
double pTextsX = 0.0;
double pTextsY = 0.0;
double pTextsW = 0.0;
double pTextsH = 0.0;
int textAlign = TQt::AlignCenter;
bool isLogarithmic = false;
bool isDateTime = false;
bool autoDtLabels = false;
TQDateTime dtLow;
TQDateTime dtHigh;
KDChartAxisParams::ValueScale dtDeltaScale;
KDChartAxesPainter::calculateLabelTexts(
painter,
*data,
*params(),
KDChartAxisParams::AxisPosSagittal,
minSizeP1000,
delimLen,
// start of reference parameters
basicPos,
orig,
dest,
dDummy,dDummy,dDummy,dDummy,
nSubDelimFactor,
pDelimDelta,
nTxtHeight,
pTextsX,
pTextsY,
pTextsW,
pTextsH,
textAlign,
isLogarithmic,
isDateTime,
autoDtLabels,
dtLow,
dtHigh,
dtDeltaScale );
labelTexts = ( TQStringList* ) paraSagittal.axisLabelTexts();
// calculate font size
actFont = paraSagittal.axisLabelsFont();
if ( paraSagittal.axisLabelsFontUseRelSize() ) {
actFont.setPointSizeFloat( nTxtHeight );
}
TQFontMetrics fm( actFont );
TQString strMax;
int maxLabelsWidth = 0;
for ( TQStringList::Iterator it = labelTexts->begin();
it != labelTexts->end();
++it ) {
if ( fm.width( *it ) > maxLabelsWidth ) {
maxLabelsWidth = fm.width( *it );
strMax = *it;
}
if ( !(*it).startsWith( "Item ") )
onlyDefaultLabels = false;
}
while ( fm.width( strMax ) > pTextsW && 6.0 < nTxtHeight ) {
nTxtHeight -= 0.5;
actFont.setPointSizeFloat( nTxtHeight );
fm = TQFontMetrics( actFont );
}
painter->setFont( actFont );
}
int currentAngle = params()->polarZeroDegreePos();
if( -360 > currentAngle
|| 360 < currentAngle )
currentAngle = 0;
if( 0 > currentAngle )
currentAngle += 360;
int r1 = static_cast < int > ( radius * 1050 / 1000 );
int r2 = static_cast < int > ( radius * 1100 / 1000 );
int r3 = static_cast < int > ( radius * 1175 / 1000 );
TQPoint pt1, pt2, pt3;
uint nLabels = labelTexts->count();
int angleBetweenRays = 360 / nLabels;
for( uint value = 0; value < nLabels; ++value ) {
pt1 = center + polarToXY( r1, currentAngle );
pt2 = center + polarToXY( r2, currentAngle );
pt3 = center + polarToXY( r3, currentAngle );
//pt3 = painter->worldMatrix().map( pt3 );
if( paraSagittal.axisShowGrid() ) {
painter->setPen( TQPen( paraSagittal.axisGridColor(),
sagittalGridLineWidth ) );
painter->drawLine( center, pt1 );
}
if( paraSagittal.axisVisible() ) {
painter->setPen( TQPen( paraSagittal.axisLineColor(),
sagittalLineWidth ) );
painter->drawLine( pt1, pt2 );
}
if( paraSagittal.axisLabelsVisible()
&& labelTexts
&& labelTexts->count() > value ) {
painter->setPen( TQPen( paraSagittal.axisLabelsColor(),
sagittalLineWidth ) );
TQString label( onlyDefaultLabels
? TQString::number( currentAngle )
: (*labelTexts)[ value ] );
KDDrawText::drawRotatedText( painter,
currentAngle+90,
painter->worldMatrix().map(pt3),
label,
0,
TQt::AlignCenter );
}
currentAngle += angleBetweenRays;
}
}
// Now draw the data
int dataLinesWidth = 0 <= params()->polarLineWidth()
? params()->polarLineWidth()
: -1 * static_cast < int > ( params()->polarLineWidth()
* minSizeP1000 );
painter->setBrush( TQt::NoBrush );
for ( unsigned int dataset = datasetStart; dataset <= datasetEnd; dataset++ ) {
painter->setPen( TQPen( params()->dataColor( dataset ),
dataLinesWidth ) );
TQPointArray points( numValues );
int totalPoints = 0;
double valueTotal = 0.0; // Will only be used for Percent
int angleBetweenRays = 360 / numValues;
TQVariant vValY;
for ( int value = 0; value < numValues; value++ ) {
if( params()->polarChartSubType() == KDChartParams::PolarPercent )
valueTotal = data->colAbsSum( value );
// the value determines the angle, the dataset only the color
if( data->cellCoord( dataset, value, vValY, 1 ) &&
TQVariant::Double == vValY.type() ){
const double cellValue = vValY.toDouble();
double drawValue;
if ( params()->polarChartSubType() == KDChartParams::PolarStacked )
drawValue = ( cellValue + currentValueSums[ value ] ) * pixelsPerUnit;
else if( params()->polarChartSubType() == KDChartParams::PolarPercent ) {
drawValue = ( ( cellValue + currentValueSums[ value ] )
/ valueTotal * static_cast<double>( radius ) );
} else
drawValue = cellValue * pixelsPerUnit;
// record the point for drawing the polygon later
int drawAngle = value * angleBetweenRays;
TQPoint drawPoint( center + polarToXY( static_cast<int>( drawValue ),
drawAngle ) );
points.setPoint( totalPoints, drawPoint );
totalPoints++;
KDChartDataRegion* datReg = 0;
// the marker can be drawn now
if( params()->polarMarker() ) {
int xsize = params()->polarMarkerSize().width();
int ysize = params()->polarMarkerSize().height();
datReg = drawMarker( painter,
params(),
_areaWidthP1000, _areaHeightP1000,
_dataRect.x(), _dataRect.y(),
params()->polarMarkerStyle( dataset ),
params()->dataColor( dataset ),
drawPoint,
dataset, value, chart,
regions,
xsize ? &xsize : 0,
ysize ? &ysize : 0 );
painter->setPen( TQPen( params()->dataColor( dataset ),
dataLinesWidth ) );
}
if ( regions ) {
bool bMustAppendDatReg = 0 == datReg;
if( bMustAppendDatReg ){
TQRect rect( TQPoint( drawPoint.x() - 1,
drawPoint.y() - 1 ),
TQSize( 3, 3 ) );
datReg = new KDChartDataRegion( dataset,
value,
chart,
rect );
}
datReg->points[ KDChartEnums::PosTopLeft ] =
drawPoint + _dataRect.topLeft();
datReg->points[ KDChartEnums::PosTopCenter ] =
datReg->points[ KDChartEnums::PosTopLeft ];
datReg->points[ KDChartEnums::PosTopRight ] =
datReg->points[ KDChartEnums::PosTopLeft ];
datReg->points[ KDChartEnums::PosBottomLeft ] =
datReg->points[ KDChartEnums::PosTopLeft ];
datReg->points[ KDChartEnums::PosBottomCenter ] =
datReg->points[ KDChartEnums::PosTopLeft ];
datReg->points[ KDChartEnums::PosBottomRight ] =
datReg->points[ KDChartEnums::PosTopLeft ];
datReg->points[ KDChartEnums::PosCenterLeft ] =
datReg->points[ KDChartEnums::PosTopLeft ];
datReg->points[ KDChartEnums::PosCenter ] =
datReg->points[ KDChartEnums::PosTopLeft ];
datReg->points[ KDChartEnums::PosCenterRight ] =
datReg->points[ KDChartEnums::PosTopLeft ];
/*
// test the center positions:
painter->drawEllipse( datReg->points[ KDChartEnums::PosCenterLeft ].x() - 2,
datReg->points[ KDChartEnums::PosCenterLeft ].y() - 2, 5, 5);
*/
datReg->startAngle = drawAngle;
datReg->angleLen = drawAngle;
if( bMustAppendDatReg )
regions->append( datReg );
}
// calculate running sum for stacked and percent
if ( params()->polarChartSubType() == KDChartParams::PolarStacked ||
params()->polarChartSubType() == KDChartParams::PolarPercent )
currentValueSums[ value ] += cellValue;
}
}
painter->drawPolygon( points );
}
painter->translate( -_dataRect.x(), -_dataRect.y() );
}
/*
Helper methode being called by KDChartPolarPainter::paintData()
*/
void KDChartPolarPainter::paintCircularAxisLabel( TQPainter* painter,
bool rotate,
int txtAngle,
TQPoint center,
double currentRadiusPPU,
const TQString& txt,
int align,
int step )
{
if( !rotate && (0 != (align & (TQt::AlignLeft | TQt::AlignRight) ) ) )
currentRadiusPPU += center.x()*0.01;
KDDrawText::drawRotatedText(
painter,
rotate ? txtAngle - 90 : 0,
painter->worldMatrix().map(center - polarToXY( static_cast<int>( currentRadiusPPU ), txtAngle )),
txt,
0,
step
? (rotate ? TQt::AlignBottom | TQt::AlignHCenter : align)
: TQt::AlignCenter,
false,0,false,
false );
}
/*!
Draws the marker for one data point according to the specified style.
\param painter the painter to draw on
\param style what kind of marker is drawn (square, diamond or circle)
\param color the color in which to draw the marker
\param p the center of the marker
\param dataset the dataset which this marker represents
\param value the value which this marker represents
\param regions a list of regions for data points, a new region for the new
marker will be appended to this list if it is not 0
*//*
void KDChartPolarPainter::drawMarker( TQPainter* painter,
KDChartParams::PolarMarkerStyle style,
const TQColor& color,
const TQPoint& p,
uint, //dataset,
uint, //value,
uint, //chart,
double minSizeP1000,
TQRegion& region )
{
int xsize = params()->polarMarkerSize().width();
if ( 0 > xsize )
xsize = -1 * static_cast < int > ( xsize * minSizeP1000 );
int ysize = params()->polarMarkerSize().height();
if ( 0 > ysize )
ysize = -1 * static_cast < int > ( ysize * minSizeP1000 );
int xsize2 = xsize / 2;
int ysize2 = ysize / 2;
painter->setPen( color );
switch ( style ) {
case KDChartParams::PolarMarkerSquare: {
painter->save();
painter->setBrush( color );
TQRect rect( TQPoint( p.x() - xsize2, p.y() - ysize2 ), TQPoint( p.x() + xsize2, p.y() + ysize2 ) );
painter->drawRect( rect );
// Don't use rect for drawing after this!
rect.moveBy( _dataRect.x(), _dataRect.y() );
region = TQRegion( rect );
painter->restore();
break;
}
case KDChartParams::PolarMarkerDiamond: {
painter->save();
painter->setBrush( color );
TQPointArray points( 4 );
points.setPoint( 0, p.x() - xsize2, p.y() );
points.setPoint( 1, p.x(), p.y() - ysize2 );
points.setPoint( 2, p.x() + xsize2, p.y() );
points.setPoint( 3, p.x(), p.y() + ysize2 );
painter->drawPolygon( points );
// Don't use points for drawing after this!
points.translate( _dataRect.x(), _dataRect.y() );
region = TQRegion( points );
painter->restore();
break;
}
case KDChartParams::PolarMarkerCircle:
default: {
painter->save();
painter->setBrush( color );
painter->drawEllipse( p.x() - xsize2, p.y() - ysize2, xsize, ysize );
TQPointArray points;
points.makeEllipse( p.x() - xsize2, p.y() - ysize2, xsize, ysize );
// Don't use points for drawing after this!
points.translate( _dataRect.x(), _dataRect.y() );
if( points.size() > 0 )
region = TQRegion( points );
else
region = TQRegion();
painter->restore();
}
};
}*/
#define DEGTORAD(d) (d)*M_PI/180
TQPoint KDChartPolarPainter::polarToXY( int radius, int angle )
{
double anglerad = DEGTORAD( static_cast<double>( angle ) );
TQPoint ret( static_cast<int>( cos( anglerad ) * radius ),
static_cast<int>( sin( anglerad ) * radius ) );
return ret;
}
/**
This method is a specialization that returns a fallback legend text
appropriate for polar charts where the fallbacks should come from
the values, not from the datasets.
This method is only used when automatic legends are used, because
manual and first-column legends do not need fallback texts.
\param uint dataset the dataset number for which to generate a
fallback text
\return the fallback text to use for describing the specified
dataset in the legend
*/
TQString KDChartPolarPainter::fallbackLegendText( uint dataset ) const
{
return TQObject::tr( "Series " ) + TQString::number( dataset + 1 );
}
/**
This methods returns the number of elements to be shown in the
legend in case fallback texts are used.
This method is only used when automatic legends are used, because
manual and first-column legends do not need fallback texts.
\return the number of fallback texts to use
*/
uint KDChartPolarPainter::numLegendFallbackTexts( KDChartTableDataBase* data ) const
{
return data->usedRows();
}