Main Page | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Class Members | File Members | Related Pages

qwt_plot_axis.cpp

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     QwtScaleDiv scaleDiv;
00030     QwtScaleEngine *scaleEngine;
00031     QwtScaleWidget *scaleWidget;
00032 };
00033 
00035 void QwtPlot::initAxesData()
00036 {
00037     int axisId;
00038 
00039     for( axisId = 0; axisId < axisCnt; axisId++)
00040         d_axisData[axisId] = new AxisData;
00041 
00042     d_axisData[yLeft]->scaleWidget = 
00043         new QwtScaleWidget(QwtScaleWidget::Left, this);
00044     d_axisData[yRight]->scaleWidget = 
00045         new QwtScaleWidget(QwtScaleWidget::Right, this);
00046     d_axisData[xTop]->scaleWidget = 
00047         new QwtScaleWidget(QwtScaleWidget::Top, this);
00048     d_axisData[xBottom]->scaleWidget = 
00049         new QwtScaleWidget(QwtScaleWidget::Bottom, this);
00050 
00051 
00052     QFont fscl(fontInfo().family(), 10);
00053     QFont fttl(fontInfo().family(), 12, QFont::Bold);
00054 
00055     for(axisId = 0; axisId < axisCnt; axisId++)
00056     {
00057         AxisData &d = *d_axisData[axisId];
00058 
00059         d.scaleWidget->setFont(fscl);
00060         d.scaleWidget->setTitleFont(fttl);
00061         d.scaleWidget->setBaselineDist(2);
00062 
00063         d.doAutoScale = true;
00064 
00065         d.minValue = 0.0;
00066         d.maxValue = 1000.0;
00067         d.stepSize = 0.0;
00068 
00069         d.maxMinor = 5;
00070         d.maxMajor = 8;
00071 
00072         d.scaleEngine = new QwtLinearScaleEngine;
00073 
00074         d.scaleDiv.invalidate();
00075     }
00076 
00077     d_axisData[yLeft]->isEnabled = true;
00078     d_axisData[yRight]->isEnabled = false;
00079     d_axisData[xBottom]->isEnabled = true;
00080     d_axisData[xTop]->isEnabled = false;
00081 }
00082 
00083 void QwtPlot::deleteAxesData()
00084 {
00085     for( int axisId = 0; axisId < axisCnt; axisId++)
00086     {
00087         delete d_axisData[axisId]->scaleEngine;
00088         delete d_axisData[axisId];
00089         d_axisData[axisId] = NULL;
00090     }
00091 }
00092 
00097 const QwtScaleWidget *QwtPlot::axisWidget(int axisId) const
00098 {
00099     if (axisValid(axisId))
00100         return d_axisData[axisId]->scaleWidget;
00101 
00102     return NULL;
00103 }
00104 
00109 QwtScaleWidget *QwtPlot::axisWidget(int axisId)
00110 {
00111     if (axisValid(axisId))
00112         return d_axisData[axisId]->scaleWidget;
00113 
00114     return NULL;
00115 }
00116 
00117 void QwtPlot::setAxisScaleEngine(int axisId, QwtScaleEngine *scaleEngine)
00118 {
00119     if (axisValid(axisId) && scaleEngine != NULL )
00120     {
00121         AxisData &d = *d_axisData[axisId];
00122 
00123         delete d.scaleEngine;
00124         d.scaleEngine = scaleEngine;
00125 
00126         d.scaleDiv.invalidate();
00127 
00128         autoRefresh();
00129     }
00130 }
00131 
00132 QwtScaleEngine *QwtPlot::axisScaleEngine(int axisId)
00133 {
00134     if (axisValid(axisId))
00135         return d_axisData[axisId]->scaleEngine;
00136     else
00137         return NULL;
00138 }
00139 
00140 const QwtScaleEngine *QwtPlot::axisScaleEngine(int axisId) const
00141 {
00142     if (axisValid(axisId))
00143         return d_axisData[axisId]->scaleEngine;
00144     else
00145         return NULL;
00146 }
00151 bool QwtPlot::axisAutoScale(int axisId) const
00152 {
00153     if (axisValid(axisId))
00154         return d_axisData[axisId]->doAutoScale;
00155     else
00156         return false;
00157     
00158 }
00159 
00164 bool QwtPlot::axisEnabled(int axisId) const
00165 {
00166     if (axisValid(axisId))
00167         return d_axisData[axisId]->isEnabled;
00168     else
00169         return false;
00170 }
00171 
00176 QFont QwtPlot::axisFont(int axisId) const
00177 {
00178     if (axisValid(axisId))
00179         return axisWidget(axisId)->font();
00180     else
00181         return QFont();
00182     
00183 }
00184 
00189 int QwtPlot::axisMaxMajor(int axisId) const
00190 {
00191     if (axisValid(axisId))
00192         return d_axisData[axisId]->maxMajor;
00193     else
00194         return 0;
00195 }
00196 
00201 int QwtPlot::axisMaxMinor(int axisId) const
00202 {
00203     if (axisValid(axisId))
00204         return d_axisData[axisId]->maxMinor;
00205     else
00206         return 0;
00207 }
00208 
00214 const QwtScaleDiv *QwtPlot::axisScaleDiv(int axisId) const
00215 {
00216     if (!axisValid(axisId))
00217         return NULL;
00218 
00219     return &d_axisData[axisId]->scaleDiv;
00220 }
00221 
00227 QwtScaleDiv *QwtPlot::axisScaleDiv(int axisId) 
00228 {
00229     if (!axisValid(axisId))
00230         return NULL;
00231 
00232     return &d_axisData[axisId]->scaleDiv;
00233 }
00234 
00241 const QwtScaleDraw *QwtPlot::axisScaleDraw(int axisId) const
00242 {
00243     if (!axisValid(axisId))
00244         return NULL;
00245 
00246     return axisWidget(axisId)->scaleDraw();
00247 }
00248 
00257 void QwtPlot::axisLabelFormat(int axisId, char &f, 
00258     int &prec, int &fieldwidth) const
00259 {
00260     if (axisValid(axisId))
00261         axisWidget(axisId)->labelFormat(f, prec, fieldwidth);
00262     else
00263     {
00264        // to do something useful for a bad call we
00265        // return the default values of QwtScaleDraw
00266         f = 'g'; 
00267         prec = 4;
00268         fieldwidth = 0;
00269     }
00270 }
00271 
00276 QString QwtPlot::axisTitle(int axisId) const
00277 {
00278     if (axisValid(axisId))
00279         return axisWidget(axisId)->title();
00280     else
00281         return QString::null;
00282 }
00283 
00288 QFont QwtPlot::axisTitleFont(int axisId) const
00289 {
00290     if (axisValid(axisId))
00291         return axisWidget(axisId)->titleFont();
00292     else
00293         return QFont();
00294 }
00295 
00301 int QwtPlot::axisTitleFlags(int axisId) const
00302 {
00303     if (axisValid(axisId))
00304         return axisWidget(axisId)->titleFlags();
00305     else
00306         return 0;
00307 }
00308 
00321 void QwtPlot::enableAxis(int axisId, bool tf)
00322 {
00323     if (axisValid(axisId) && tf != d_axisData[axisId]->isEnabled)
00324     {
00325         d_axisData[axisId]->isEnabled = tf;
00326         updateLayout();
00327     }
00328 }
00329 
00338 double QwtPlot::invTransform(int axisId, int pos) const
00339 {
00340     if (axisValid(axisId))
00341        return(canvasMap(axisId).invTransform(pos));
00342     else
00343        return 0.0;
00344 }
00345 
00346 
00354 int QwtPlot::transform(int axisId, double value) const
00355 {
00356     if (axisValid(axisId))
00357        return(canvasMap(axisId).transform(value));
00358     else
00359        return 0;
00360     
00361 }
00362 
00370 void QwtPlot::setAxisFont(int axisId, const QFont &f)
00371 {
00372     if (axisValid(axisId))
00373         axisWidget(axisId)->setFont(f);
00374 }
00375 
00385 void QwtPlot::setAxisAutoScale(int axisId)
00386 {
00387     if (axisValid(axisId) && !d_axisData[axisId]->doAutoScale )
00388     {
00389         d_axisData[axisId]->doAutoScale = true;
00390         autoRefresh();
00391     }
00392 }
00393 
00403 void QwtPlot::setAxisScale(int axisId, double min, double max, double stepSize)
00404 {
00405     if (axisValid(axisId))
00406     {
00407         AxisData &d = *d_axisData[axisId];
00408 
00409         d.doAutoScale = false;
00410         d.scaleDiv.invalidate();
00411 
00412         d.minValue = min;
00413         d.maxValue = max;
00414         d.stepSize = stepSize;
00415             
00416         autoRefresh();
00417     }
00418 }
00419 
00426 void QwtPlot::setAxisScaleDiv(int axisId, const QwtScaleDiv &scaleDiv)
00427 {
00428     if (axisValid(axisId))
00429     {
00430         AxisData &d = *d_axisData[axisId];
00431 
00432         d.doAutoScale = false;
00433         d.scaleDiv = scaleDiv;
00434 
00435         autoRefresh();
00436     }
00437 }
00438 
00454 void QwtPlot::setAxisScaleDraw(int axisId, QwtScaleDraw *scaleDraw)
00455 {
00456     if (axisValid(axisId))
00457     {
00458         axisWidget(axisId)->setScaleDraw(scaleDraw);
00459         autoRefresh();
00460     }
00461 }
00462 
00471 void QwtPlot::setAxisLabelFormat(int axisId, char f, int prec, int fieldwidth)
00472 {
00473     if (axisValid(axisId))
00474         axisWidget(axisId)->setLabelFormat(f, prec, fieldwidth);
00475 }
00476 
00483 void QwtPlot::setAxisLabelFlags(int axisId, int flags)
00484 {
00485     if (axisValid(axisId))
00486         axisWidget(axisId)->setLabelFlags(flags);
00487 }
00488 
00496 void QwtPlot::setAxisLabelRotation(int axisId, double rotation)
00497 {
00498     if (axisValid(axisId))
00499         axisWidget(axisId)->setLabelRotation(rotation);
00500 }
00501 
00507 void QwtPlot::setAxisTitleFont(int axisId, const QFont &f)
00508 {
00509     if (axisValid(axisId))
00510         axisWidget(axisId)->setTitleFont(f);
00511 }
00512 
00519 void QwtPlot::setAxisTitleFlags(int axisId, int flags)
00520 {
00521     if (axisValid(axisId))
00522         axisWidget(axisId)->setTitleFlags(flags);
00523 }
00524 
00525 
00532 void QwtPlot::setAxisMaxMinor(int axisId, int maxMinor)
00533 {
00534     if (axisValid(axisId))
00535     {
00536         if ( maxMinor < 0 )
00537             maxMinor = 0;
00538         if ( maxMinor > 100 )
00539             maxMinor = 100;
00540             
00541         AxisData &d = *d_axisData[axisId];
00542 
00543         if ( maxMinor != d.maxMinor )
00544         {
00545             d.maxMinor = maxMinor;
00546             d.scaleDiv.invalidate();
00547             autoRefresh();
00548         }
00549     }
00550 }
00551 
00558 void QwtPlot::setAxisMaxMajor(int axisId, int maxMajor)
00559 {
00560     if (axisValid(axisId))
00561     {
00562         if ( maxMajor < 1 )
00563             maxMajor = 1;
00564         if ( maxMajor > 1000 )
00565             maxMajor = 10000;
00566             
00567         AxisData &d = *d_axisData[axisId];
00568         if ( maxMajor != d.maxMinor )
00569         {
00570             d.maxMajor = maxMajor;
00571             d.scaleDiv.invalidate();
00572             autoRefresh();
00573         }
00574     }
00575 }
00576 
00582 void QwtPlot::setAxisTitle(int axisId, const QString &t)
00583 {
00584     if (axisValid(axisId))
00585         axisWidget(axisId)->setTitle(t);
00586 }
00587 
00589 void QwtPlot::updateAxes() 
00590 {
00591     // Find bounding interval of the item data
00592     // for all axes, where autoscaling is enabled
00593     
00594     QwtDoubleInterval intv[axisCnt];
00595 
00596     const QwtPlotItemList& itmList = itemList();
00597 
00598     QwtPlotItemIterator it;
00599     for ( it = itmList.begin(); it != itmList.end(); ++it )
00600     {
00601         const QwtPlotItem *item = *it;
00602 
00603         if ( !item->testItemAttribute(QwtPlotItem::AutoScale) )
00604             continue;
00605 
00606         if ( axisAutoScale(item->xAxis()) || axisAutoScale(item->yAxis()) )
00607         {
00608             const QwtDoubleRect rect = item->boundingRect();
00609             intv[item->xAxis()] |= QwtDoubleInterval(rect.left(), rect.right());
00610             intv[item->yAxis()] |= QwtDoubleInterval(rect.top(), rect.bottom());
00611         }
00612     }
00613 
00614     // Adjust scales
00615 
00616     for (int axisId = 0; axisId < axisCnt; axisId++)
00617     {
00618         AxisData &d = *d_axisData[axisId];
00619 
00620         double minValue = d.minValue;
00621         double maxValue = d.maxValue;
00622         double stepSize = d.stepSize;
00623 
00624         if ( d.doAutoScale && intv[axisId].isValid() )
00625         {
00626             d.scaleDiv.invalidate();
00627 
00628             minValue = intv[axisId].minValue();
00629             maxValue = intv[axisId].maxValue();
00630 
00631             d.scaleEngine->autoScale(d.maxMajor, 
00632                 minValue, maxValue, stepSize);
00633         }
00634         if ( !d.scaleDiv.isValid() )
00635         {
00636             d.scaleDiv = d.scaleEngine->divideScale(
00637                 minValue, maxValue, 
00638                 d.maxMajor, d.maxMinor, stepSize);
00639         }
00640 
00641         QwtScaleWidget *scaleWidget = axisWidget(axisId);
00642         scaleWidget->setScaleDiv(
00643             d.scaleEngine->transformation(), d.scaleDiv);
00644 
00645         int startDist, endDist;
00646         scaleWidget->minBorderDist(startDist, endDist);
00647         scaleWidget->setBorderDist(startDist, endDist);
00648     }
00649 
00650     for ( it = itmList.begin(); it != itmList.end(); ++it )
00651     {
00652         QwtPlotItem *item = *it;
00653         item->updateScaleDiv( *axisScaleDiv(item->xAxis()),
00654             *axisScaleDiv(item->yAxis()));
00655     }
00656 }
00657 

Generated on Wed Aug 31 23:02:29 2005 for Qwt User's Guide by  doxygen 1.4.1