KChart

KChartCartesianGrid.cpp
1/*
2 * SPDX-FileCopyrightText: 2001-2015 Klaralvdalens Datakonsult AB. All rights reserved.
3 *
4 * This file is part of the KD Chart library.
5 *
6 * SPDX-License-Identifier: GPL-2.0-or-later
7 */
8
9#include "KChartCartesianGrid.h"
10#include "KChartAbstractCartesianDiagram.h"
11#include "KChartPaintContext.h"
12#include "KChartPainterSaver_p.h"
13#include "KChartPrintingParameters.h"
14#include "KChartFrameAttributes.h"
15#include "KChartCartesianAxis_p.h"
16#include "KChartMath_p.h"
17
18#include <QPainter>
19#include <QPainterPath>
20
21using namespace KChart;
22
23CartesianGrid::CartesianGrid()
24 : AbstractGrid(), m_minsteps( 2 ), m_maxsteps( 12 )
25{
26}
27
28CartesianGrid::~CartesianGrid()
29{
30}
31
32int CartesianGrid::minimalSteps() const
33{
34 return m_minsteps;
35}
36
37void CartesianGrid::setMinimalSteps(int minsteps)
38{
39 m_minsteps = minsteps;
40}
41
42int CartesianGrid::maximalSteps() const
43{
44 return m_maxsteps;
45}
46
47void CartesianGrid::setMaximalSteps(int maxsteps)
48{
49 m_maxsteps = maxsteps;
50}
51
52void CartesianGrid::drawGrid( PaintContext* context )
53{
54 CartesianCoordinatePlane* plane = qobject_cast< CartesianCoordinatePlane* >( context->coordinatePlane() );
55 const GridAttributes gridAttrsX( plane->gridAttributes( Qt::Horizontal ) );
56 const GridAttributes gridAttrsY( plane->gridAttributes( Qt::Vertical ) );
57 if ( !gridAttrsX.isGridVisible() && !gridAttrsX.isSubGridVisible() &&
58 !gridAttrsY.isGridVisible() && !gridAttrsY.isSubGridVisible() ) {
59 return;
60 }
61 // This plane is used for translating the coordinates - not for the data boundaries
62 QPainter *p = context->painter();
63 PainterSaver painterSaver( p );
64 // sharedAxisMasterPlane() changes the painter's coordinate transformation(!)
65 plane = qobject_cast< CartesianCoordinatePlane* >( plane->sharedAxisMasterPlane( context->painter() ) );
66 Q_ASSERT_X ( plane, "CartesianGrid::drawGrid",
67 "Bad function call: PaintContext::coodinatePlane() NOT a cartesian plane." );
68
69 // update the calculated mDataDimensions before using them
70 updateData( context->coordinatePlane() ); // this, in turn, calls our calculateGrid().
71 Q_ASSERT_X ( mDataDimensions.count() == 2, "CartesianGrid::drawGrid",
72 "Error: updateData did not return exactly two dimensions." );
73 if ( !isBoundariesValid( mDataDimensions ) ) {
74 return;
75 }
76
77 const DataDimension dimX = mDataDimensions.first();
78 const DataDimension dimY = mDataDimensions.last();
79 const bool isLogarithmicX = dimX.calcMode == AbstractCoordinatePlane::Logarithmic;
80 const bool isLogarithmicY = dimY.calcMode == AbstractCoordinatePlane::Logarithmic;
81
82 qreal minValueX = qMin( dimX.start, dimX.end );
83 qreal maxValueX = qMax( dimX.start, dimX.end );
84 qreal minValueY = qMin( dimY.start, dimY.end );
85 qreal maxValueY = qMax( dimY.start, dimY.end );
86 {
87 bool adjustXLower = !isLogarithmicX && gridAttrsX.adjustLowerBoundToGrid();
88 bool adjustXUpper = !isLogarithmicX && gridAttrsX.adjustUpperBoundToGrid();
89 bool adjustYLower = !isLogarithmicY && gridAttrsY.adjustLowerBoundToGrid();
90 bool adjustYUpper = !isLogarithmicY && gridAttrsY.adjustUpperBoundToGrid();
91 AbstractGrid::adjustLowerUpperRange( minValueX, maxValueX, dimX.stepWidth, adjustXLower, adjustXUpper );
92 AbstractGrid::adjustLowerUpperRange( minValueY, maxValueY, dimY.stepWidth, adjustYLower, adjustYUpper );
93 }
94
95 if ( plane->frameAttributes().isVisible() ) {
96 const qreal radius = plane->frameAttributes().cornerRadius();
97 QPainterPath path;
98 path.addRoundedRect( QRectF( plane->translate( QPointF( minValueX, minValueY ) ),
99 plane->translate( QPointF( maxValueX, maxValueY ) ) ),
100 radius, radius );
101 context->painter()->setClipPath( path );
102 }
103
104 /* TODO features from old code:
105 - MAYBE coarsen the main grid when it gets crowded (do it in calculateGrid or here?)
106 if ( ! dimX.isCalculated ) {
107 while ( screenRangeX / numberOfUnitLinesX <= MinimumPixelsBetweenLines ) {
108 dimX.stepWidth *= 10.0;
109 dimX.subStepWidth *= 10.0;
110 numberOfUnitLinesX = qAbs( dimX.distance() / dimX.stepWidth );
111 }
112 }
113 - MAYBE deactivate the sub-grid when it gets crowded
114 if ( dimX.subStepWidth && (screenRangeX / (dimX.distance() / dimX.subStepWidth)
115 <= MinimumPixelsBetweenLines) ) {
116 // de-activating grid sub steps: not enough space
117 dimX.subStepWidth = 0.0;
118 }
119 */
120
121 for ( int i = 0; i < 2; i++ ) {
122 XySwitch xy( i == 1 ); // first iteration paints the X grid lines, second paints the Y grid lines
123 const GridAttributes& gridAttrs = xy( gridAttrsX, gridAttrsY );
124 bool hasMajorLines = gridAttrs.isGridVisible();
125 bool hasMinorLines = hasMajorLines && gridAttrs.isSubGridVisible();
126 if ( !hasMajorLines && !hasMinorLines ) {
127 continue;
128 }
129
130 const DataDimension& dimension = xy( dimX, dimY );
131 const bool drawZeroLine = dimension.isCalculated && gridAttrs.zeroLinePen().style() != Qt::NoPen;
132
133 QPointF lineStart = QPointF( minValueX, minValueY ); // still need transformation to screen space
134 QPointF lineEnd = QPointF( maxValueX, maxValueY );
135
136 TickIterator it( xy.isY, dimension, gridAttrs.linesOnAnnotations(),
137 hasMajorLines, hasMinorLines, plane );
138 for ( ; !it.isAtEnd(); ++it ) {
139 if ( !gridAttrs.isOuterLinesVisible() &&
140 ( it.areAlmostEqual( it.position(), xy( minValueX, minValueY ) ) ||
141 it.areAlmostEqual( it.position(), xy( maxValueX, maxValueY ) ) ) ) {
142 continue;
143 }
144 xy.lvalue( lineStart.rx(), lineStart.ry() ) = it.position();
145 xy.lvalue( lineEnd.rx(), lineEnd.ry() ) = it.position();
146 QPointF transLineStart = plane->translate( lineStart );
147 QPointF transLineEnd = plane->translate( lineEnd );
148 if ( ISNAN( transLineStart.x() ) || ISNAN( transLineStart.y() ) ||
149 ISNAN( transLineEnd.x() ) || ISNAN( transLineEnd.y() ) ) {
150 // ### can we catch NaN problems earlier, wasting fewer cycles?
151 continue;
152 }
153 if ( it.position() == 0.0 && drawZeroLine ) {
154 p->setPen( PrintingParameters::scalePen( gridAttrsX.zeroLinePen() ) );
155 } else if ( it.type() == TickIterator::MinorTick ) {
156 p->setPen( PrintingParameters::scalePen( gridAttrs.subGridPen() ) );
157 } else {
158 p->setPen( PrintingParameters::scalePen( gridAttrs.gridPen() ) );
159 }
160 p->drawLine( transLineStart, transLineEnd );
161 }
162 }
163}
164
165
166DataDimensionsList CartesianGrid::calculateGrid( const DataDimensionsList& rawDataDimensions ) const
167{
168 Q_ASSERT_X ( rawDataDimensions.count() == 2, "CartesianGrid::calculateGrid",
169 "Error: calculateGrid() expects a list with exactly two entries." );
170
171 CartesianCoordinatePlane* plane = qobject_cast< CartesianCoordinatePlane* >( mPlane );
172 Q_ASSERT_X ( plane, "CartesianGrid::calculateGrid",
173 "Error: PaintContext::calculatePlane() called, but no cartesian plane set." );
174
175 DataDimensionsList l( rawDataDimensions );
176#if 0
177 qDebug() << Q_FUNC_INFO << "initial grid X-range:" << l.first().start << "->" << l.first().end
178 << " substep width:" << l.first().subStepWidth;
179 qDebug() << Q_FUNC_INFO << "initial grid Y-range:" << l.last().start << "->" << l.last().end
180 << " substep width:" << l.last().subStepWidth;
181#endif
182 // rule: Returned list is either empty, or it is providing two
183 // valid dimensions, complete with two non-Zero step widths.
184 if ( isBoundariesValid( l ) ) {
185 const QPointF translatedBottomLeft( plane->translateBack( plane->geometry().bottomLeft() ) );
186 const QPointF translatedTopRight( plane->translateBack( plane->geometry().topRight() ) );
187
188 const GridAttributes gridAttrsX( plane->gridAttributes( Qt::Horizontal ) );
189 const GridAttributes gridAttrsY( plane->gridAttributes( Qt::Vertical ) );
190
191 const DataDimension dimX
192 = calculateGridXY( l.first(), Qt::Horizontal,
193 gridAttrsX.adjustLowerBoundToGrid(),
194 gridAttrsX.adjustUpperBoundToGrid() );
195 if ( dimX.stepWidth ) {
196 //qDebug("CartesianGrid::calculateGrid() l.last().start: %f l.last().end: %f", l.last().start, l.last().end);
197 //qDebug(" l.first().start: %f l.first().end: %f", l.first().start, l.first().end);
198
199 // one time for the min/max value
200 const DataDimension minMaxY
201 = calculateGridXY( l.last(), Qt::Vertical,
202 gridAttrsY.adjustLowerBoundToGrid(),
203 gridAttrsY.adjustUpperBoundToGrid() );
204
205 if ( plane->autoAdjustGridToZoom()
206 && plane->axesCalcModeY() == CartesianCoordinatePlane::Linear
207 && plane->zoomFactorY() > 1.0 )
208 {
209 l.last().start = translatedBottomLeft.y();
210 l.last().end = translatedTopRight.y();
211 }
212 // and one other time for the step width
213 const DataDimension dimY
214 = calculateGridXY( l.last(), Qt::Vertical,
215 gridAttrsY.adjustLowerBoundToGrid(),
216 gridAttrsY.adjustUpperBoundToGrid() );
217 if ( dimY.stepWidth ) {
218 l.first().start = dimX.start;
219 l.first().end = dimX.end;
220 l.first().stepWidth = dimX.stepWidth;
221 l.first().subStepWidth = dimX.subStepWidth;
222 l.last().start = minMaxY.start;
223 l.last().end = minMaxY.end;
224 l.last().stepWidth = dimY.stepWidth;
225 l.last().subStepWidth = dimY.subStepWidth;
226 //qDebug() << "CartesianGrid::calculateGrid() final grid y-range:" << l.last().end - l.last().start << " step width:" << l.last().stepWidth << endl;
227 // calculate some reasonable subSteps if the
228 // user did not set the sub grid but did set
229 // the stepWidth.
230
231 // FIXME (Johannes)
232 // the last (y) dimension is not always the dimension for the ordinate!
233 // since there's no way to check for the orientation of this dimension here,
234 // we cannot automatically assume substep values
235 //if ( dimY.subStepWidth == 0 )
236 // l.last().subStepWidth = dimY.stepWidth/2;
237 //else
238 // l.last().subStepWidth = dimY.subStepWidth;
239 }
240 }
241 }
242#if 0
243 qDebug() << Q_FUNC_INFO << "final grid X-range:" << l.first().start << "->" << l.first().end
244 << " substep width:" << l.first().subStepWidth;
245 qDebug() << Q_FUNC_INFO << "final grid Y-range:" << l.last().start << "->" << l.last().end
246 << " substep width:" << l.last().subStepWidth;
247#endif
248 return l;
249}
250
251qreal fastPow10( int x )
252{
253 qreal res = 1.0;
254 if ( 0 <= x ) {
255 for ( int i = 1; i <= x; ++i )
256 res *= 10.0;
257 } else {
258 for ( int i = -1; i >= x; --i )
259 res *= 0.1;
260 }
261 return res;
262}
263
264#ifdef Q_OS_WIN
265#define trunc(x) ((int)(x))
266#endif
267
268DataDimension CartesianGrid::calculateGridXY(
269 const DataDimension& rawDataDimension,
270 Qt::Orientation orientation,
271 bool adjustLower, bool adjustUpper ) const
272{
273 CartesianCoordinatePlane* const plane = dynamic_cast<CartesianCoordinatePlane*>( mPlane );
274 if ( ( orientation == Qt::Vertical && plane->autoAdjustVerticalRangeToData() >= 100 ) ||
275 ( orientation == Qt::Horizontal && plane->autoAdjustHorizontalRangeToData() >= 100 ) ) {
276 adjustLower = false;
277 adjustUpper = false;
278 }
279
280 DataDimension dim( rawDataDimension );
281 if ( dim.isCalculated && dim.start != dim.end ) {
282 if ( dim.calcMode == AbstractCoordinatePlane::Linear ) {
283 // linear ( == not-logarithmic) calculation
284 if ( dim.stepWidth == 0.0 ) {
285 QList<qreal> granularities;
286 switch ( dim.sequence ) {
287 case KChartEnums::GranularitySequence_10_20:
288 granularities << 1.0 << 2.0;
289 break;
290 case KChartEnums::GranularitySequence_10_50:
291 granularities << 1.0 << 5.0;
292 break;
293 case KChartEnums::GranularitySequence_25_50:
294 granularities << 2.5 << 5.0;
295 break;
296 case KChartEnums::GranularitySequence_125_25:
297 granularities << 1.25 << 2.5;
298 break;
299 case KChartEnums::GranularitySequenceIrregular:
300 granularities << 1.0 << 1.25 << 2.0 << 2.5 << 5.0;
301 break;
302 }
303 //qDebug("CartesianGrid::calculateGridXY() dim.start: %f dim.end: %f", dim.start, dim.end);
304 calculateStepWidth(
305 dim.start, dim.end, granularities, orientation,
306 dim.stepWidth, dim.subStepWidth,
307 adjustLower, adjustUpper );
308 }
309 // if needed, adjust start/end to match the step width:
310 //qDebug() << "CartesianGrid::calculateGridXY() has 1st linear range: min " << dim.start << " and max" << dim.end;
311
312 AbstractGrid::adjustLowerUpperRange( dim.start, dim.end, dim.stepWidth,
313 adjustLower, adjustUpper );
314 //qDebug() << "CartesianGrid::calculateGridXY() returns linear range: min " << dim.start << " and max" << dim.end;
315 } else {
316 // logarithmic calculation with negative values
317 if ( dim.end <= 0 )
318 {
319 qreal min;
320 const qreal minRaw = qMin( dim.start, dim.end );
321 const int minLog = -static_cast<int>(trunc( log10( -minRaw ) ) );
322 if ( minLog >= 0 )
323 min = qMin( minRaw, -std::numeric_limits< qreal >::epsilon() );
324 else
325 min = -fastPow10( -(minLog-1) );
326
327 qreal max;
328 const qreal maxRaw = qMin( -std::numeric_limits< qreal >::epsilon(), qMax( dim.start, dim.end ) );
329 const int maxLog = -static_cast<int>(ceil( log10( -maxRaw ) ) );
330 if ( maxLog >= 0 )
331 max = -1;
332 else if ( fastPow10( -maxLog ) < maxRaw )
333 max = -fastPow10( -(maxLog+1) );
334 else
335 max = -fastPow10( -maxLog );
336 if ( adjustLower )
337 dim.start = min;
338 if ( adjustUpper )
339 dim.end = max;
340 dim.stepWidth = -pow( 10.0, ceil( log10( qAbs( max - min ) / 10.0 ) ) );
341 }
342 // logarithmic calculation (ignoring all negative values)
343 else
344 {
345 qreal min;
346 const qreal minRaw = qMax( qMin( dim.start, dim.end ), qreal( 0.0 ) );
347 const int minLog = static_cast<int>(trunc( log10( minRaw ) ) );
348 if ( minLog <= 0 && dim.end < 1.0 )
349 min = qMax( minRaw, std::numeric_limits< qreal >::epsilon() );
350 else if ( minLog <= 0 )
351 min = qMax( qreal(0.00001), dim.start );
352 else
353 min = fastPow10( minLog-1 );
354
355 // Uh oh. Logarithmic scaling doesn't work with a lower or upper
356 // bound being 0.
357 const bool zeroBound = dim.start == 0.0 || dim.end == 0.0;
358
359 qreal max;
360 const qreal maxRaw = qMax( qMax( dim.start, dim.end ), qreal( 0.0 ) );
361 const int maxLog = static_cast<int>(ceil( log10( maxRaw ) ) );
362 if ( maxLog <= 0 )
363 max = 1;
364 else if ( fastPow10( maxLog ) < maxRaw )
365 max = fastPow10( maxLog+1 );
366 else
367 max = fastPow10( maxLog );
368 if ( adjustLower || zeroBound )
369 dim.start = min;
370 if ( adjustUpper || zeroBound )
371 dim.end = max;
372 dim.stepWidth = pow( 10.0, ceil( log10( qAbs( max - min ) / 10.0 ) ) );
373 }
374 }
375 } else {
376 //qDebug() << "CartesianGrid::calculateGridXY() returns stepWidth 1.0 !!";
377 // Do not ignore the user configuration
378 dim.stepWidth = dim.stepWidth ? dim.stepWidth : 1.0;
379 }
380 return dim;
381}
382
383
384static void calculateSteps(
385 qreal start_, qreal end_, const QList<qreal>& list,
386 int minSteps, int maxSteps,
387 int power,
388 qreal& steps, qreal& stepWidth,
389 bool adjustLower, bool adjustUpper )
390{
391 //qDebug("-----------------------------------\nstart: %f end: %f power-of-ten: %i", start_, end_, power);
392
393 qreal distance = 0.0;
394 steps = 0.0;
395
396 const int lastIdx = list.count()-1;
397 for ( int i = 0; i <= lastIdx; ++i ) {
398 const qreal testStepWidth = list.at(lastIdx - i) * fastPow10( power );
399 //qDebug( "testing step width: %f", testStepWidth);
400 qreal start = qMin( start_, end_ );
401 qreal end = qMax( start_, end_ );
402 //qDebug("pre adjusting start: %f end: %f", start, end);
403 AbstractGrid::adjustLowerUpperRange( start, end, testStepWidth, adjustLower, adjustUpper );
404 //qDebug("post adjusting start: %f end: %f", start, end);
405
406 const qreal testDistance = qAbs(end - start);
407 const qreal testSteps = testDistance / testStepWidth;
408
409 //qDebug() << "testDistance:" << testDistance << " distance:" << distance;
410 if ( (minSteps <= testSteps) && (testSteps <= maxSteps)
411 && ( (steps == 0.0) || (testDistance <= distance) ) ) {
412 steps = testSteps;
413 stepWidth = testStepWidth;
414 distance = testDistance;
415 //qDebug( "start: %f end: %f step width: %f steps: %f distance: %f", start, end, stepWidth, steps, distance);
416 }
417 }
418}
419
420
421void CartesianGrid::calculateStepWidth(
422 qreal start_, qreal end_,
423 const QList<qreal>& granularities,
424 Qt::Orientation orientation,
425 qreal& stepWidth, qreal& subStepWidth,
426 bool adjustLower, bool adjustUpper ) const
427{
428 Q_UNUSED( orientation );
429
430 Q_ASSERT_X ( granularities.count(), "CartesianGrid::calculateStepWidth",
431 "Error: The list of GranularitySequence values is empty." );
432 QList<qreal> list( granularities );
433 std::sort(list.begin(), list.end());
434
435 const qreal start = qMin( start_, end_);
436 const qreal end = qMax( start_, end_);
437 const qreal distance = end - start;
438 //qDebug( "raw data start: %f end: %f", start, end);
439
440 qreal steps;
441 int power = 0;
442 while ( list.last() * fastPow10( power ) < distance ) {
443 ++power;
444 };
445 // We have the sequence *two* times in the calculation test list,
446 // so we will be sure to find the best match:
447 const int count = list.count();
448 QList<qreal> testList;
449
450 for ( int dec = -1; dec == -1 || fastPow10( dec + 1 ) >= distance; --dec )
451 for ( int i = 0; i < count; ++i )
452 testList << list.at(i) * fastPow10( dec );
453
454 testList << list;
455
456 do {
457 calculateSteps( start, end, testList, m_minsteps, m_maxsteps, power,
458 steps, stepWidth,
459 adjustLower, adjustUpper );
460 --power;
461 } while ( steps == 0.0 );
462 ++power;
463 //qDebug( "steps calculated: stepWidth: %f steps: %f", stepWidth, steps);
464
465 // find the matching sub-grid line width in case it is
466 // not set by the user
467
468 if ( subStepWidth == 0.0 ) {
469 if ( stepWidth == list.first() * fastPow10( power ) ) {
470 subStepWidth = list.last() * fastPow10( power-1 );
471 //qDebug("A");
472 } else if ( stepWidth == list.first() * fastPow10( power-1 ) ) {
473 subStepWidth = list.last() * fastPow10( power-2 );
474 //qDebug("B");
475 } else {
476 qreal smallerStepWidth = list.first();
477 for ( int i = 1; i < list.count(); ++i ) {
478 if ( stepWidth == list.at( i ) * fastPow10( power ) ) {
479 subStepWidth = smallerStepWidth * fastPow10( power );
480 break;
481 }
482 if ( stepWidth == list.at( i ) * fastPow10( power-1 ) ) {
483 subStepWidth = smallerStepWidth * fastPow10( power-1 );
484 break;
485 }
486 smallerStepWidth = list.at( i );
487 }
488 }
489 }
490 //qDebug("CartesianGrid::calculateStepWidth() found stepWidth %f (%f steps) and sub-stepWidth %f", stepWidth, steps, subStepWidth);
491}
KChart::AbstractCoordinatePlane::geometry
QRect geometry() const override
pure virtual in QLayoutItem
Definition KChartAbstractCoordinatePlane.cpp:232
KChart::AbstractGrid
Abstract base class for grid classes: cartesian, polar, ...
Definition KChartAbstractGrid.h:34
KChart::AbstractGrid::updateData
DataDimensionsList updateData(AbstractCoordinatePlane *plane)
Returns the cached result of data calculation.
Definition KChartAbstractGrid.cpp:43
KChart::AbstractGrid::adjustLowerUpperRange
static void adjustLowerUpperRange(qreal &start, qreal &end, qreal stepWidth, bool adjustLower, bool adjustUpper)
Adjusts start and/or end so that they are a multiple of stepWidth.
Definition KChartAbstractGrid.cpp:82
KChart::AbstractGrid::isBoundariesValid
static bool isBoundariesValid(const QRectF &r)
Checks whether both coordinates of r are valid according to isValueValid.
Definition KChartAbstractGrid.cpp:58
KChart::CartesianCoordinatePlane::autoAdjustVerticalRangeToData
unsigned int autoAdjustVerticalRangeToData() const
Returns the maximal allowed percent of the vertical space covered by the coordinate plane that may be...
Definition KChartCartesianCoordinatePlane.cpp:700
KChart::CartesianCoordinatePlane::autoAdjustHorizontalRangeToData
unsigned int autoAdjustHorizontalRangeToData() const
Returns the maximal allowed percent of the horizontal space covered by the coordinate plane that may ...
Definition KChartCartesianCoordinatePlane.cpp:695
KChart::CartesianCoordinatePlane::translate
const QPointF translate(const QPointF &diagramPoint) const override
Translate the given point in value space coordinates to a position in pixel space.
Definition KChartCartesianCoordinatePlane.cpp:442
KChart::CartesianCoordinatePlane::sharedAxisMasterPlane
AbstractCoordinatePlane * sharedAxisMasterPlane(QPainter *p=nullptr) override
reimpl
Definition KChartCartesianCoordinatePlane.cpp:768
KChart::CartesianCoordinatePlane::gridAttributes
const GridAttributes gridAttributes(Qt::Orientation orientation) const
Definition KChartCartesianCoordinatePlane.cpp:724
KChart::CartesianCoordinatePlane::autoAdjustGridToZoom
bool autoAdjustGridToZoom() const
Return the status of the built-in grid adjusting feature.
Definition KChartCartesianCoordinatePlane.cpp:763
KChart::CartesianGrid::drawGrid
void drawGrid(PaintContext *context) override
Doing the actual drawing.
Definition KChartCartesianGrid.cpp:52
KChart::DataDimension
Helper class for one dimension of data, e.g.
Definition KChartAbstractCoordinatePlane.h:364
KChart::GridAttributes
A set of attributes controlling the appearance of grids.
Definition KChartGridAttributes.h:26
KChart::PaintContext
Stores information about painting diagrams.
Definition KChartPaintContext.h:28
start
Q_SCRIPTABLE Q_NOREPLY void start()
KRecentDirs::list
KIOCORE_EXPORT QStringList list(const QString &fileClass)
KStandardShortcut::end
const QList< QKeySequence > & end()
OSM::distance
KOSM_EXPORT double distance(const std::vector< const OSM::Node * > &path, Coordinate coord)
QList::at
const_reference at(qsizetype i) const const
QList::begin
iterator begin()
QList::count
qsizetype count() const const
QList::end
iterator end()
QList::first
T & first()
QList::last
T & last()
QPainter::drawLine
void drawLine(const QLine &line)
QPainter::setClipPath
void setClipPath(const QPainterPath &path, Qt::ClipOperation operation)
QPainter::setPen
void setPen(Qt::PenStyle style)
QPen::style
Qt::PenStyle style() const const
QPointF::rx
qreal & rx()
QPointF::ry
qreal & ry()
QPointF::x
qreal x() const const
QPointF::y
qreal y() const const
QRect::bottomLeft
QPoint bottomLeft() const const
QRect::topRight
QPoint topRight() const const
Qt::Horizontal
Horizontal
Qt::dec
QTextStream & dec(QTextStream &stream)
This file is part of the KDE documentation.
Documentation copyright © 1996-2024 The KDE developers.
Generated on Sat Dec 21 2024 17:02:46 by doxygen 1.12.0 written by Dimitri van Heesch, © 1997-2006

KDE's Doxygen guidelines are available online.