/*!
Return a scale division with an interval [lowerBound, upperBound]
where all ticks outside this interval are removed
\param lowerBound Lower bound
\param upperBound Upper bound
\note lowerBound might be greater than upperBound for inverted scales
*/
QwtScaleDiv QwtScaleDiv::bounded(
double lowerBound, double upperBound ) const
{
const double min = qMin( lowerBound, upperBound );
const double max = qMax( lowerBound, upperBound );
QwtScaleDiv sd;
sd.setInterval( lowerBound, upperBound );
for ( int tickType = 0; tickType < QwtScaleDiv::NTickTypes; tickType++ )
{
const QList<double> &ticks = d_ticks[ tickType ];
QList<double> boundedTicks;
for ( int i = 0; i < ticks.size(); i++ )
{
const double tick = ticks[i];
if ( tick >= min && tick <= max )
boundedTicks += tick;
}
sd.setTicks( tickType, boundedTicks );
}
return sd;
}
/*!
\brief Calculate a scale division
\param x1 First interval limit
\param x2 Second interval limit
\param maxMajSteps Maximum for the number of major steps
\param maxMinSteps Maximum number of minor steps
\param stepSize Step size. If stepSize == 0, the scaleEngine
calculates one.
*/
QwtScaleDiv ProbabilityScaleEngine::divideScale(double x1, double x2,
int, int, double stepSize) const
{
QwtDoubleInterval interval = QwtDoubleInterval(x1, x2).normalized();
interval = interval.limited(1e-4, 99.999);
if (interval.width() <= 0 )
return QwtScaleDiv();
stepSize = fabs(qRound(stepSize));
if ( stepSize == 0.0 )
stepSize = 1.0;
QwtScaleDiv scaleDiv;
if ( stepSize != 0.0 ){
QwtValueList ticks[QwtScaleDiv::NTickTypes];
buildTicks(interval, stepSize, ticks);
scaleDiv = QwtScaleDiv(interval, ticks);
}
if ( x1 > x2 )
scaleDiv.invert();
return scaleDiv;
}
void QwtPlotScaleItem::updateBorders()
{
const QwtPlot *plt = plot();
if ( plt == NULL || !d_data->scaleDivFromAxis )
return;
const QRect r = plt->canvas()->contentsRect();
d_data->canvasRectCache = r;
QwtDoubleInterval interval;
if ( d_data->scaleDraw->orientation() == Qt::Horizontal )
{
const QwtScaleMap map = plt->canvasMap(xAxis());
interval.setMinValue(map.invTransform(r.left()));
interval.setMaxValue(map.invTransform(r.right()));
}
else
{
const QwtScaleMap map = plt->canvasMap(yAxis());
interval.setMinValue(map.invTransform(r.bottom()));
interval.setMaxValue(map.invTransform(r.top()));
}
QwtScaleDiv scaleDiv = d_data->scaleDraw->scaleDiv();
scaleDiv.setInterval(interval);
d_data->scaleDraw->setScaleDiv(scaleDiv);
}
Knob::Knob(const QString &title, double min, double max, QWidget *parent):
QWidget(parent)
{
QFont font("Helvetica", 10);
d_knob = new QwtKnob(this);
d_knob->setFont(font);
d_knob->setRange(min, max);
QwtScaleDiv scaleDiv =
d_knob->scaleEngine()->divideScale(min, max, 5, 3);
QList<double> ticks = scaleDiv.ticks(QwtScaleDiv::MajorTick);
if ( ticks.size() > 0 && ticks[0] > min )
{
if ( ticks.first() > min )
ticks.prepend(min);
if ( ticks.last() < max )
ticks.append(max);
}
scaleDiv.setTicks(QwtScaleDiv::MajorTick, ticks);
d_knob->setScale(scaleDiv);
d_knob->setKnobWidth(50);
font.setBold(true);
d_label = new QLabel(title, this);
d_label->setFont(font);
d_label->setAlignment(Qt::AlignTop | Qt::AlignHCenter);
setSizePolicy(QSizePolicy::MinimumExpanding,
QSizePolicy::MinimumExpanding);
connect(d_knob, SIGNAL(valueChanged(double)),
this, SIGNAL(valueChanged(double)));
}
void Graph::saveData(DataFileParser *file)
{
// background color
file->writeBlockIdentifier("graphWBgColor");
file->writeString(getBgColor().name());
// markers
file->writeBlockIdentifier("graphWMarkersX");
saveMarkers(file, QwtPlot::xBottom);
file->writeBlockIdentifier("graphWMarkersY");
saveMarkers(file, QwtPlot::yLeft);
file->writeBlockIdentifier("graphWMarkersYRight");
saveMarkers(file, QwtPlot::yRight);
// axes
file->writeBlockIdentifier("graphWAxisRangeV2");
*file << (quint32)QwtPlot::axisCnt;
for(size_t i = 0; i < QwtPlot::axisCnt; ++i)
{
const QwtScaleDiv div = axisScaleDiv(i);
*file << div.lowerBound();
*file << div.upperBound();
}
}
/*!
\return A scale division with inverted boundaries and ticks
\sa invert()
*/
QwtScaleDiv QwtScaleDiv::inverted() const
{
QwtScaleDiv other = *this;
other.invert();
return other;
}
/*!
\fn xtPlot::slotYmaxChanged(double)
*/
void xyPlot::slotXmaxChanged(double v)
{
const QwtScaleDiv a = plotWidget->axisScaleDiv(QwtPlot::xBottom);
plotWidget->setAxisScale( QwtPlot::xBottom, a.lowerBound(), v);
xminCounter->setRange(-20.0, v);
xminCounter->setSingleStep(0.01);
}
/*!
\brief Calculate a scale division
\param x1 First interval limit
\param x2 Second interval limit
\param maxMajSteps Maximum for the number of major steps
\param maxMinSteps Maximum number of minor steps
\param stepSize Step size. If stepSize == 0, the scaleEngine
calculates one.
\sa QwtScaleEngine::stepSize(), QwtScaleEngine::subDivide()
*/
QwtScaleDiv QwtLinearScaleEngine::divideScale(double x1, double x2,
int maxMajSteps, int maxMinSteps, double stepSize) const
{
QwtDoubleInterval interval = QwtDoubleInterval(x1, x2).normalized();
if (interval.width() <= 0 )
return QwtScaleDiv();
stepSize = qwtAbs(stepSize);
if ( stepSize == 0.0 )
{
if ( maxMajSteps < 1 )
maxMajSteps = 1;
stepSize = divideInterval(interval.width(), maxMajSteps);
}
QwtScaleDiv scaleDiv;
if ( stepSize != 0.0 )
{
QwtValueList ticks[QwtScaleDiv::NTickTypes];
buildTicks(interval, stepSize, maxMinSteps, ticks);
scaleDiv = QwtScaleDiv(interval, ticks);
}
if ( x1 > x2 )
scaleDiv.invert();
return scaleDiv;
}
int ScalePicker::maxLabelWidth(const QwtScale *scale) const
{
QFontMetrics fm(scale->font());
const QwtScaleDraw * scaleDraw=scale->scaleDraw ();
const QwtScaleDiv scaleDiv=scaleDraw->scaleDiv();
const double step_eps = 1.0e-6;
int maxWidth = 0;
for (uint i = 0; i < scaleDiv.majCnt(); i++)
{
double val = scaleDiv.majMark(i);
// correct rounding errors if val = 0
if ((!scaleDiv.logScale())
&& (qwtAbs(val) < step_eps * qwtAbs(scaleDiv.majStep())))
{
val = 0.0;
}
const int w = fm.boundingRect(scaleDraw->label(val)).width();
if ( w > maxWidth )
maxWidth = w;
}
return maxWidth;
}
/*!
\fn xtPlot::slotYminChanged
*/
void xyPlot::slotXminChanged(double v)
{
const QwtScaleDiv a = plotWidget->axisScaleDiv(QwtPlot::xBottom);
plotWidget->setAxisScale( QwtPlot::xBottom, v, a.upperBound());
xmaxCounter->setRange(v, 20.0);
xmaxCounter->setSingleStep(0.01);
}
QVector<double> qwtTickList( const QwtScaleDiv &scaleDiv )
{
QVector<double> values;
double lowerLimit = scaleDiv.interval().minValue();
double upperLimit = scaleDiv.interval().maxValue();
if ( upperLimit < lowerLimit )
qSwap( lowerLimit, upperLimit );
values += lowerLimit;
for ( int tickType = QwtScaleDiv::MinorTick;
tickType < QwtScaleDiv::NTickTypes; tickType++ )
{
const QList<double> ticks = scaleDiv.ticks( tickType );
for ( int i = 0; i < ticks.count(); i++ )
{
const double v = ticks[i];
if ( v > lowerLimit && v < upperLimit )
values += v;
}
}
values += upperLimit;
return values;
}
void VectorPlot::setupPlot(const QwtDoubleRect &rect) {
QwtScaleDiv *hDiv = plot->axisScaleDiv(QwtPlot::xBottom);
QwtScaleDiv *vDiv = plot->axisScaleDiv(QwtPlot::yLeft);
// In earlier qwt version some member function names are different from newer version
#if QWT_VERSION <= 0x050101
double lLimit = std::min(hDiv->lBound(), rect.left());
double rLimit = std::max(hDiv->hBound(), rect.right());
double bLimit = std::min(vDiv->lBound(), rect.bottom());
double tLimit = std::max(vDiv->hBound(), rect.top());
#else
double lLimit = std::min(hDiv->lowerBound(), rect.left());
double rLimit = std::max(hDiv->upperBound(), rect.right());
double bLimit = std::min(vDiv->lowerBound(), rect.bottom());
double tLimit = std::max(vDiv->upperBound(), rect.top());
#endif
plot->setAxisScale(QwtPlot::xBottom, lLimit, rLimit);
plot->setAxisScale(QwtPlot::yLeft, bLimit, tLimit);
double xMargin = plot->invTransform(QwtPlot::xBottom, plot->margin());
double yMargin = plot->invTransform(QwtPlot::yLeft, plot->margin());
mBoundingRect = QwtDoubleRect(QwtDoublePoint(lLimit - xMargin, tLimit + yMargin),
QwtDoublePoint(rLimit + xMargin, bLimit - yMargin));
qDebug() << "xMargin:" << xMargin;
qDebug() << "yMargin:" << yMargin;
qDebug() << "mBoundingRect:" << mBoundingRect;
// mBoundingRect = rect;
}
void OscilloscopePlot::incrementInterval()
{
d_interval = QwtInterval( d_interval.maxValue(),
d_interval.maxValue() + d_interval.width() );
CurveData *data = static_cast<CurveData *>( d_curve->data() );
data->values().clearStaleValues( d_interval.minValue() );
// To avoid, that the grid is jumping, we disable
// the autocalculation of the ticks and shift them
// manually instead.
QwtScaleDiv scaleDiv = axisScaleDiv( QwtPlot::xBottom );
scaleDiv.setInterval( d_interval );
for ( int i = 0; i < QwtScaleDiv::NTickTypes; i++ )
{
QList<double> ticks = scaleDiv.ticks( i );
for ( int j = 0; j < ticks.size(); j++ )
ticks[j] += d_interval.width();
scaleDiv.setTicks( i, ticks );
}
setAxisScaleDiv( QwtPlot::xBottom, scaleDiv );
d_origin->setValue( d_interval.minValue() + d_interval.width() / 2.0, 0.0 );
d_paintedPoints = 0;
replot();
}
void Plot::incrementInterval()
{
d_interval = QwtInterval(d_interval.maxValue(),
d_interval.maxValue() + d_interval.width());
CurveData *data0 = static_cast<CurveData *>( d_curve0->data() );
CurveData *data1 = static_cast<CurveData *>( d_curve1->data() );
data0->clearStaleVal(d_interval.minValue());
data1->clearStaleVal(d_interval.minValue());
QwtScaleDiv scaleDiv = *axisScaleDiv(QwtPlot::xBottom);
scaleDiv.setInterval(d_interval);
for ( int i = 0; i < QwtScaleDiv::NTickTypes; i++ )
{
QList<double> ticks = scaleDiv.ticks(i);
for ( int j = 0; j < ticks.size(); j++ )
ticks[j] += d_interval.width();
scaleDiv.setTicks(i, ticks);
}
setAxisScaleDiv(QwtPlot::xBottom, scaleDiv);
d_origin->setValue(d_interval.minValue() + d_interval.width() / 2.0, 0.0);
d_paintedPoints0 = 0;
d_paintedPoints1 = 0;
replot();
}
/*!
\brief Calculate a scale division for an interval
\param x1 First interval limit
\param x2 Second interval limit
\param maxMajorSteps Maximum for the number of major steps
\param maxMinorSteps Maximum number of minor steps
\param stepSize Step size. If stepSize == 0, the engine
calculates one.
\return Calculated scale division
*/
QwtScaleDiv QwtLogScaleEngine::divideScale( double x1, double x2,
int maxMajorSteps, int maxMinorSteps, double stepSize ) const
{
QwtInterval interval = QwtInterval( x1, x2 ).normalized();
interval = interval.limited( LOG_MIN, LOG_MAX );
if ( interval.width() <= 0 )
return QwtScaleDiv();
const double logBase = base();
if ( interval.maxValue() / interval.minValue() < logBase )
{
// scale width is less than one decade -> build linear scale
QwtLinearScaleEngine linearScaler;
linearScaler.setAttributes( attributes() );
linearScaler.setReference( reference() );
linearScaler.setMargins( lowerMargin(), upperMargin() );
if ( stepSize != 0.0 )
{
if ( stepSize < 0.0 )
stepSize = -qPow( logBase, -stepSize );
else
stepSize = qPow( logBase, stepSize );
}
return linearScaler.divideScale( x1, x2,
maxMajorSteps, maxMinorSteps, stepSize );
}
stepSize = qAbs( stepSize );
if ( stepSize == 0.0 )
{
if ( maxMajorSteps < 1 )
maxMajorSteps = 1;
stepSize = divideInterval(
qwtLogInterval( logBase, interval ).width(), maxMajorSteps );
if ( stepSize < 1.0 )
stepSize = 1.0; // major step must be >= 1 decade
}
QwtScaleDiv scaleDiv;
if ( stepSize != 0.0 )
{
QList<double> ticks[QwtScaleDiv::NTickTypes];
buildTicks( interval, stepSize, maxMinorSteps, ticks );
scaleDiv = QwtScaleDiv( interval, ticks );
}
if ( x1 > x2 )
scaleDiv.invert();
return scaleDiv;
}
void QwtPlotSeriesItem::updateScaleDiv(
const QwtScaleDiv &xScaleDiv, const QwtScaleDiv &yScaleDiv )
{
const QRectF rect = QRectF(
xScaleDiv.lowerBound(), yScaleDiv.lowerBound(),
xScaleDiv.range(), yScaleDiv.range() );
setRectOfInterest( rect );
}
QDebug operator<<( QDebug debug, const QwtScaleDiv &scaleDiv )
{
debug << scaleDiv.lowerBound() << "<->" << scaleDiv.upperBound();
debug << "Major: " << scaleDiv.ticks( QwtScaleDiv::MajorTick );
debug << "Medium: " << scaleDiv.ticks( QwtScaleDiv::MediumTick );
debug << "Minor: " << scaleDiv.ticks( QwtScaleDiv::MinorTick );
return debug;
}
void ScaleDraw::drawTick(QPainter *p, double value, int len) const
{
int axis = this->axis();
ScaleEngine *sc_engine = (ScaleEngine *)d_plot->axisScaleEngine(axis);
if (sc_engine->hasBreak()){
double dlb = sc_engine->axisBreakLeft();
double drb = sc_engine->axisBreakRight();
if ((dlb < value && drb > value) ||
((axis == QwtPlot::yLeft || axis == QwtPlot::xBottom) && value == dlb) ||
((axis == QwtPlot::yRight || axis == QwtPlot::xTop) && value == drb) ||
(sc_engine->testAttribute(QwtScaleEngine::Inverted) && (value == dlb || value == drb)))
return;
if (d_plot->isPrinting()){
QwtScaleMap scaleMap = map();
double val = scaleMap.transform(value);
if (val >= scaleMap.transform(dlb) && val <= scaleMap.transform(drb))
return;
}
}
QwtScaleDiv scDiv = scaleDiv();
QwtValueList majTicks = scDiv.ticks(QwtScaleDiv::MajorTick);
if (majTicks.contains(value)){
if (d_majTicks == In || d_majTicks == None)
return;
switch (d_show_ticks_policy){
case ShowAll:
break;
case HideBegin:
if (majTicks.first() == value)
return;
break;
case HideEnd:
if (majTicks.last() == value)
return;
break;
case HideBeginEnd:
if (majTicks.first() == value || majTicks.last() == value)
return;
break;
}
}
QwtValueList medTicks = scDiv.ticks(QwtScaleDiv::MediumTick);
if (medTicks.contains(value) && (d_minTicks == In || d_minTicks == None))
return;
QwtValueList minTicks = scDiv.ticks(QwtScaleDiv::MinorTick);
if (minTicks.contains(value) && (d_minTicks == In || d_minTicks == None))
return;
QwtScaleDraw::drawTick(p, value, len);
}
void MainWindow::updatePanel()
{
const QwtScaleDiv scaleDiv = d_plot->axisScaleDiv( QwtAxis::yLeft );
Settings settings = d_panel->settings();
settings.startDateTime = QwtDate::toDateTime( scaleDiv.lowerBound(), Qt::LocalTime );
settings.endDateTime = QwtDate::toDateTime( scaleDiv.upperBound(), Qt::LocalTime );
d_panel->setSettings( settings );
}
/*!
\brief Calculate a scale division for a date/time interval
\param x1 First interval limit
\param x2 Second interval limit
\param maxMajorSteps Maximum for the number of major steps
\param maxMinorSteps Maximum number of minor steps
\param stepSize Step size. If stepSize == 0, the scaleEngine
calculates one.
\return Calculated scale division
*/
QwtScaleDiv QwtDateScaleEngine::divideScale( double x1, double x2,
int maxMajorSteps, int maxMinorSteps, double stepSize ) const
{
if ( maxMajorSteps < 1 )
maxMajorSteps = 1;
const double min = qMin( x1, x2 );
const double max = qMax( x1, x2 );
const QDateTime from = toDateTime( min );
const QDateTime to = toDateTime( max );
if ( from == to )
return QwtScaleDiv();
stepSize = qAbs( stepSize );
if ( stepSize > 0.0 )
{
// as interval types above hours are not equidistant
// ( even days might have 23/25 hours because of daylight saving )
// the stepSize is used as a hint only
maxMajorSteps = qCeil( ( max - min ) / stepSize );
}
const QwtDate::IntervalType intvType =
intervalType( from, to, maxMajorSteps );
QwtScaleDiv scaleDiv;
if ( intvType == QwtDate::Millisecond )
{
// for milliseconds and below we can use the decimal system
scaleDiv = QwtLinearScaleEngine::divideScale( min, max,
maxMajorSteps, maxMinorSteps, stepSize );
}
else
{
const QDateTime minDate = QwtDate::floor( from, intvType );
const QDateTime maxDate = QwtDate::ceil( to, intvType );
scaleDiv = buildScaleDiv( minDate, maxDate,
maxMajorSteps, maxMinorSteps, intvType );
// scaleDiv has been calculated from an extended interval
// adjusted to the step size. We have to shrink it again.
scaleDiv = scaleDiv.bounded( min, max );
}
if ( x1 > x2 )
scaleDiv.invert();
return scaleDiv;
}
/*!
\fn xtPlot::slotAutoscaleToggled()
*/
void xyPlot::slotAutoscaleToggled()
{
if(autoscaleCheck->isChecked())
{
// yrange autoscale on
yminCounter->setDisabled(TRUE);
ymaxCounter->setDisabled(TRUE);
xminCounter->setDisabled(TRUE);
xmaxCounter->setDisabled(TRUE);
plotWidget->setAxisAutoScale(QwtPlot::yLeft);
plotWidget->setAxisAutoScale(QwtPlot::xBottom);
}
else
{
// yrange autoscale off
yminCounter->setDisabled(FALSE);
ymaxCounter->setDisabled(FALSE);
xminCounter->setDisabled(FALSE);
xmaxCounter->setDisabled(FALSE);
QwtScaleDiv a = plotWidget->axisScaleDiv(QwtPlot::yLeft);
yminCounter->setValue(a.lowerBound());
ymaxCounter->setValue(a.upperBound());
plotWidget->setAxisScale( QwtPlot::yLeft, a.lowerBound(), a.upperBound());
a = plotWidget->axisScaleDiv(QwtPlot::xBottom);
xminCounter->setValue(a.lowerBound());
xmaxCounter->setValue(a.upperBound());
plotWidget->setAxisScale( QwtPlot::xBottom, a.lowerBound(), a.upperBound());
}
}
void Graph::syncYZeros(int masterAxis, double masterAxisLower, double masterAxisUpper)
{
int slaveAxis = masterAxis == QwtPlot::yLeft ? QwtPlot::yRight : QwtPlot::yLeft;
const QwtScaleDiv divSlave = axisScaleDiv(slaveAxis);
double slaveAxisRange = divSlave.range();
double zeroOff = masterAxisLower/(masterAxisUpper - masterAxisLower);
double lower = slaveAxisRange*zeroOff;
double upper = slaveAxisRange*zeroOff + slaveAxisRange;
setAxisScale(slaveAxis, lower, upper);
}
/*!
\brief Calculate a scale division
\param x1 First interval limit
\param x2 Second interval limit
\param maxMajSteps Maximum for the number of major steps
\param maxMinSteps Maximum number of minor steps
\param stepSize Step size. If stepSize == 0, the scaleEngine
calculates one.
\sa QwtScaleEngine::stepSize, LogTimeScaleEngine::subDivide
*/
QwtScaleDiv LogTimeScaleEngine::divideScale(double x1, double x2,
int maxMajSteps, int maxMinSteps, double stepSize) const
{
QwtDoubleInterval interval = QwtDoubleInterval(x1, x2).normalized();
interval = interval.limited(LOG_MIN, LOG_MAX);
if (interval.width() <= 0 )
return QwtScaleDiv();
if (interval.maxValue() / interval.minValue() < 10.0)
{
// scale width is less than one decade -> build linear scale
QwtLinearScaleEngine linearScaler;
linearScaler.setAttributes(attributes());
linearScaler.setReference(reference());
linearScaler.setMargins(
#if (QWT_VERSION >= 0x050200)
lowerMargin(), upperMargin()
#else
loMargin(), hiMargin()
#endif
);
return linearScaler.divideScale(x1, x2,
maxMajSteps, maxMinSteps, stepSize);
}
stepSize = qwtAbs(stepSize);
if ( stepSize == 0.0 )
{
if ( maxMajSteps < 1 )
maxMajSteps = 1;
stepSize = divideInterval(log10(interval).width(), maxMajSteps);
if ( stepSize < 1.0 )
stepSize = 1.0; // major step must be >= 1 decade
}
QwtScaleDiv scaleDiv;
if ( stepSize != 0.0 )
{
QwtValueList ticks[QwtScaleDiv::NTickTypes];
buildTicks(interval, stepSize, maxMinSteps, ticks);
scaleDiv = QwtScaleDiv(interval, ticks);
}
if ( x1 > x2 )
scaleDiv.invert();
return scaleDiv;
}
vector<double> AxisImp::getMinorTickLocations() const
{
vector<double> minorTicks;
QwtScaleDiv scaleDiv = mScaleDraw.scaleDiv();
QwtValueList minorTickList = scaleDiv.ticks(QwtScaleDiv::MinorTick) + scaleDiv.ticks(QwtScaleDiv::MediumTick);
for (int i = 0; i < minorTickList.size(); ++i)
{
double dValue = minorTickList[i];
minorTicks.push_back(dValue);
}
return minorTicks;
}
virtual void updateScaleDiv( const QwtScaleDiv &xMap,
const QwtScaleDiv &yMap )
{
QList<double> ticks[QwtScaleDiv::NTickTypes];
ticks[QwtScaleDiv::MajorTick] =
xMap.ticks( QwtScaleDiv::MediumTick );
ticks[QwtScaleDiv::MinorTick] =
xMap.ticks( QwtScaleDiv::MinorTick );
QwtPlotGrid::updateScaleDiv(
QwtScaleDiv( xMap.lowerBound(), xMap.upperBound(), ticks ),
yMap );
}
QwtText QwtTextScaleDraw::label(double value) const
{
const QwtScaleDiv scDiv = scaleDiv();
if (!scDiv.contains (value))
return QwtText();
QwtValueList lst = scDiv.ticks (QwtScaleDiv::MajorTick);
lst.pop_front();
lst.pop_back();
int index = lst.indexOf(value);
if (index >= 0 && index < (int)labels.count())
return QwtText(labels[index]);
else
return QwtText();
}
void Spectrogram::showColorScale(int axis, bool on)
{
if (hasColorScale() == on && color_axis == axis)
return;
QwtPlot *plot = this->plot();
if (!plot)
return;
QwtScaleWidget *colorAxis = plot->axisWidget(color_axis);
colorAxis->setColorBarEnabled(false);
color_axis = axis;
// We must switch main and the color scale axes and their respective scales
int xAxis = this->xAxis();
int yAxis = this->yAxis();
int oldMainAxis = yAxis;
if (axis == QwtPlot::xBottom || axis == QwtPlot::xTop)
{
oldMainAxis = xAxis;
xAxis = 5 - color_axis;
}
else if (axis == QwtPlot::yLeft || axis == QwtPlot::yRight)
{
oldMainAxis = yAxis;
yAxis = 1 - color_axis;
}
// First we switch axes
setAxis(xAxis, yAxis);
// Next we switch axes scales
QwtScaleDiv *scDiv = plot->axisScaleDiv(oldMainAxis);
if (axis == QwtPlot::xBottom || axis == QwtPlot::xTop)
plot->setAxisScale(xAxis, scDiv->lBound(), scDiv->hBound());
else if (axis == QwtPlot::yLeft || color_axis == QwtPlot::yRight)
plot->setAxisScale(yAxis, scDiv->lBound(), scDiv->hBound());
colorAxis = plot->axisWidget(color_axis);
plot->setAxisScale(color_axis, data().range().minValue(), data().range().maxValue());
colorAxis->setColorBarEnabled(on);
colorAxis->setColorMap(data().range(), colorMap());
if (!plot->axisEnabled(color_axis))
plot->enableAxis(color_axis);
colorAxis->show();
plot->updateLayout();
}
void ScaleDraw::drawTick(QPainter *p, double value, int len) const
{
QwtScaleDiv scDiv = scaleDiv();
QwtValueList majTicks = scDiv.ticks(QwtScaleDiv::MajorTick);
if (majTicks.contains(value) && (d_majTicks == In || d_majTicks == None))
return;
QwtValueList medTicks = scDiv.ticks(QwtScaleDiv::MediumTick);
if (medTicks.contains(value) && (d_minTicks == In || d_minTicks == None))
return;
QwtValueList minTicks = scDiv.ticks(QwtScaleDiv::MinorTick);
if (minTicks.contains(value) && (d_minTicks == In || d_minTicks == None))
return;
QwtScaleDraw::drawTick(p, value, len);
}
KnobSpin::KnobSpin(const QString &title, double min, double max, double step, QWidget *parent):
QWidget(parent)
{
QFont font("Helvetica", 10);
knob_ = new QwtKnob(this);
knob_->setFont(font);
knob_->setRange(min, max);
QwtScaleDiv scaleDiv =
knob_->scaleEngine()->divideScale(min, max, 5, 3);
QList<double> ticks = scaleDiv.ticks(QwtScaleDiv::MajorTick);
if ( ticks.size() > 0 && ticks[0] > min )
{
if ( ticks.first() > min )
ticks.prepend(min);
if ( ticks.last() < max )
ticks.append(max);
}
scaleDiv.setTicks(QwtScaleDiv::MajorTick, ticks);
knob_->setScale(scaleDiv);
knob_->setKnobWidth(150);
knob_->setStep(step);
spin_ = new QDoubleSpinBox(this);
spin_->setRange(min, max);
spin_->setSingleStep(step);
font.setBold(true);
label_ = new QLabel(title, this);
label_->setFont(font);
label_->setAlignment(Qt::AlignTop | Qt::AlignHCenter);
setSizePolicy(QSizePolicy::MinimumExpanding,
QSizePolicy::MinimumExpanding);
connect(spin_, SIGNAL(valueChanged(double)),
this, SIGNAL(valueChanged(double)));
connect(knob_, SIGNAL(valueChanged(double)),
spin_, SLOT(setValue(double)) );
connect(spin_, SIGNAL(valueChanged(double)),
knob_, SLOT(setValue(double)) );
}
int ScalePicker::maxLabelHeight(const QwtScale *scale) const
{
QFontMetrics fm(scale->font());
const QwtScaleDraw * scaleDraw=scale->scaleDraw ();
const QwtScaleDiv scaleDiv=scaleDraw->scaleDiv();
int maxHeight = 0;
for (uint i = 0; i < scaleDiv.majCnt(); i++)
{
double val = scaleDiv.majMark(i);
const int w = fm.boundingRect(scaleDraw->label(val)).height();
if ( w > maxHeight )
maxHeight = w;
}
return maxHeight;
}
