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(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->setBaselineDist(2);
00061 
00062         QwtText text;
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 
00120 void QwtPlot::setAxisScaleEngine(int axisId, QwtScaleEngine *scaleEngine)
00121 {
00122     if (axisValid(axisId) && scaleEngine != NULL )
00123     {
00124         AxisData &d = *d_axisData[axisId];
00125 
00126         delete d.scaleEngine;
00127         d.scaleEngine = scaleEngine;
00128 
00129         d.scaleDiv.invalidate();
00130 
00131         autoRefresh();
00132     }
00133 }
00134 
00135 QwtScaleEngine *QwtPlot::axisScaleEngine(int axisId)
00136 {
00137     if (axisValid(axisId))
00138         return d_axisData[axisId]->scaleEngine;
00139     else
00140         return NULL;
00141 }
00142 
00143 const QwtScaleEngine *QwtPlot::axisScaleEngine(int axisId) const
00144 {
00145     if (axisValid(axisId))
00146         return d_axisData[axisId]->scaleEngine;
00147     else
00148         return NULL;
00149 }
00154 bool QwtPlot::axisAutoScale(int axisId) const
00155 {
00156     if (axisValid(axisId))
00157         return d_axisData[axisId]->doAutoScale;
00158     else
00159         return false;
00160     
00161 }
00162 
00167 bool QwtPlot::axisEnabled(int axisId) const
00168 {
00169     if (axisValid(axisId))
00170         return d_axisData[axisId]->isEnabled;
00171     else
00172         return false;
00173 }
00174 
00179 QFont QwtPlot::axisFont(int axisId) const
00180 {
00181     if (axisValid(axisId))
00182         return axisWidget(axisId)->font();
00183     else
00184         return QFont();
00185     
00186 }
00187 
00192 int QwtPlot::axisMaxMajor(int axisId) const
00193 {
00194     if (axisValid(axisId))
00195         return d_axisData[axisId]->maxMajor;
00196     else
00197         return 0;
00198 }
00199 
00204 int QwtPlot::axisMaxMinor(int axisId) const
00205 {
00206     if (axisValid(axisId))
00207         return d_axisData[axisId]->maxMinor;
00208     else
00209         return 0;
00210 }
00211 
00217 const QwtScaleDiv *QwtPlot::axisScaleDiv(int axisId) const
00218 {
00219     if (!axisValid(axisId))
00220         return NULL;
00221 
00222     return &d_axisData[axisId]->scaleDiv;
00223 }
00224 
00230 QwtScaleDiv *QwtPlot::axisScaleDiv(int axisId) 
00231 {
00232     if (!axisValid(axisId))
00233         return NULL;
00234 
00235     return &d_axisData[axisId]->scaleDiv;
00236 }
00237 
00244 const QwtScaleDraw *QwtPlot::axisScaleDraw(int axisId) const
00245 {
00246     if (!axisValid(axisId))
00247         return NULL;
00248 
00249     return axisWidget(axisId)->scaleDraw();
00250 }
00251 
00258 QwtScaleDraw *QwtPlot::axisScaleDraw(int axisId) 
00259 {
00260     if (!axisValid(axisId))
00261         return NULL;
00262 
00263     return axisWidget(axisId)->scaleDraw();
00264 }
00265 
00270 QwtText QwtPlot::axisTitle(int axisId) const
00271 {
00272     if (axisValid(axisId))
00273         return axisWidget(axisId)->title();
00274     else
00275         return QwtText();
00276 }
00277 
00290 void QwtPlot::enableAxis(int axisId, bool tf)
00291 {
00292     if (axisValid(axisId) && tf != d_axisData[axisId]->isEnabled)
00293     {
00294         d_axisData[axisId]->isEnabled = tf;
00295         updateLayout();
00296     }
00297 }
00298 
00307 double QwtPlot::invTransform(int axisId, int pos) const
00308 {
00309     if (axisValid(axisId))
00310        return(canvasMap(axisId).invTransform(pos));
00311     else
00312        return 0.0;
00313 }
00314 
00315 
00323 int QwtPlot::transform(int axisId, double value) const
00324 {
00325     if (axisValid(axisId))
00326        return(canvasMap(axisId).transform(value));
00327     else
00328        return 0;
00329     
00330 }
00331 
00339 void QwtPlot::setAxisFont(int axisId, const QFont &f)
00340 {
00341     if (axisValid(axisId))
00342         axisWidget(axisId)->setFont(f);
00343 }
00344 
00354 void QwtPlot::setAxisAutoScale(int axisId)
00355 {
00356     if (axisValid(axisId) && !d_axisData[axisId]->doAutoScale )
00357     {
00358         d_axisData[axisId]->doAutoScale = true;
00359         autoRefresh();
00360     }
00361 }
00362 
00372 void QwtPlot::setAxisScale(int axisId, double min, double max, double stepSize)
00373 {
00374     if (axisValid(axisId))
00375     {
00376         AxisData &d = *d_axisData[axisId];
00377 
00378         d.doAutoScale = false;
00379         d.scaleDiv.invalidate();
00380 
00381         d.minValue = min;
00382         d.maxValue = max;
00383         d.stepSize = stepSize;
00384             
00385         autoRefresh();
00386     }
00387 }
00388 
00395 void QwtPlot::setAxisScaleDiv(int axisId, const QwtScaleDiv &scaleDiv)
00396 {
00397     if (axisValid(axisId))
00398     {
00399         AxisData &d = *d_axisData[axisId];
00400 
00401         d.doAutoScale = false;
00402         d.scaleDiv = scaleDiv;
00403 
00404         autoRefresh();
00405     }
00406 }
00407 
00423 void QwtPlot::setAxisScaleDraw(int axisId, QwtScaleDraw *scaleDraw)
00424 {
00425     if (axisValid(axisId))
00426     {
00427         axisWidget(axisId)->setScaleDraw(scaleDraw);
00428         autoRefresh();
00429     }
00430 }
00431 
00438 #if QT_VERSION < 0x040000
00439 void QwtPlot::setAxisLabelAlignment(int axisId, int alignment)
00440 #else
00441 void QwtPlot::setAxisLabelAlignment(int axisId, Qt::Alignment alignment)
00442 #endif
00443 {
00444     if (axisValid(axisId))
00445         axisWidget(axisId)->setLabelAlignment(alignment);
00446 }
00447 
00455 void QwtPlot::setAxisLabelRotation(int axisId, double rotation)
00456 {
00457     if (axisValid(axisId))
00458         axisWidget(axisId)->setLabelRotation(rotation);
00459 }
00460 
00467 void QwtPlot::setAxisMaxMinor(int axisId, int maxMinor)
00468 {
00469     if (axisValid(axisId))
00470     {
00471         if ( maxMinor < 0 )
00472             maxMinor = 0;
00473         if ( maxMinor > 100 )
00474             maxMinor = 100;
00475             
00476         AxisData &d = *d_axisData[axisId];
00477 
00478         if ( maxMinor != d.maxMinor )
00479         {
00480             d.maxMinor = maxMinor;
00481             d.scaleDiv.invalidate();
00482             autoRefresh();
00483         }
00484     }
00485 }
00486 
00493 void QwtPlot::setAxisMaxMajor(int axisId, int maxMajor)
00494 {
00495     if (axisValid(axisId))
00496     {
00497         if ( maxMajor < 1 )
00498             maxMajor = 1;
00499         if ( maxMajor > 1000 )
00500             maxMajor = 10000;
00501             
00502         AxisData &d = *d_axisData[axisId];
00503         if ( maxMajor != d.maxMinor )
00504         {
00505             d.maxMajor = maxMajor;
00506             d.scaleDiv.invalidate();
00507             autoRefresh();
00508         }
00509     }
00510 }
00511 
00517 void QwtPlot::setAxisTitle(int axisId, const QString &title)
00518 {
00519     if (axisValid(axisId))
00520         axisWidget(axisId)->setTitle(title);
00521 }
00522 
00528 void QwtPlot::setAxisTitle(int axisId, const QwtText &title)
00529 {
00530     if (axisValid(axisId))
00531         axisWidget(axisId)->setTitle(title);
00532 }
00533 
00535 void QwtPlot::updateAxes() 
00536 {
00537     // Find bounding interval of the item data
00538     // for all axes, where autoscaling is enabled
00539     
00540     QwtDoubleInterval intv[axisCnt];
00541 
00542     const QwtPlotItemList& itmList = itemList();
00543 
00544     QwtPlotItemIterator it;
00545     for ( it = itmList.begin(); it != itmList.end(); ++it )
00546     {
00547         const QwtPlotItem *item = *it;
00548 
00549         if ( !item->testItemAttribute(QwtPlotItem::AutoScale) )
00550             continue;
00551 
00552         if ( axisAutoScale(item->xAxis()) || axisAutoScale(item->yAxis()) )
00553         {
00554             const QwtDoubleRect rect = item->boundingRect();
00555             intv[item->xAxis()] |= QwtDoubleInterval(rect.left(), rect.right());
00556             intv[item->yAxis()] |= QwtDoubleInterval(rect.top(), rect.bottom());
00557         }
00558     }
00559 
00560     // Adjust scales
00561 
00562     for (int axisId = 0; axisId < axisCnt; axisId++)
00563     {
00564         AxisData &d = *d_axisData[axisId];
00565 
00566         double minValue = d.minValue;
00567         double maxValue = d.maxValue;
00568         double stepSize = d.stepSize;
00569 
00570         if ( d.doAutoScale && intv[axisId].isValid() )
00571         {
00572             d.scaleDiv.invalidate();
00573 
00574             minValue = intv[axisId].minValue();
00575             maxValue = intv[axisId].maxValue();
00576 
00577             d.scaleEngine->autoScale(d.maxMajor, 
00578                 minValue, maxValue, stepSize);
00579         }
00580         if ( !d.scaleDiv.isValid() )
00581         {
00582             d.scaleDiv = d.scaleEngine->divideScale(
00583                 minValue, maxValue, 
00584                 d.maxMajor, d.maxMinor, stepSize);
00585         }
00586 
00587         QwtScaleWidget *scaleWidget = axisWidget(axisId);
00588         scaleWidget->setScaleDiv(
00589             d.scaleEngine->transformation(), d.scaleDiv);
00590 
00591         int startDist, endDist;
00592         scaleWidget->getBorderDistHint(startDist, endDist);
00593         scaleWidget->setBorderDist(startDist, endDist);
00594     }
00595 
00596     for ( it = itmList.begin(); it != itmList.end(); ++it )
00597     {
00598         QwtPlotItem *item = *it;
00599         item->updateScaleDiv( *axisScaleDiv(item->xAxis()),
00600             *axisScaleDiv(item->yAxis()));
00601     }
00602 }
00603 

Generated on Mon Jan 30 22:16:25 2006 for Qwt User's Guide by  doxygen 1.4.4