mitk: qwt_plot_axis.cpp Source File

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     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(QwtScaleDraw::LeftScale, this);
00044     d_axisData[yRight]->scaleWidget = 
00045         new QwtScaleWidget(QwtScaleDraw::RightScale, this);
00046     d_axisData[xTop]->scaleWidget = 
00047         new QwtScaleWidget(QwtScaleDraw::TopScale, this);
00048     d_axisData[xBottom]->scaleWidget = 
00049         new QwtScaleWidget(QwtScaleDraw::BottomScale, 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->setMargin(2);
00061 
00062         QwtText text = d.scaleWidget->title();
00063         text.setFont(fttl);
00064         d.scaleWidget->setTitle(text);
00065 
00066         d.doAutoScale = true;
00067 
00068         d.minValue = 0.0;
00069         d.maxValue = 1000.0;
00070         d.stepSize = 0.0;
00071 
00072         d.maxMinor = 5;
00073         d.maxMajor = 8;
00074 
00075         d.scaleEngine = new QwtLinearScaleEngine;
00076 
00077         d.scaleDiv.invalidate();
00078     }
00079 
00080     d_axisData[yLeft]->isEnabled = true;
00081     d_axisData[yRight]->isEnabled = false;
00082     d_axisData[xBottom]->isEnabled = true;
00083     d_axisData[xTop]->isEnabled = false;
00084 }
00085 
00086 void QwtPlot::deleteAxesData()
00087 {
00088     for( int axisId = 0; axisId < axisCnt; axisId++)
00089     {
00090         delete d_axisData[axisId]->scaleEngine;
00091         delete d_axisData[axisId];
00092         d_axisData[axisId] = NULL;
00093     }
00094 }
00095 
00100 const QwtScaleWidget *QwtPlot::axisWidget(int axisId) const
00101 {
00102     if (axisValid(axisId))
00103         return d_axisData[axisId]->scaleWidget;
00104 
00105     return NULL;
00106 }
00107 
00112 QwtScaleWidget *QwtPlot::axisWidget(int axisId)
00113 {
00114     if (axisValid(axisId))
00115         return d_axisData[axisId]->scaleWidget;
00116 
00117     return NULL;
00118 }
00119 
00128 void QwtPlot::setAxisScaleEngine(int axisId, QwtScaleEngine *scaleEngine)
00129 {
00130     if (axisValid(axisId) && scaleEngine != NULL )
00131     {
00132         AxisData &d = *d_axisData[axisId];
00133 
00134         delete d.scaleEngine;
00135         d.scaleEngine = scaleEngine;
00136 
00137         d.scaleDiv.invalidate();
00138 
00139         autoRefresh();
00140     }
00141 }
00142 
00147 QwtScaleEngine *QwtPlot::axisScaleEngine(int axisId)
00148 {
00149     if (axisValid(axisId))
00150         return d_axisData[axisId]->scaleEngine;
00151     else
00152         return NULL;
00153 }
00154 
00159 const QwtScaleEngine *QwtPlot::axisScaleEngine(int axisId) const
00160 {
00161     if (axisValid(axisId))
00162         return d_axisData[axisId]->scaleEngine;
00163     else
00164         return NULL;
00165 }
00170 bool QwtPlot::axisAutoScale(int axisId) const
00171 {
00172     if (axisValid(axisId))
00173         return d_axisData[axisId]->doAutoScale;
00174     else
00175         return false;
00176     
00177 }
00178 
00183 bool QwtPlot::axisEnabled(int axisId) const
00184 {
00185     if (axisValid(axisId))
00186         return d_axisData[axisId]->isEnabled;
00187     else
00188         return false;
00189 }
00190 
00195 QFont QwtPlot::axisFont(int axisId) const
00196 {
00197     if (axisValid(axisId))
00198         return axisWidget(axisId)->font();
00199     else
00200         return QFont();
00201     
00202 }
00203 
00209 int QwtPlot::axisMaxMajor(int axisId) const
00210 {
00211     if (axisValid(axisId))
00212         return d_axisData[axisId]->maxMajor;
00213     else
00214         return 0;
00215 }
00216 
00222 int QwtPlot::axisMaxMinor(int axisId) const
00223 {
00224     if (axisValid(axisId))
00225         return d_axisData[axisId]->maxMinor;
00226     else
00227         return 0;
00228 }
00229 
00241 const QwtScaleDiv *QwtPlot::axisScaleDiv(int axisId) const
00242 {
00243     if (!axisValid(axisId))
00244         return NULL;
00245 
00246     return &d_axisData[axisId]->scaleDiv;
00247 }
00248 
00260 QwtScaleDiv *QwtPlot::axisScaleDiv(int axisId) 
00261 {
00262     if (!axisValid(axisId))
00263         return NULL;
00264 
00265     return &d_axisData[axisId]->scaleDiv;
00266 }
00267 
00274 const QwtScaleDraw *QwtPlot::axisScaleDraw(int axisId) const
00275 {
00276     if (!axisValid(axisId))
00277         return NULL;
00278 
00279     return axisWidget(axisId)->scaleDraw();
00280 }
00281 
00288 QwtScaleDraw *QwtPlot::axisScaleDraw(int axisId) 
00289 {
00290     if (!axisValid(axisId))
00291         return NULL;
00292 
00293     return axisWidget(axisId)->scaleDraw();
00294 }
00295 
00306 double QwtPlot::axisStepSize(int axisId) const
00307 {
00308     if (!axisValid(axisId))
00309         return 0;
00310 
00311     return d_axisData[axisId]->stepSize;
00312 }
00313 
00318 QwtText QwtPlot::axisTitle(int axisId) const
00319 {
00320     if (axisValid(axisId))
00321         return axisWidget(axisId)->title();
00322     else
00323         return QwtText();
00324 }
00325 
00338 void QwtPlot::enableAxis(int axisId, bool tf)
00339 {
00340     if (axisValid(axisId) && tf != d_axisData[axisId]->isEnabled)
00341     {
00342         d_axisData[axisId]->isEnabled = tf;
00343         updateLayout();
00344     }
00345 }
00346 
00355 double QwtPlot::invTransform(int axisId, int pos) const
00356 {
00357     if (axisValid(axisId))
00358        return(canvasMap(axisId).invTransform(pos));
00359     else
00360        return 0.0;
00361 }
00362 
00363 
00371 int QwtPlot::transform(int axisId, double value) const
00372 {
00373     if (axisValid(axisId))
00374        return(canvasMap(axisId).transform(value));
00375     else
00376        return 0;
00377     
00378 }
00379 
00387 void QwtPlot::setAxisFont(int axisId, const QFont &f)
00388 {
00389     if (axisValid(axisId))
00390         axisWidget(axisId)->setFont(f);
00391 }
00392 
00402 void QwtPlot::setAxisAutoScale(int axisId)
00403 {
00404     if (axisValid(axisId) && !d_axisData[axisId]->doAutoScale )
00405     {
00406         d_axisData[axisId]->doAutoScale = true;
00407         autoRefresh();
00408     }
00409 }
00410 
00420 void QwtPlot::setAxisScale(int axisId, double min, double max, double stepSize)
00421 {
00422     if (axisValid(axisId))
00423     {
00424         AxisData &d = *d_axisData[axisId];
00425 
00426         d.doAutoScale = false;
00427         d.scaleDiv.invalidate();
00428 
00429         d.minValue = min;
00430         d.maxValue = max;
00431         d.stepSize = stepSize;
00432             
00433         autoRefresh();
00434     }
00435 }
00436 
00443 void QwtPlot::setAxisScaleDiv(int axisId, const QwtScaleDiv &scaleDiv)
00444 {
00445     if (axisValid(axisId))
00446     {
00447         AxisData &d = *d_axisData[axisId];
00448 
00449         d.doAutoScale = false;
00450         d.scaleDiv = scaleDiv;
00451 
00452         autoRefresh();
00453     }
00454 }
00455 
00471 void QwtPlot::setAxisScaleDraw(int axisId, QwtScaleDraw *scaleDraw)
00472 {
00473     if (axisValid(axisId))
00474     {
00475         axisWidget(axisId)->setScaleDraw(scaleDraw);
00476         autoRefresh();
00477     }
00478 }
00479 
00486 #if QT_VERSION < 0x040000
00487 void QwtPlot::setAxisLabelAlignment(int axisId, int alignment)
00488 #else
00489 void QwtPlot::setAxisLabelAlignment(int axisId, Qt::Alignment alignment)
00490 #endif
00491 {
00492     if (axisValid(axisId))
00493         axisWidget(axisId)->setLabelAlignment(alignment);
00494 }
00495 
00503 void QwtPlot::setAxisLabelRotation(int axisId, double rotation)
00504 {
00505     if (axisValid(axisId))
00506         axisWidget(axisId)->setLabelRotation(rotation);
00507 }
00508 
00516 void QwtPlot::setAxisMaxMinor(int axisId, int maxMinor)
00517 {
00518     if (axisValid(axisId))
00519     {
00520         if ( maxMinor < 0 )
00521             maxMinor = 0;
00522         if ( maxMinor > 100 )
00523             maxMinor = 100;
00524             
00525         AxisData &d = *d_axisData[axisId];
00526 
00527         if ( maxMinor != d.maxMinor )
00528         {
00529             d.maxMinor = maxMinor;
00530             d.scaleDiv.invalidate();
00531             autoRefresh();
00532         }
00533     }
00534 }
00535 
00543 void QwtPlot::setAxisMaxMajor(int axisId, int maxMajor)
00544 {
00545     if (axisValid(axisId))
00546     {
00547         if ( maxMajor < 1 )
00548             maxMajor = 1;
00549         if ( maxMajor > 1000 )
00550             maxMajor = 10000;
00551             
00552         AxisData &d = *d_axisData[axisId];
00553         if ( maxMajor != d.maxMinor )
00554         {
00555             d.maxMajor = maxMajor;
00556             d.scaleDiv.invalidate();
00557             autoRefresh();
00558         }
00559     }
00560 }
00561 
00567 void QwtPlot::setAxisTitle(int axisId, const QString &title)
00568 {
00569     if (axisValid(axisId))
00570         axisWidget(axisId)->setTitle(title);
00571 }
00572 
00578 void QwtPlot::setAxisTitle(int axisId, const QwtText &title)
00579 {
00580     if (axisValid(axisId))
00581         axisWidget(axisId)->setTitle(title);
00582 }
00583 
00585 void QwtPlot::updateAxes() 
00586 {
00587     // Find bounding interval of the item data
00588     // for all axes, where autoscaling is enabled
00589     
00590     QwtDoubleInterval intv[axisCnt];
00591 
00592     const QwtPlotItemList& itmList = itemList();
00593 
00594     QwtPlotItemIterator it;
00595     for ( it = itmList.begin(); it != itmList.end(); ++it )
00596     {
00597         const QwtPlotItem *item = *it;
00598 
00599         if ( !item->testItemAttribute(QwtPlotItem::AutoScale) )
00600             continue;
00601 
00602         if ( axisAutoScale(item->xAxis()) || axisAutoScale(item->yAxis()) )
00603         {
00604             const QwtDoubleRect rect = item->boundingRect();
00605             intv[item->xAxis()] |= QwtDoubleInterval(rect.left(), rect.right());
00606             intv[item->yAxis()] |= QwtDoubleInterval(rect.top(), rect.bottom());
00607         }
00608     }
00609 
00610     // Adjust scales
00611 
00612     for (int axisId = 0; axisId < axisCnt; axisId++)
00613     {
00614         AxisData &d = *d_axisData[axisId];
00615 
00616         double minValue = d.minValue;
00617         double maxValue = d.maxValue;
00618         double stepSize = d.stepSize;
00619 
00620         if ( d.doAutoScale && intv[axisId].isValid() )
00621         {
00622             d.scaleDiv.invalidate();
00623 
00624             minValue = intv[axisId].minValue();
00625             maxValue = intv[axisId].maxValue();
00626 
00627             d.scaleEngine->autoScale(d.maxMajor, 
00628                 minValue, maxValue, stepSize);
00629         }
00630         if ( !d.scaleDiv.isValid() )
00631         {
00632             d.scaleDiv = d.scaleEngine->divideScale(
00633                 minValue, maxValue, 
00634                 d.maxMajor, d.maxMinor, stepSize);
00635         }
00636 
00637         QwtScaleWidget *scaleWidget = axisWidget(axisId);
00638         scaleWidget->setScaleDiv(
00639             d.scaleEngine->transformation(), d.scaleDiv);
00640 
00641         int startDist, endDist;
00642         scaleWidget->getBorderDistHint(startDist, endDist);
00643         scaleWidget->setBorderDist(startDist, endDist);
00644     }
00645 
00646     for ( it = itmList.begin(); it != itmList.end(); ++it )
00647     {
00648         QwtPlotItem *item = *it;
00649         item->updateScaleDiv( *axisScaleDiv(item->xAxis()),
00650             *axisScaleDiv(item->yAxis()));
00651     }
00652 }
00653