qwt_plot_axis.cpp
Go to the documentation of this file.
1 /* -*- mode: C++ ; c-file-style: "stroustrup" -*- *****************************
2  * Qwt Widget Library
3  * Copyright (C) 1997 Josef Wilgen
4  * Copyright (C) 2002 Uwe Rathmann
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the Qwt License, Version 1.0
8  *****************************************************************************/
9 
10 #include "qwt_plot.h"
11 #include "qwt_scale_widget.h"
12 #include "qwt_scale_map.h"
13 #include "qwt_scale_div.h"
14 #include "qwt_scale_engine.h"
15 #include "qwt_interval.h"
16 
18 {
19 public:
20  bool isEnabled;
22 
23  double minValue;
24  double maxValue;
25  double stepSize;
26 
27  int maxMajor;
28  int maxMinor;
29 
30  bool isValid;
31 
35 };
36 
39 {
40  int axisId;
41 
42  for ( axisId = 0; axisId < axisCnt; axisId++ )
43  d_axisData[axisId] = new AxisData;
44 
53 
54  d_axisData[yLeft]->scaleWidget->setObjectName( "QwtPlotAxisYLeft" );
55  d_axisData[yRight]->scaleWidget->setObjectName( "QwtPlotAxisYRight" );
56  d_axisData[xTop]->scaleWidget->setObjectName( "QwtPlotAxisXTop" );
57  d_axisData[xBottom]->scaleWidget->setObjectName( "QwtPlotAxisXBottom" );
58 
59 #if 1
60  // better find the font sizes from the application font
61  QFont fscl( fontInfo().family(), 10 );
62  QFont fttl( fontInfo().family(), 12, QFont::Bold );
63 #endif
64 
65  for ( axisId = 0; axisId < axisCnt; axisId++ )
66  {
67  AxisData &d = *d_axisData[axisId];
68 
70 
73 
74  d.scaleWidget->setFont( fscl );
75  d.scaleWidget->setMargin( 2 );
76 
77  QwtText text = d.scaleWidget->title();
78  text.setFont( fttl );
79  d.scaleWidget->setTitle( text );
80 
81  d.doAutoScale = true;
82 
83  d.minValue = 0.0;
84  d.maxValue = 1000.0;
85  d.stepSize = 0.0;
86 
87  d.maxMinor = 5;
88  d.maxMajor = 8;
89 
90 
91  d.isValid = false;
92  }
93 
94  d_axisData[yLeft]->isEnabled = true;
95  d_axisData[yRight]->isEnabled = false;
96  d_axisData[xBottom]->isEnabled = true;
97  d_axisData[xTop]->isEnabled = false;
98 }
99 
101 {
102  for ( int axisId = 0; axisId < axisCnt; axisId++ )
103  {
104  delete d_axisData[axisId]->scaleEngine;
105  delete d_axisData[axisId];
106  d_axisData[axisId] = NULL;
107  }
108 }
109 
114 const QwtScaleWidget *QwtPlot::axisWidget( int axisId ) const
115 {
116  if ( axisValid( axisId ) )
117  return d_axisData[axisId]->scaleWidget;
118 
119  return NULL;
120 }
121 
127 {
128  if ( axisValid( axisId ) )
129  return d_axisData[axisId]->scaleWidget;
130 
131  return NULL;
132 }
133 
143 {
144  if ( axisValid( axisId ) && scaleEngine != NULL )
145  {
146  AxisData &d = *d_axisData[axisId];
147 
148  delete d.scaleEngine;
150 
152  scaleEngine->transformation() );
153 
154  d.isValid = false;
155 
156  autoRefresh();
157  }
158 }
159 
165 {
166  if ( axisValid( axisId ) )
167  return d_axisData[axisId]->scaleEngine;
168  else
169  return NULL;
170 }
171 
176 const QwtScaleEngine *QwtPlot::axisScaleEngine( int axisId ) const
177 {
178  if ( axisValid( axisId ) )
179  return d_axisData[axisId]->scaleEngine;
180  else
181  return NULL;
182 }
187 bool QwtPlot::axisAutoScale( int axisId ) const
188 {
189  if ( axisValid( axisId ) )
190  return d_axisData[axisId]->doAutoScale;
191  else
192  return false;
193 }
194 
199 bool QwtPlot::axisEnabled( int axisId ) const
200 {
201  if ( axisValid( axisId ) )
202  return d_axisData[axisId]->isEnabled;
203  else
204  return false;
205 }
206 
211 QFont QwtPlot::axisFont( int axisId ) const
212 {
213  if ( axisValid( axisId ) )
214  return axisWidget( axisId )->font();
215  else
216  return QFont();
217 
218 }
219 
225 int QwtPlot::axisMaxMajor( int axisId ) const
226 {
227  if ( axisValid( axisId ) )
228  return d_axisData[axisId]->maxMajor;
229  else
230  return 0;
231 }
232 
238 int QwtPlot::axisMaxMinor( int axisId ) const
239 {
240  if ( axisValid( axisId ) )
241  return d_axisData[axisId]->maxMinor;
242  else
243  return 0;
244 }
245 
257 const QwtScaleDiv &QwtPlot::axisScaleDiv( int axisId ) const
258 {
259  return d_axisData[axisId]->scaleDiv;
260 }
261 
268 const QwtScaleDraw *QwtPlot::axisScaleDraw( int axisId ) const
269 {
270  if ( !axisValid( axisId ) )
271  return NULL;
272 
273  return axisWidget( axisId )->scaleDraw();
274 }
275 
283 {
284  if ( !axisValid( axisId ) )
285  return NULL;
286 
287  return axisWidget( axisId )->scaleDraw();
288 }
289 
300 double QwtPlot::axisStepSize( int axisId ) const
301 {
302  if ( !axisValid( axisId ) )
303  return 0;
304 
305  return d_axisData[axisId]->stepSize;
306 }
307 
319 {
320  if ( !axisValid( axisId ) )
321  return QwtInterval();
322 
323  return d_axisData[axisId]->scaleDiv.interval();
324 }
325 
330 QwtText QwtPlot::axisTitle( int axisId ) const
331 {
332  if ( axisValid( axisId ) )
333  return axisWidget( axisId )->title();
334  else
335  return QwtText();
336 }
337 
351 void QwtPlot::enableAxis( int axisId, bool tf )
352 {
353  if ( axisValid( axisId ) && tf != d_axisData[axisId]->isEnabled )
354  {
355  d_axisData[axisId]->isEnabled = tf;
356  updateLayout();
357  }
358 }
359 
372 double QwtPlot::invTransform( int axisId, int pos ) const
373 {
374  if ( axisValid( axisId ) )
375  return( canvasMap( axisId ).invTransform( pos ) );
376  else
377  return 0.0;
378 }
379 
380 
389 double QwtPlot::transform( int axisId, double value ) const
390 {
391  if ( axisValid( axisId ) )
392  return( canvasMap( axisId ).transform( value ) );
393  else
394  return 0.0;
395 }
396 
405 void QwtPlot::setAxisFont( int axisId, const QFont &font )
406 {
407  if ( axisValid( axisId ) )
408  axisWidget( axisId )->setFont( font );
409 }
410 
424 void QwtPlot::setAxisAutoScale( int axisId, bool on )
425 {
426  if ( axisValid( axisId ) && ( d_axisData[axisId]->doAutoScale != on ) )
427  {
428  d_axisData[axisId]->doAutoScale = on;
429  autoRefresh();
430  }
431 }
432 
448 void QwtPlot::setAxisScale( int axisId, double min, double max, double stepSize )
449 {
450  if ( axisValid( axisId ) )
451  {
452  AxisData &d = *d_axisData[axisId];
453 
454  d.doAutoScale = false;
455  d.isValid = false;
456 
457  d.minValue = min;
458  d.maxValue = max;
459  d.stepSize = stepSize;
460 
461  autoRefresh();
462  }
463 }
464 
478 {
479  if ( axisValid( axisId ) )
480  {
481  AxisData &d = *d_axisData[axisId];
482 
483  d.doAutoScale = false;
484  d.scaleDiv = scaleDiv;
485  d.isValid = true;
486 
487  autoRefresh();
488  }
489 }
490 
507 void QwtPlot::setAxisScaleDraw( int axisId, QwtScaleDraw *scaleDraw )
508 {
509  if ( axisValid( axisId ) )
510  {
511  axisWidget( axisId )->setScaleDraw( scaleDraw );
512  autoRefresh();
513  }
514 }
515 
524 void QwtPlot::setAxisLabelAlignment( int axisId, Qt::Alignment alignment )
525 {
526  if ( axisValid( axisId ) )
527  axisWidget( axisId )->setLabelAlignment( alignment );
528 }
529 
539 void QwtPlot::setAxisLabelRotation( int axisId, double rotation )
540 {
541  if ( axisValid( axisId ) )
542  axisWidget( axisId )->setLabelRotation( rotation );
543 }
544 
553 void QwtPlot::setAxisMaxMinor( int axisId, int maxMinor )
554 {
555  if ( axisValid( axisId ) )
556  {
557  maxMinor = qBound( 0, maxMinor, 100 );
558 
559  AxisData &d = *d_axisData[axisId];
560  if ( maxMinor != d.maxMinor )
561  {
562  d.maxMinor = maxMinor;
563  d.isValid = false;
564  autoRefresh();
565  }
566  }
567 }
568 
577 void QwtPlot::setAxisMaxMajor( int axisId, int maxMajor )
578 {
579  if ( axisValid( axisId ) )
580  {
581  maxMajor = qBound( 1, maxMajor, 10000 );
582 
583  AxisData &d = *d_axisData[axisId];
584  if ( maxMajor != d.maxMajor )
585  {
586  d.maxMajor = maxMajor;
587  d.isValid = false;
588  autoRefresh();
589  }
590  }
591 }
592 
599 void QwtPlot::setAxisTitle( int axisId, const QString &title )
600 {
601  if ( axisValid( axisId ) )
602  axisWidget( axisId )->setTitle( title );
603 }
604 
611 void QwtPlot::setAxisTitle( int axisId, const QwtText &title )
612 {
613  if ( axisValid( axisId ) )
614  axisWidget( axisId )->setTitle( title );
615 }
616 
642 {
643  // Find bounding interval of the item data
644  // for all axes, where autoscaling is enabled
645 
646  QwtInterval intv[axisCnt];
647 
648  const QwtPlotItemList& itmList = itemList();
649 
651  for ( it = itmList.begin(); it != itmList.end(); ++it )
652  {
653  const QwtPlotItem *item = *it;
654 
656  continue;
657 
658  if ( !item->isVisible() )
659  continue;
660 
661  if ( axisAutoScale( item->xAxis() ) || axisAutoScale( item->yAxis() ) )
662  {
663  const QRectF rect = item->boundingRect();
664 
665  if ( rect.width() >= 0.0 )
666  intv[item->xAxis()] |= QwtInterval( rect.left(), rect.right() );
667 
668  if ( rect.height() >= 0.0 )
669  intv[item->yAxis()] |= QwtInterval( rect.top(), rect.bottom() );
670  }
671  }
672 
673  // Adjust scales
674 
675  for ( int axisId = 0; axisId < axisCnt; axisId++ )
676  {
677  AxisData &d = *d_axisData[axisId];
678 
679  double minValue = d.minValue;
680  double maxValue = d.maxValue;
681  double stepSize = d.stepSize;
682 
683  if ( d.doAutoScale && intv[axisId].isValid() )
684  {
685  d.isValid = false;
686 
687  minValue = intv[axisId].minValue();
688  maxValue = intv[axisId].maxValue();
689 
691  minValue, maxValue, stepSize );
692  }
693  if ( !d.isValid )
694  {
696  minValue, maxValue,
697  d.maxMajor, d.maxMinor, stepSize );
698  d.isValid = true;
699  }
700 
702  scaleWidget->setScaleDiv( d.scaleDiv );
703 
704  int startDist, endDist;
705  scaleWidget->getBorderDistHint( startDist, endDist );
706  scaleWidget->setBorderDist( startDist, endDist );
707  }
708 
709  for ( it = itmList.begin(); it != itmList.end(); ++it )
710  {
711  QwtPlotItem *item = *it;
713  {
714  item->updateScaleDiv( axisScaleDiv( item->xAxis() ),
715  axisScaleDiv( item->yAxis() ) );
716  }
717  }
718 }
719 
void setAxisFont(int axisId, const QFont &)
Change the font of an axis.
enum MQTTPropertyCodes value
const QwtScaleDiv & axisScaleDiv(int axisId) const
Return the scale division of a specified axis.
QFont axisFont(int axisId) const
X axis above the canvas.
Definition: qwt_plot.h:106
void setFont(const QFont &)
Definition: qwt_text.cpp:306
void setAxisLabelRotation(int axisId, double rotation)
bool isVisible() const
A class representing an interval.
Definition: qwt_interval.h:22
Number of axes.
Definition: qwt_plot.h:109
MQTTClient d
Definition: test10.c:1656
int xAxis() const
Return xAxis.
double minValue() const
Definition: qwt_interval.h:190
The scale is above.
void setAxisMaxMajor(int axisId, int maxMajor)
void setAxisScaleDraw(int axisId, QwtScaleDraw *)
Set a scale draw.
const QwtPlotItemList & itemList() const
A QwtPlotItemList of all attached plot items.
void deleteAxesData()
void autoRefresh()
Replots the plot if autoReplot() is true.
Definition: qwt_plot.cpp:286
Y axis right of the canvas.
Definition: qwt_plot.h:100
void setScaleDiv(const QwtScaleDiv &)
Assign a scale division.
void setLabelAlignment(Qt::Alignment)
Change the alignment for the labels.
A class representing a scale division.
Definition: qwt_scale_div.h:33
double invTransform(int axisId, int pos) const
bool axisEnabled(int axisId) const
QwtTransform * transformation() const
void setMargin(int)
Specify the margin to the colorBar/base line.
const QwtScaleDraw * scaleDraw() const
void setLabelRotation(double rotation)
Change the rotation for the labels. See QwtScaleDraw::setLabelRotation().
double maxValue() const
Definition: qwt_interval.h:196
Y axis left of the canvas.
Definition: qwt_plot.h:97
void setAxisScaleDiv(int axisId, const QwtScaleDiv &)
Disable autoscaling and specify a fixed scale for a selected axis.
QList< QwtPlotItem * >::ConstIterator QwtPlotItemIterator
Definition: qwt_plot_dict.h:19
static bool axisValid(int axisId)
Definition: qwt_plot.cpp:882
const QwtScaleWidget * axisWidget(int axisId) const
void setAxisLabelAlignment(int axisId, Qt::Alignment)
bool testItemAttribute(ItemAttribute) const
void setAxisTitle(int axisId, const QString &)
Change the title of a specified axis.
#define min(A, B)
Definition: Log.c:64
#define max(A, B)
Definition: Socket.h:88
The scale is left.
virtual void updateLayout()
Adjust plot content to its current size.
Definition: qwt_plot.cpp:571
void setAxisAutoScale(int axisId, bool on=true)
Enable autoscaling for a specified axis.
void setTitle(const QString &title)
void enableAxis(int axisId, bool tf=true)
Enable or disable a specified axis.
A Widget which contains a scale.
int axisMaxMinor(int axisId) const
void initAxesData()
Initialize axes.
bool isValid() const
Definition: qwt_interval.h:208
A class representing a text.
Definition: qwt_text.h:51
virtual QwtScaleMap canvasMap(int axisId) const
Definition: qwt_plot.cpp:786
double axisStepSize(int axisId) const
Return the step size parameter that has been set in setAxisScale.
bool axisAutoScale(int axisId) const
int yAxis() const
Return yAxis.
QwtScaleDiv scaleDiv
void setAxisScaleEngine(int axisId, QwtScaleEngine *)
void setAxisScale(int axisId, double min, double max, double stepSize=0)
Disable autoscaling and specify a fixed scale for a selected axis.
QwtScaleEngine * scaleEngine
bool testItemInterest(ItemInterest) const
QwtText title() const
Definition: qwt_plot.cpp:348
void setBorderDist(int dist1, int dist2)
const QwtScaleDraw * axisScaleDraw(int axisId) const
Return the scale draw of a specified axis.
AxisData * d_axisData[axisCnt]
Definition: qwt_plot.h:306
double transform(int axisId, double value) const
Transform a value into a coordinate in the plotting region.
The scale is right.
virtual void autoScale(int maxNumSteps, double &x1, double &x2, double &stepSize) const =0
int axisMaxMajor(int axisId) const
void getBorderDistHint(int &start, int &end) const
Calculate a hint for the border distances.
QwtInterval interval() const
QwtScaleEngine * axisScaleEngine(int axisId)
virtual void updateScaleDiv(const QwtScaleDiv &, const QwtScaleDiv &)
Update the item to changes of the axes scale division.
QwtText axisTitle(int axisId) const
A class for drawing scales.
A scale engine for linear scales.
Base class for items on the plot canvas.
Definition: qwt_plot_item.h:65
void setTransformation(QwtTransform *)
virtual QwtScaleDiv divideScale(double x1, double x2, int maxMajorSteps, int maxMinorSteps, double stepSize=0.0) const =0
Calculate a scale division.
QwtText title() const
void setScaleDraw(QwtScaleDraw *)
QwtScaleWidget * scaleWidget
QwtInterval axisInterval(int axisId) const
Return the current interval of the specified axis.
The scale is below.
void updateAxes()
Rebuild the axes scales.
void setAxisMaxMinor(int axisId, int maxMinor)
X axis below the canvas.
Definition: qwt_plot.h:103
Base class for scale engines.
virtual QRectF boundingRect() const


plotjuggler
Author(s): Davide Faconti
autogenerated on Sun Dec 6 2020 03:48:10