/*!
\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 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 QwtPlotSeriesItem::updateScaleDiv(
const QwtScaleDiv &xScaleDiv, const QwtScaleDiv &yScaleDiv )
{
const QRectF rect = QRectF(
xScaleDiv.lowerBound(), yScaleDiv.lowerBound(),
xScaleDiv.range(), yScaleDiv.range() );
setRectOfInterest( rect );
}
/*!
\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);
}
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();
}
}
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 Spectrogram::showColorScale(int axis, bool on)
{
if (hasColorScale() == on && color_axis == axis)
return;
if (!d_graph)
return;
QwtScaleWidget *colorAxis = d_graph->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 = QwtPlot::xBottom;
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 = d_graph->axisScaleDiv(oldMainAxis);
if (axis == QwtPlot::xBottom || axis == QwtPlot::xTop)
d_graph->setAxisScale(xAxis, scDiv->lowerBound(), scDiv->upperBound());
else if (axis == QwtPlot::yLeft || color_axis == QwtPlot::yRight)
d_graph->setAxisScale(yAxis, scDiv->lowerBound(), scDiv->upperBound());
colorAxis = d_graph->axisWidget(color_axis);
d_graph->setAxisScale(color_axis, range().minValue(), range().maxValue());
colorAxis->setColorBarEnabled(on);
colorAxis->setColorMap(range(), colorMap());
if (!d_graph->axisEnabled(color_axis))
d_graph->enableAxis(color_axis);
colorAxis->show();
d_graph->updateLayout();
}
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 );
}
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 );
}
void QwtPolarGrid::updateScaleDiv( const QwtScaleDiv &azimuthScaleDiv,
const QwtScaleDiv &radialScaleDiv, const QwtDoubleInterval &interval )
{
GridData &radialGrid = d_data->gridData[QwtPolar::Radius];
const QwtPolarPlot *plt = plot();
if ( plt && testGridAttribute( AutoScaling ) )
{
const QwtScaleEngine *se = plt->scaleEngine( QwtPolar::Radius );
radialGrid.scaleDiv = se->divideScale(
interval.minValue(), interval.maxValue(),
plt->scaleMaxMajor( QwtPolar::Radius ),
plt->scaleMaxMinor( QwtPolar::Radius ), 0 );
}
else
{
if ( radialGrid.scaleDiv != radialScaleDiv )
radialGrid.scaleDiv = radialScaleDiv;
}
GridData &azimuthGrid = d_data->gridData[QwtPolar::Azimuth];
if ( azimuthGrid.scaleDiv != azimuthScaleDiv )
{
azimuthGrid.scaleDiv = azimuthScaleDiv;
}
bool hasOrigin = false;
for ( int axisId = 0; axisId < QwtPolar::AxesCount; axisId++ )
{
AxisData &axis = d_data->axisData[axisId];
if ( axis.isVisible && axis.scaleDraw )
{
if ( axisId == QwtPolar::AxisAzimuth )
{
axis.scaleDraw->setScaleDiv( azimuthGrid.scaleDiv );
if ( testDisplayFlag( SmartScaleDraw ) )
{
axis.scaleDraw->enableComponent(
QwtAbstractScaleDraw::Ticks, !azimuthGrid.isVisible );
}
}
else
{
QwtScaleDiv sd = radialGrid.scaleDiv;
QwtValueList &ticks =
( QwtValueList & )sd.ticks( QwtScaleDiv::MajorTick );
if ( testDisplayFlag( SmartOriginLabel ) )
{
bool skipOrigin = hasOrigin;
if ( !skipOrigin )
{
if ( axisId == QwtPolar::AxisLeft
|| axisId == QwtPolar::AxisRight )
{
if ( d_data->axisData[QwtPolar::AxisBottom].isVisible )
skipOrigin = true;
}
else
{
if ( d_data->axisData[QwtPolar::AxisLeft].isVisible )
skipOrigin = true;
}
}
#if QWT_VERSION < 0x050200
if ( ticks.size() > 0 && ticks.first() == sd.lBound() )
#else
if ( ticks.size() > 0 && ticks.first() == sd.lowerBound() )
#endif
{
if ( skipOrigin )
{
#if QT_VERSION < 0x040000
ticks.pop_front();
#else
ticks.removeFirst();
#endif
}
else
hasOrigin = true;
}
}
if ( testDisplayFlag( HideMaxRadiusLabel ) )
{
#if QWT_VERSION < 0x050200
if ( ticks.size() > 0 && ticks.last() == sd.hBound() )
#else
if ( ticks.size() > 0 && ticks.last() == sd.upperBound() )
#endif
#if QT_VERSION < 0x040000
ticks.pop_back();
#else
ticks.removeLast();
#endif
}
axis.scaleDraw->setScaleDiv( sd );
if ( testDisplayFlag( SmartScaleDraw ) )
{
axis.scaleDraw->enableComponent(
QwtAbstractScaleDraw::Ticks, !radialGrid.isVisible );
}
}
}
}
}
/*!
Change the scale division
\param scaleDiv New scale division
*/
void QwtAbstractScaleDraw::setScaleDiv( const QwtScaleDiv &scaleDiv )
{
d_data->scaleDiv = scaleDiv;
d_data->map.setScaleInterval( scaleDiv.lowerBound(), scaleDiv.upperBound() );
d_data->labelCache.clear();
}
void Graph::syncYZeros()
{
const QwtScaleDiv div = axisScaleDiv(QwtPlot::yLeft);
syncYZeros(QwtPlot::yLeft, div.lowerBound(), div.upperBound());
}
double AxisImp::getMinimumValue() const
{
QwtScaleDiv scaleDiv = mScaleDraw.scaleDiv();
return scaleDiv.lowerBound();
}
int
CurveOHLC::draw (QPainter *painter, const QwtScaleMap &xMap, const QwtScaleMap &yMap, const QRect &, void *c)
{
Curve *curve = (Curve *) c;
QwtScaleDiv *sd = curve->plot()->axisScaleDiv(QwtPlot::xBottom);
if (! g_symbol)
{
qDebug() << "CurveOHLC::draw: bars missing";
return 0;
}
int loop = sd->lowerBound();
int size = sd->upperBound();
bool ff = FALSE;
for (; loop < size; loop++)
{
OHLCBar *b = (OHLCBar *) curve->bar(loop);
if (! b)
continue;
painter->setPen(b->color());
int x = xMap.transform(loop);
int width = xMap.transform(loop + 1) - x;
int yo = yMap.transform(b->open());
int yh = yMap.transform(b->high());
int yl = yMap.transform(b->low());
int yc = yMap.transform(b->close());
switch ((CurveOHLCType::Key) curve->style())
{
case CurveOHLCType::_OHLC:
{
QRect rect(QPoint(x + 1, yh), QPoint(x + width - 1, yl));
painter->drawLine (rect.center().x(), yh, rect.center().x(), yl); // draw the high/low line
painter->drawLine (rect.left(), yo, rect.center().x(), yo); // draw the open tick
painter->drawLine (rect.right(), yc, rect.center().x(), yc); // draw the close tick
break;
}
default: // Candle
{
ff = FALSE;
if (b->close() < b->open())
ff = TRUE;
if (! ff)
{
// empty candle c > o
QRect rect(QPoint(x + 2, yc), QPoint(x + width - 2, yo));
painter->drawLine (rect.center().x(), yh, rect.center().x(), yl);
painter->setBrush(curve->plot()->canvasBackground());
painter->drawRect(rect);
}
else
{
// filled candle c < o
QRect rect(QPoint(x + 2, yo), QPoint(x + width - 2, yc));
painter->drawLine (rect.center().x(), yh, rect.center().x(), yl);
painter->setBrush(b->color());
painter->drawRect(rect);
}
break;
}
}
}
return 1;
}
