qwt_plot_axis.cpp
Go to the documentation of this file.
00001 /* -*- mode: C++ ; c-file-style: "stroustrup" -*- *****************************
00002  * Qwt Widget Library
00003  * Copyright (C) 1997   Josef Wilgen
00004  * Copyright (C) 2002   Uwe Rathmann
00005  *
00006  * This library is free software; you can redistribute it and/or
00007  * modify it under the terms of the Qwt License, Version 1.0
00008  *****************************************************************************/
00009 
00010 #include "qwt_plot.h"
00011 #include "qwt_math.h"
00012 #include "qwt_scale_widget.h"
00013 #include "qwt_scale_div.h"
00014 #include "qwt_scale_engine.h"
00015 
00016 class QwtPlot::AxisData
00017 {
00018 public:
00019     bool isEnabled;
00020     bool doAutoScale;
00021 
00022     double minValue;
00023     double maxValue;
00024     double stepSize;
00025 
00026     int maxMajor;
00027     int maxMinor;
00028 
00029     bool isValid;
00030 
00031     QwtScaleDiv scaleDiv;
00032     QwtScaleEngine *scaleEngine;
00033     QwtScaleWidget *scaleWidget;
00034 };
00035 
00037 void QwtPlot::initAxesData()
00038 {
00039     int axisId;
00040 
00041     for ( axisId = 0; axisId < axisCnt; axisId++ )
00042         d_axisData[axisId] = new AxisData;
00043 
00044     d_axisData[yLeft]->scaleWidget =
00045         new QwtScaleWidget( QwtScaleDraw::LeftScale, this );
00046     d_axisData[yRight]->scaleWidget =
00047         new QwtScaleWidget( QwtScaleDraw::RightScale, this );
00048     d_axisData[xTop]->scaleWidget =
00049         new QwtScaleWidget( QwtScaleDraw::TopScale, this );
00050     d_axisData[xBottom]->scaleWidget =
00051         new QwtScaleWidget( QwtScaleDraw::BottomScale, this );
00052 
00053     d_axisData[yLeft]->scaleWidget->setObjectName( "QwtPlotAxisYLeft" );
00054     d_axisData[yRight]->scaleWidget->setObjectName( "QwtPlotAxisYRight" );
00055     d_axisData[xTop]->scaleWidget->setObjectName( "QwtPlotAxisXTop" );
00056     d_axisData[xBottom]->scaleWidget->setObjectName( "QwtPlotAxisXBottom" );
00057 
00058 #if 1
00059     // better find the font sizes from the application font
00060     QFont fscl( fontInfo().family(), 10 );
00061     QFont fttl( fontInfo().family(), 12, QFont::Bold );
00062 #endif
00063 
00064     for ( axisId = 0; axisId < axisCnt; axisId++ )
00065     {
00066         AxisData &d = *d_axisData[axisId];
00067 
00068         d.scaleEngine = new QwtLinearScaleEngine;
00069 
00070         d.scaleWidget->setTransformation( 
00071             d.scaleEngine->transformation() );
00072 
00073         d.scaleWidget->setFont( fscl );
00074         d.scaleWidget->setMargin( 2 );
00075 
00076         QwtText text = d.scaleWidget->title();
00077         text.setFont( fttl );
00078         d.scaleWidget->setTitle( text );
00079 
00080         d.doAutoScale = true;
00081 
00082         d.minValue = 0.0;
00083         d.maxValue = 1000.0;
00084         d.stepSize = 0.0;
00085 
00086         d.maxMinor = 5;
00087         d.maxMajor = 8;
00088 
00089 
00090         d.isValid = false;
00091     }
00092 
00093     d_axisData[yLeft]->isEnabled = true;
00094     d_axisData[yRight]->isEnabled = false;
00095     d_axisData[xBottom]->isEnabled = true;
00096     d_axisData[xTop]->isEnabled = false;
00097 }
00098 
00099 void QwtPlot::deleteAxesData()
00100 {
00101     for ( int axisId = 0; axisId < axisCnt; axisId++ )
00102     {
00103         delete d_axisData[axisId]->scaleEngine;
00104         delete d_axisData[axisId];
00105         d_axisData[axisId] = NULL;
00106     }
00107 }
00108 
00113 const QwtScaleWidget *QwtPlot::axisWidget( int axisId ) const
00114 {
00115     if ( axisValid( axisId ) )
00116         return d_axisData[axisId]->scaleWidget;
00117 
00118     return NULL;
00119 }
00120 
00125 QwtScaleWidget *QwtPlot::axisWidget( int axisId )
00126 {
00127     if ( axisValid( axisId ) )
00128         return d_axisData[axisId]->scaleWidget;
00129 
00130     return NULL;
00131 }
00132 
00141 void QwtPlot::setAxisScaleEngine( int axisId, QwtScaleEngine *scaleEngine )
00142 {
00143     if ( axisValid( axisId ) && scaleEngine != NULL )
00144     {
00145         AxisData &d = *d_axisData[axisId];
00146 
00147         delete d.scaleEngine;
00148         d.scaleEngine = scaleEngine;
00149 
00150         d_axisData[axisId]->scaleWidget->setTransformation( 
00151             scaleEngine->transformation() );
00152 
00153         d.isValid = false;
00154 
00155         autoRefresh();
00156     }
00157 }
00158 
00163 QwtScaleEngine *QwtPlot::axisScaleEngine( int axisId )
00164 {
00165     if ( axisValid( axisId ) )
00166         return d_axisData[axisId]->scaleEngine;
00167     else
00168         return NULL;
00169 }
00170 
00175 const QwtScaleEngine *QwtPlot::axisScaleEngine( int axisId ) const
00176 {
00177     if ( axisValid( axisId ) )
00178         return d_axisData[axisId]->scaleEngine;
00179     else
00180         return NULL;
00181 }
00186 bool QwtPlot::axisAutoScale( int axisId ) const
00187 {
00188     if ( axisValid( axisId ) )
00189         return d_axisData[axisId]->doAutoScale;
00190     else
00191         return false;
00192 }
00193 
00198 bool QwtPlot::axisEnabled( int axisId ) const
00199 {
00200     if ( axisValid( axisId ) )
00201         return d_axisData[axisId]->isEnabled;
00202     else
00203         return false;
00204 }
00205 
00210 QFont QwtPlot::axisFont( int axisId ) const
00211 {
00212     if ( axisValid( axisId ) )
00213         return axisWidget( axisId )->font();
00214     else
00215         return QFont();
00216 
00217 }
00218 
00224 int QwtPlot::axisMaxMajor( int axisId ) const
00225 {
00226     if ( axisValid( axisId ) )
00227         return d_axisData[axisId]->maxMajor;
00228     else
00229         return 0;
00230 }
00231 
00237 int QwtPlot::axisMaxMinor( int axisId ) const
00238 {
00239     if ( axisValid( axisId ) )
00240         return d_axisData[axisId]->maxMinor;
00241     else
00242         return 0;
00243 }
00244 
00256 const QwtScaleDiv &QwtPlot::axisScaleDiv( int axisId ) const
00257 {
00258     return d_axisData[axisId]->scaleDiv;
00259 }
00260 
00267 const QwtScaleDraw *QwtPlot::axisScaleDraw( int axisId ) const
00268 {
00269     if ( !axisValid( axisId ) )
00270         return NULL;
00271 
00272     return axisWidget( axisId )->scaleDraw();
00273 }
00274 
00281 QwtScaleDraw *QwtPlot::axisScaleDraw( int axisId )
00282 {
00283     if ( !axisValid( axisId ) )
00284         return NULL;
00285 
00286     return axisWidget( axisId )->scaleDraw();
00287 }
00288 
00299 double QwtPlot::axisStepSize( int axisId ) const
00300 {
00301     if ( !axisValid( axisId ) )
00302         return 0;
00303 
00304     return d_axisData[axisId]->stepSize;
00305 }
00306 
00317 QwtInterval QwtPlot::axisInterval( int axisId ) const
00318 {
00319     if ( !axisValid( axisId ) )
00320         return QwtInterval();
00321 
00322     return d_axisData[axisId]->scaleDiv.interval();
00323 }
00324 
00329 QwtText QwtPlot::axisTitle( int axisId ) const
00330 {
00331     if ( axisValid( axisId ) )
00332         return axisWidget( axisId )->title();
00333     else
00334         return QwtText();
00335 }
00336 
00350 void QwtPlot::enableAxis( int axisId, bool tf )
00351 {
00352     if ( axisValid( axisId ) && tf != d_axisData[axisId]->isEnabled )
00353     {
00354         d_axisData[axisId]->isEnabled = tf;
00355         updateLayout();
00356     }
00357 }
00358 
00371 double QwtPlot::invTransform( int axisId, int pos ) const
00372 {
00373     if ( axisValid( axisId ) )
00374         return( canvasMap( axisId ).invTransform( pos ) );
00375     else
00376         return 0.0;
00377 }
00378 
00379 
00388 double QwtPlot::transform( int axisId, double value ) const
00389 {
00390     if ( axisValid( axisId ) )
00391         return( canvasMap( axisId ).transform( value ) );
00392     else
00393         return 0.0;
00394 }
00395 
00404 void QwtPlot::setAxisFont( int axisId, const QFont &font )
00405 {
00406     if ( axisValid( axisId ) )
00407         axisWidget( axisId )->setFont( font );
00408 }
00409 
00423 void QwtPlot::setAxisAutoScale( int axisId, bool on )
00424 {
00425     if ( axisValid( axisId ) && ( d_axisData[axisId]->doAutoScale != on ) )
00426     {
00427         d_axisData[axisId]->doAutoScale = on;
00428         autoRefresh();
00429     }
00430 }
00431 
00447 void QwtPlot::setAxisScale( int axisId, double min, double max, double stepSize )
00448 {
00449     if ( axisValid( axisId ) )
00450     {
00451         AxisData &d = *d_axisData[axisId];
00452 
00453         d.doAutoScale = false;
00454         d.isValid = false;
00455 
00456         d.minValue = min;
00457         d.maxValue = max;
00458         d.stepSize = stepSize;
00459 
00460         autoRefresh();
00461     }
00462 }
00463 
00476 void QwtPlot::setAxisScaleDiv( int axisId, const QwtScaleDiv &scaleDiv )
00477 {
00478     if ( axisValid( axisId ) )
00479     {
00480         AxisData &d = *d_axisData[axisId];
00481 
00482         d.doAutoScale = false;
00483         d.scaleDiv = scaleDiv;
00484         d.isValid = true;
00485 
00486         autoRefresh();
00487     }
00488 }
00489 
00506 void QwtPlot::setAxisScaleDraw( int axisId, QwtScaleDraw *scaleDraw )
00507 {
00508     if ( axisValid( axisId ) )
00509     {
00510         axisWidget( axisId )->setScaleDraw( scaleDraw );
00511         autoRefresh();
00512     }
00513 }
00514 
00523 void QwtPlot::setAxisLabelAlignment( int axisId, Qt::Alignment alignment )
00524 {
00525     if ( axisValid( axisId ) )
00526         axisWidget( axisId )->setLabelAlignment( alignment );
00527 }
00528 
00538 void QwtPlot::setAxisLabelRotation( int axisId, double rotation )
00539 {
00540     if ( axisValid( axisId ) )
00541         axisWidget( axisId )->setLabelRotation( rotation );
00542 }
00543 
00552 void QwtPlot::setAxisMaxMinor( int axisId, int maxMinor )
00553 {
00554     if ( axisValid( axisId ) )
00555     {
00556         maxMinor = qBound( 0, maxMinor, 100 );
00557 
00558         AxisData &d = *d_axisData[axisId];
00559         if ( maxMinor != d.maxMinor )
00560         {
00561             d.maxMinor = maxMinor;
00562             d.isValid = false;
00563             autoRefresh();
00564         }
00565     }
00566 }
00567 
00576 void QwtPlot::setAxisMaxMajor( int axisId, int maxMajor )
00577 {
00578     if ( axisValid( axisId ) )
00579     {
00580         maxMajor = qBound( 1, maxMajor, 10000 );
00581 
00582         AxisData &d = *d_axisData[axisId];
00583         if ( maxMajor != d.maxMajor )
00584         {
00585             d.maxMajor = maxMajor;
00586             d.isValid = false;
00587             autoRefresh();
00588         }
00589     }
00590 }
00591 
00598 void QwtPlot::setAxisTitle( int axisId, const QString &title )
00599 {
00600     if ( axisValid( axisId ) )
00601         axisWidget( axisId )->setTitle( title );
00602 }
00603 
00610 void QwtPlot::setAxisTitle( int axisId, const QwtText &title )
00611 {
00612     if ( axisValid( axisId ) )
00613         axisWidget( axisId )->setTitle( title );
00614 }
00615 
00640 void QwtPlot::updateAxes()
00641 {
00642     // Find bounding interval of the item data
00643     // for all axes, where autoscaling is enabled
00644 
00645     QwtInterval intv[axisCnt];
00646 
00647     const QwtPlotItemList& itmList = itemList();
00648 
00649     QwtPlotItemIterator it;
00650     for ( it = itmList.begin(); it != itmList.end(); ++it )
00651     {
00652         const QwtPlotItem *item = *it;
00653 
00654         if ( !item->testItemAttribute( QwtPlotItem::AutoScale ) )
00655             continue;
00656 
00657         if ( !item->isVisible() )
00658             continue;
00659 
00660         if ( axisAutoScale( item->xAxis() ) || axisAutoScale( item->yAxis() ) )
00661         {
00662             const QRectF rect = item->boundingRect();
00663 
00664             if ( rect.width() >= 0.0 )
00665                 intv[item->xAxis()] |= QwtInterval( rect.left(), rect.right() );
00666 
00667             if ( rect.height() >= 0.0 )
00668                 intv[item->yAxis()] |= QwtInterval( rect.top(), rect.bottom() );
00669         }
00670     }
00671 
00672     // Adjust scales
00673 
00674     for ( int axisId = 0; axisId < axisCnt; axisId++ )
00675     {
00676         AxisData &d = *d_axisData[axisId];
00677 
00678         double minValue = d.minValue;
00679         double maxValue = d.maxValue;
00680         double stepSize = d.stepSize;
00681 
00682         if ( d.doAutoScale && intv[axisId].isValid() )
00683         {
00684             d.isValid = false;
00685 
00686             minValue = intv[axisId].minValue();
00687             maxValue = intv[axisId].maxValue();
00688 
00689             d.scaleEngine->autoScale( d.maxMajor,
00690                 minValue, maxValue, stepSize );
00691         }
00692         if ( !d.isValid )
00693         {
00694             d.scaleDiv = d.scaleEngine->divideScale(
00695                 minValue, maxValue,
00696                 d.maxMajor, d.maxMinor, stepSize );
00697             d.isValid = true;
00698         }
00699 
00700         QwtScaleWidget *scaleWidget = axisWidget( axisId );
00701         scaleWidget->setScaleDiv( d.scaleDiv );
00702 
00703         int startDist, endDist;
00704         scaleWidget->getBorderDistHint( startDist, endDist );
00705         scaleWidget->setBorderDist( startDist, endDist );
00706     }
00707 
00708     for ( it = itmList.begin(); it != itmList.end(); ++it )
00709     {
00710         QwtPlotItem *item = *it;
00711         if ( item->testItemInterest( QwtPlotItem::ScaleInterest ) )
00712         {
00713             item->updateScaleDiv( axisScaleDiv( item->xAxis() ),
00714                 axisScaleDiv( item->yAxis() ) );
00715         }
00716     }
00717 }
00718 


plotjuggler
Author(s): Davide Faconti
autogenerated on Fri Sep 1 2017 02:41:56