void IncrementalPlot::appendData(double *x, double *y, int size)
{
if ( d_data == NULL )
d_data = new CurveData;
if ( d_curve == NULL )
{
d_curve = new QwtPlotCurve("Test Curve");
d_curve->setStyle(QwtPlotCurve::NoCurve);
d_curve->setPaintAttribute(QwtPlotCurve::PaintFiltered);
const QColor &c = Qt::white;
d_curve->setSymbol(QwtSymbol(QwtSymbol::XCross,
QBrush(c), QPen(c), QSize(5, 5)) );
d_curve->attach(this);
}
d_data->append(x, y, size);
d_curve->setRawData(d_data->x(), d_data->y(), d_data->count());
#ifdef __GNUC__
#endif
const bool cacheMode =
canvas()->testPaintAttribute(QwtPlotCanvas::PaintCached);
canvas()->setPaintAttribute(QwtPlotCanvas::PaintCached, false);
d_curve->draw(d_curve->dataSize() - size, d_curve->dataSize() - 1);
canvas()->setPaintAttribute(QwtPlotCanvas::PaintCached, cacheMode);
}
void ALCPeakFittingView::initialize() {
m_ui.setupUi(m_widget);
connect(m_ui.fit, SIGNAL(clicked()), this, SIGNAL(fitRequested()));
m_ui.plot->setCanvasBackground(Qt::white);
m_ui.plot->setAxisFont(QwtPlot::xBottom, m_widget->font());
m_ui.plot->setAxisFont(QwtPlot::yLeft, m_widget->font());
m_dataCurve->setStyle(QwtPlotCurve::NoCurve);
m_dataCurve->setSymbol(
QwtSymbol(QwtSymbol::Ellipse, QBrush(), QPen(), QSize(7, 7)));
m_dataCurve->setRenderHint(QwtPlotItem::RenderAntialiased, true);
m_dataCurve->attach(m_ui.plot);
m_fittedCurve->setPen(QPen(Qt::red, 1.5));
m_fittedCurve->setRenderHint(QwtPlotItem::RenderAntialiased, true);
m_fittedCurve->attach(m_ui.plot);
// XXX: Being a QwtPlotItem, should get deleted when m_ui.plot gets deleted
// (auto-delete option)
m_peakPicker = new MantidWidgets::PeakPicker(m_ui.plot, Qt::red);
connect(m_peakPicker, SIGNAL(changed()), SIGNAL(peakPickerChanged()));
connect(m_ui.peaks, SIGNAL(currentFunctionChanged()),
SIGNAL(currentFunctionChanged()));
connect(m_ui.peaks, SIGNAL(parameterChanged(QString, QString)),
SIGNAL(parameterChanged(QString, QString)));
connect(m_ui.help, SIGNAL(clicked()), this, SLOT(help()));
connect(m_ui.plotGuess, SIGNAL(clicked()), this, SLOT(plotGuess()));
}
void BaselineDialog::modifyBaseline()
{
if (!d_baseline)
createBaseline();
disableBaselineTool();
if (d_baseline->type() == Graph::Function){
ApplicationWindow *app = (ApplicationWindow *)parent();
int points = d_baseline->dataSize();
d_table = app->newTable(points, 2);
app->setWindowName(d_table, tr("Baseline"));
app->hideWindow(d_table);
for (int i = 0; i < points; i++){
d_table->setCell(i, 0, d_baseline->x(i));
d_table->setCell(i, 1, d_baseline->y(i));
}
QPen pen = d_baseline->pen();
graph->removeCurve(d_baseline->title().text());
delete d_baseline;
d_baseline = graph->insertCurve(d_table, d_table->objectName() + "_2", Graph::Line);
d_baseline->setPen(pen);
}
d_baseline->setSymbol(QwtSymbol(QwtSymbol::Rect, QBrush(Qt::black), d_baseline->pen(), QSize(7, 7)));
d_picker_tool = new BaselineTool(d_baseline, graph, (ApplicationWindow *)parent());
graph->setActiveTool(d_picker_tool);
graph->replot();
}
/*!
\return a marker's symbol
\param key Marker key
*/
QwtSymbol QwtPlot::markerSymbol(long key) const
{
QwtPlotMarker *m = d_markers->find(key);
if (m)
return m->symbol();
else
return QwtSymbol();
}
void
IncrementalPlot::nextSymbol()
{
int n = d_curve->symbol().style() + 1;
if (n > 14)
n = 0;
d_curve->setSymbol(QwtSymbol((QwtSymbol::Style) n, QBrush(Qt::white), QPen(
Qt::white), QSize(6, 6)));
}
void QmitkHistogramWidget::InitializeMarker()
{
m_Marker = new QwtPlotMarker();
m_Marker->setXValue(0.);
m_Marker->setLineStyle(QwtPlotMarker::VLine);
m_Marker->setLabelAlignment(Qt::AlignHCenter | Qt::AlignRight);
m_Marker->setLinePen(QPen(QColor(200,150,0), 3, Qt::SolidLine));
m_Marker->setSymbol( QwtSymbol(QwtSymbol::Diamond,
QColor(Qt::red), QColor(Qt::red), QSize(10,10)));
m_Marker->attach(m_Plot);
}
void IncrementalPlot::startNewCurve()
{
if (!curves.empty())
curCurveOffset += curves.back()->dataSize();
QwtPlotCurve *newCurve = new QwtPlotCurve("Line");
newCurve->setStyle(QwtPlotCurve::Lines);
newCurve->setPaintAttribute(QwtPlotCurve::PaintFiltered);
newCurve->setPen(QColor(Qt::white));
const QColor &c = Qt::white;
newCurve->setSymbol(QwtSymbol(QwtSymbol::NoSymbol, QBrush(c), QPen(c), QSize(6, 6)));
curves.push_back(newCurve);
newCurve->attach(this);
}
void IncrementalPlot::appendData(double *x, double *y, int size)
{
if ( d_data == NULL )
d_data = new CurveData;
if ( d_curve == NULL )
{
d_curve = new QwtPlotCurve("Test Curve");
d_curve->setStyle(QwtPlotCurve::NoCurve);
d_curve->setPaintAttribute(QwtPlotCurve::PaintFiltered);
const QColor &c = Qt::white;
d_curve->setSymbol(QwtSymbol(QwtSymbol::XCross,
QBrush(c), QPen(c), QSize(5, 5)) );
d_curve->attach(this);
}
d_data->append(x, y, size);
d_curve->setRawData(d_data->x(), d_data->y(), d_data->count());
#ifdef __GNUC__
#endif
const bool cacheMode =
canvas()->testPaintAttribute(QwtPlotCanvas::PaintCached);
#if QT_VERSION >= 0x040000
const bool oldDirectPaint =
canvas()->testAttribute(Qt::WA_PaintOutsidePaintEvent);
const QPaintEngine *pe = canvas()->paintEngine();
bool directPaint = pe->hasFeature(QPaintEngine::PaintOutsidePaintEvent);
if ( pe->type() == QPaintEngine::X11 )
{
// Even if not recommended by TrollTech, Qt::WA_PaintOutsidePaintEvent
// works on X11. This has an tremendous effect on the performance..
directPaint = true;
}
canvas()->setAttribute(Qt::WA_PaintOutsidePaintEvent, directPaint);
#endif
canvas()->setPaintAttribute(QwtPlotCanvas::PaintCached, false);
d_curve->draw(d_curve->dataSize() - size, d_curve->dataSize() - 1);
canvas()->setPaintAttribute(QwtPlotCanvas::PaintCached, cacheMode);
#if QT_VERSION >= 0x040000
canvas()->setAttribute(Qt::WA_PaintOutsidePaintEvent, oldDirectPaint);
#endif
}
void IncrementalPlot::appendData(double *x, double *y, int size)
{
resizeIfNeeded(x[0], y[0]);
if ( d_data == NULL )
d_data = new CurveData;
if ( d_curve == NULL )
{
d_curve = new QwtPlotCurve("Test Curve");
d_curve->setStyle(QwtPlotCurve::NoCurve);
d_curve->setPaintAttribute(QwtPlotCurve::PaintFiltered);
const QColor &c = Qt::white;
d_curve->setSymbol(QwtSymbol(QwtSymbol::XCross,
QBrush(c), QPen(c), QSize(5, 5)) );
d_curve->attach(this);
}
d_data->append(x, y, size);
d_curve->setRawData(d_data->x(), d_data->y(), d_data->count());
#ifdef __GNUC__
#warning better use QwtData
#endif
const bool cacheMode =
canvas()->testPaintAttribute(QwtPlotCanvas::PaintCached);
#if QT_VERSION >= 0x040000 && defined(Q_WS_X11)
// Even if not recommended by TrollTech, Qt::WA_PaintOutsidePaintEvent
// works on X11. This has an tremendous effect on the performance..
canvas()->setAttribute(Qt::WA_PaintOutsidePaintEvent, true);
#endif
canvas()->setPaintAttribute(QwtPlotCanvas::PaintCached, false);
d_curve->draw(d_curve->dataSize() - size, d_curve->dataSize() - 1);
canvas()->setPaintAttribute(QwtPlotCanvas::PaintCached, cacheMode);
#if QT_VERSION >= 0x040000 && defined(Q_WS_X11)
canvas()->setAttribute(Qt::WA_PaintOutsidePaintEvent, false);
#endif
}
void QgsVectorGradientColorRampV2Dialog::addPlotMarker( double x, double y, const QColor& color, bool isSelected )
{
QColor borderColor = color.darker( 200 );
borderColor.setAlpha( 255 );
QColor brushColor = color;
brushColor.setAlpha( 255 );
QwtPlotMarker *marker = new QwtPlotMarker();
#if defined(QWT_VERSION) && QWT_VERSION>=0x060000
marker->setSymbol( new QwtSymbol( QwtSymbol::Ellipse, QBrush( brushColor ), QPen( borderColor, isSelected ? 2 : 1 ), QSize( 10, 10 ) ) );
#else
marker->setSymbol( QwtSymbol( QwtSymbol::Ellipse, QBrush( brushColor ), QPen( borderColor, isSelected ? 2 : 1 ), QSize( 10, 10 ) ) );
#endif
marker->setValue( x, y );
marker->attach( mPlot );
marker->setRenderHint( QwtPlotItem::RenderAntialiased, true );
mMarkers << marker;
}
void IncrementalPlot::appendData(double x, double y)
{
if ( d_data == NULL )
d_data = new CurveData;
if ( d_curve == NULL )
{
d_curve = new QwtPlotCurve("Residual Curve");
d_curve->setStyle(QwtPlotCurve::Lines);
d_curve->setPaintAttribute(QwtPlotCurve::PaintFiltered);
const QColor &c = Qt::black;
d_curve->setSymbol(QwtSymbol(QwtSymbol::XCross,
QBrush(c), QPen(c), QSize(5, 5)) );
d_curve->attach(this);
}
d_data->append(x, y);
d_curve->setData(d_data->d_x.data(), d_data->d_y.data(), d_data->size());
const bool cacheMode =
canvas()->testPaintAttribute(QwtPlotCanvas::PaintCached);
#if QT_VERSION >= 0x040000 && defined(Q_WS_X11)
// Even if not recommended by TrollTech, Qt::WA_PaintOutsidePaintEvent
// works on X11. This has an tremendous effect on the performance..
canvas()->setAttribute(Qt::WA_PaintOutsidePaintEvent, true);
#endif
canvas()->setPaintAttribute(QwtPlotCanvas::PaintCached, false);
d_curve->draw(d_curve->dataSize() - d_data->size(), d_curve->dataSize() - 1);
canvas()->setPaintAttribute(QwtPlotCanvas::PaintCached, cacheMode);
#if QT_VERSION >= 0x040000 && defined(Q_WS_X11)
canvas()->setAttribute(Qt::WA_PaintOutsidePaintEvent, false);
#endif
}
void QgsGPSInformationWidget::displayGPSInformation( const QgsGPSInformation &info )
{
QVector<QPointF> data;
// set validity flag and status from GPS data
// based on GGA, GSA and RMC sentences - the logic does not require all
bool validFlag = false; // true if GPS indicates position fix
FixStatus fixStatus = NoData;
// no fix if any of the three report bad; default values are invalid values and won't be changed if the corresponding NMEA msg is not received
if ( info.status == 'V' || info.fixType == NMEA_FIX_BAD || info.quality == 0 ) // some sources say that 'V' indicates position fix, but is below acceptable quality
{
fixStatus = NoFix;
}
else if ( info.fixType == NMEA_FIX_2D ) // 2D indication (from GGA)
{
fixStatus = Fix2D;
validFlag = true;
}
else if ( info.status == 'A' || info.fixType == NMEA_FIX_3D || info.quality > 0 ) // good
{
fixStatus = Fix3D;
validFlag = true;
}
else // unknown status (not likely)
{
}
// set visual status indicator -- do only on change of state
if ( fixStatus != mLastFixStatus )
{
setStatusIndicator( fixStatus );
}
if ( mStackedWidget->currentIndex() == 1 && info.satInfoComplete ) //signal
{
mpPlot->setAxisScale( QwtPlot::xBottom, 0, info.satellitesInView.size() );
} //signal
#ifdef WITH_QWTPOLAR
if ( mStackedWidget->currentIndex() == 2 && info.satInfoComplete ) //satellites
{
while ( !mMarkerList.isEmpty() )
{
delete mMarkerList.takeFirst();
}
} //satellites
#endif
if ( mStackedWidget->currentIndex() == 4 ) //debug
{
mGPSPlainTextEdit->clear();
} //debug
for ( int i = 0; i < info.satellitesInView.size(); ++i ) //satellite processing loop
{
QgsSatelliteInfo currentInfo = info.satellitesInView.at( i );
if ( mStackedWidget->currentIndex() == 1 && info.satInfoComplete ) //signal
{
data << QPointF( i, 0 );
data << QPointF( i, currentInfo.signal );
data << QPointF( i + 1, currentInfo.signal );
data << QPointF( i + 1, 0 );
} //signal
if ( mStackedWidget->currentIndex() == 2 && info.satInfoComplete ) //satellites
{
QColor bg( Qt::white ); // moved several items outside of the following if block to minimize loop time
bg.setAlpha( 200 );
QColor myColor;
// Add a marker to the polar plot
if ( currentInfo.id > 0 ) // don't show satellite if id=0 (no satellite indication)
{
#ifdef WITH_QWTPOLAR
QwtPolarMarker *mypMarker = new QwtPolarMarker();
#if (QWT_POLAR_VERSION<0x010000)
mypMarker->setPosition( QwtPolarPoint( currentInfo.azimuth, currentInfo.elevation ) );
#else
mypMarker->setPosition( QwtPointPolar( currentInfo.azimuth, currentInfo.elevation ) );
#endif
#endif
if ( currentInfo.signal < 30 ) //weak signal
{
myColor = Qt::red;
}
else
{
myColor = Qt::black; //strong signal
}
#ifdef WITH_QWTPOLAR
QBrush symbolBrush( Qt::black );
QSize markerSize( 9, 9 );
QBrush textBgBrush( bg );
#if (QWT_POLAR_VERSION<0x010000)
mypMarker->setSymbol( QwtSymbol( QwtSymbol::Ellipse,
symbolBrush, QPen( myColor ), markerSize ) );
#else
mypMarker->setSymbol( new QwtSymbol( QwtSymbol::Ellipse,
symbolBrush, QPen( myColor ), markerSize ) );
#endif
mypMarker->setLabelAlignment( Qt::AlignHCenter | Qt::AlignTop );
QwtText text( QString::number( currentInfo.id ) );
text.setColor( myColor );
text.setBackgroundBrush( textBgBrush );
mypMarker->setLabel( text );
mypMarker->attach( mpSatellitesWidget );
mMarkerList << mypMarker;
#endif
} // currentInfo.id > 0
} //satellites
} //satellite processing loop
if ( mStackedWidget->currentIndex() == 1 && info.satInfoComplete ) //signal
{
mpCurve->setSamples( data );
mpPlot->replot();
} //signal
#ifdef WITH_QWTPOLAR
if ( mStackedWidget->currentIndex() == 2 && info.satInfoComplete ) //satellites
{
mpSatellitesWidget->replot();
} //satellites
#endif
if ( validFlag )
{
validFlag = info.longitude >= -180.0 && info.longitude <= 180.0 && info.latitude >= -90.0 && info.latitude <= 90.0;
}
QgsPointXY myNewCenter;
if ( validFlag )
{
myNewCenter = QgsPointXY( info.longitude, info.latitude );
}
else
{
myNewCenter = mLastGpsPosition;
}
if ( mStackedWidget->currentIndex() == 0 ) //position
{
mTxtLatitude->setText( QString::number( info.latitude, 'f', 8 ) );
mTxtLongitude->setText( QString::number( info.longitude, 'f', 8 ) );
mTxtAltitude->setText( tr( "%1 m" ).arg( info.elevation, 0, 'f', 1 ) ); // don't know of any GPS receivers that output better than 0.1 m precision
if ( mDateTimeFormat.isEmpty() )
{
mTxtDateTime->setText( info.utcDateTime.toString( Qt::TextDate ) ); // default format
}
else
{
mTxtDateTime->setText( info.utcDateTime.toString( mDateTimeFormat ) ); //user specified format string for testing the millisecond part of time
}
mTxtSpeed->setText( tr( "%1 km/h" ).arg( info.speed, 0, 'f', 1 ) );
mTxtDirection->setText( QString::number( info.direction, 'f', 1 ) + QStringLiteral( "°" ) );
mTxtHdop->setText( QString::number( info.hdop, 'f', 1 ) );
mTxtVdop->setText( QString::number( info.vdop, 'f', 1 ) );
mTxtPdop->setText( QString::number( info.pdop, 'f', 1 ) );
mTxtHacc->setText( QString::number( info.hacc, 'f', 1 ) + "m" );
mTxtVacc->setText( QString::number( info.vacc, 'f', 1 ) + "m" );
mTxtFixMode->setText( info.fixMode == 'A' ? tr( "Automatic" ) : info.fixMode == 'M' ? tr( "Manual" ) : QLatin1String( "" ) ); // A=automatic 2d/3d, M=manual; allowing for anything else
mTxtFixType->setText( info.fixType == 3 ? tr( "3D" ) : info.fixType == 2 ? tr( "2D" ) : info.fixType == 1 ? tr( "No fix" ) : QString::number( info.fixType ) ); // 1=no fix, 2=2D, 3=3D; allowing for anything else
mTxtQuality->setText( info.quality == 2 ? tr( "Differential" ) : info.quality == 1 ? tr( "Non-differential" ) : info.quality == 0 ? tr( "No position" ) : info.quality > 2 ? QString::number( info.quality ) : QLatin1String( "" ) ); // allowing for anything else
mTxtSatellitesUsed->setText( QString::number( info.satellitesUsed ) );
mTxtStatus->setText( info.status == 'A' ? tr( "Valid" ) : info.status == 'V' ? tr( "Invalid" ) : QLatin1String( "" ) );
} //position
// Avoid refreshing / panning if we haven't moved
if ( mLastGpsPosition != myNewCenter )
{
mLastGpsPosition = myNewCenter;
// Pan based on user specified behavior
if ( radRecenterMap->isChecked() || radRecenterWhenNeeded->isChecked() )
{
QgsCoordinateReferenceSystem mypSRS = mpCanvas->mapSettings().destinationCrs();
QgsCoordinateTransform myTransform( mWgs84CRS, mypSRS ); // use existing WGS84 CRS
QgsPointXY myPoint = myTransform.transform( myNewCenter );
//keep the extent the same just center the map canvas in the display so our feature is in the middle
QgsRectangle myRect( myPoint, myPoint ); // empty rect can be used to set new extent that is centered on the point used to construct the rect
// testing if position is outside some proportion of the map extent
// this is a user setting - useful range: 5% to 100% (0.05 to 1.0)
QgsRectangle myExtentLimit( mpCanvas->extent() );
myExtentLimit.scale( mSpinMapExtentMultiplier->value() * 0.01 );
// only change the extents if the point is beyond the current extents to minimize repaints
if ( radRecenterMap->isChecked() ||
( radRecenterWhenNeeded->isChecked() && !myExtentLimit.contains( myPoint ) ) )
{
mpCanvas->setExtent( myRect );
mpCanvas->refresh();
}
} //otherwise never recenter automatically
if ( mCbxAutoAddVertices->isChecked() )
{
addVertex();
}
} // mLastGpsPosition != myNewCenter
// new marker position after recentering
if ( mGroupShowMarker->isChecked() ) // show marker
{
if ( validFlag ) // update cursor position if valid position
{
// initially, cursor isn't drawn until first valid fix; remains visible until GPS disconnect
if ( ! mpMapMarker )
{
mpMapMarker = new QgsGpsMarker( mpCanvas );
}
mpMapMarker->setSize( mSliderMarkerSize->value() );
mpMapMarker->setCenter( myNewCenter );
}
}
else
{
if ( mpMapMarker )
{
delete mpMapMarker;
mpMapMarker = nullptr;
}
} // show marker
}
int QwtPlotWidget::interpret(const char *command, double *x, double *y)
{
if(command == NULL) return -1;
line = command;
if (isCommand("setCurveData("))
{
if(x == NULL) return -1;
if(y == NULL) return -1;
int c,count;
sscanf(command,"setCurveData(%d,%d",&c,&count);
if(c<0 || c>=nCurves) return -1;
if(curves[c] != NULL) curves[c]->setData(x,y,count);
}
else if(isCommand("replot("))
{
replot();
}
else if(isCommand("setTitle("))
{
QString text;
if(getText(command,text) != 0) return -1;
setTitle(text);
}
else if(isCommand("setCanvasBackground("))
{
int r,g,b;
sscanf(command,"setCanvasBackground(%d,%d,%d",&r,&g,&b);
setCanvasBackground(QColor(r,g,b));
}
else if(isCommand("enableOutline("))
{
int val;
sscanf(command,"enableOutline(%d",&val);
if( val == 0 || val == 1 )
{
//xx enableOutline(val);
//xx setOutlineStyle(Qwt::Rect );
}
else
{
//xx enableOutline( 1 );
//xx setOutlineStyle(Qwt::Cross );
}
}
else if(isCommand("setOutlinePen("))
{
int r,g,b;
sscanf(command,"setOutlinePen(%d,%d,%d",&r,&g,&b);
//xx setOutlinePen(QColor(r,g,b));
}
else if(isCommand("setAutoLegend("))
{
int val;
sscanf(command,"setAutoLegend(%d",&val);
//xx setAutoLegend(val);
autolegend = val;
}
else if(isCommand("enableLegend("))
{
int val;
sscanf(command,"enableLegend(%d",&val);
enablelegend = val;
}
else if(isCommand("setLegendPos("))
{
int val;
sscanf(command,"setLegendPos(%d",&val);
if(opt.arg_debug) printf("SetLegendPos begin\n");;
if(legend == NULL) legend = new QwtLegend();
if(opt.arg_debug) printf("SetLegendPos 1\n");;
legend->setItemMode(QwtLegend::ClickableItem);
if(opt.arg_debug) printf("SetLegendPos 2\n");;
switch(val)
{
case PV::LeftLegend:
insertLegend(legend, QwtPlot::LeftLegend);
break;
case PV::RightLegend:
insertLegend(legend, QwtPlot::RightLegend);
break;
case PV::TopLegend:
insertLegend(legend, QwtPlot::TopLegend);
break;
default:
insertLegend(legend, QwtPlot::BottomLegend);
break;
}
if(opt.arg_debug) printf("SetLegendPos end\n");;
}
else if(isCommand("setLegendFrameStyle("))
{
int val;
sscanf(command,"setLegendFrameStyle(%d",&val);
legendframestyle = val;
if(legend != NULL) legend->setFrameStyle(legendframestyle);
}
else if(isCommand("enableGridXMin("))
{
grid.enableXMin(true);
}
else if(isCommand("setGridMajPen("))
{
int r,g,b,style;
sscanf(command,"setGridMajPen(%d,%d,%d,%d",&r,&g,&b,&style);
grid.setMajPen(QPen(QColor(r,g,b),0,(Qt::PenStyle) style));
}
else if(isCommand("setGridMinPen("))
{
int r,g,b,style;
sscanf(command,"setGridMinPen(%d,%d,%d,%d",&r,&g,&b,&style);
grid.setMinPen(QPen(QColor(r,g,b),0,(Qt::PenStyle) style));
}
else if(isCommand("enableAxis("))
{
int pos;
sscanf(command,"enableAxis(%d",&pos);
enableAxis(pos);
}
else if(isCommand("setAxisTitle("))
{
int pos;
QString text;
sscanf(command,"setAxisTitle(%d",&pos);
if(getText(command,text) != 0) return -1;
setAxisTitle(pos,text);
}
else if(isCommand("setAxisOptions("))
{
int pos,val;
sscanf(command,"setAxisOptions(%d,%d",&pos,&val);
//xx setAxisOptions(pos,val);
}
else if(isCommand("setAxisMaxMajor("))
{
int pos,val;
sscanf(command,"setAxisMaxMajor(%d,%d",&pos,&val);
setAxisMaxMajor(pos,val);
}
else if(isCommand("setAxisMaxMinor("))
{
int pos,val;
sscanf(command,"setAxisMaxMinor(%d,%d",&pos,&val);
setAxisMaxMinor(pos,val);
}
else if(isCommand("insertCurve("))
{
int pos;
QString text;
sscanf(command,"insertCurve(%d",&pos);
if(getText(command,text) != 0) return -1;
if(pos<0 || pos>=nCurves) return -1;
//xx removeCurve( curves[pos] );
//xx curves[pos] = insertCurve(text);
if(curves[pos] != NULL) delete curves[pos];
if(opt.arg_debug) printf("new QwtPlotCurve(%s)\n",(const char *) text.toUtf8());
curves[pos] = new QwtPlotCurve(text);
curves[pos]->attach(this);
if(legend != NULL)
{
QWidget *w = legend->find(curves[pos]);
if(w != NULL)
{
if(opt.arg_debug) printf("setChecked(%d)\n",autolegend);
((QwtLegendItem *)w)->setChecked(autolegend);
}
}
replot();
//if(autolegend && legend != NULL) curves[pos]->updateLegend(legend);
}
else if(isCommand("removeCurve("))
{
int pos;
sscanf(command,"removeCurve(%d",&pos);
if(pos<0 || pos>=nCurves) return -1;
//xx removeCurve( curves[pos] );
if(curves[pos] != NULL) curves[pos]->detach();
if(curves[pos] != NULL) delete curves[pos];
curves[pos] = NULL;
}
else if(isCommand("setCurvePen("))
{
int pos,r,g,b,width,style;
sscanf(command,"setCurvePen(%d,%d,%d,%d,%d,%d",&pos,&r,&g,&b,&width,&style);
if(pos<0 || pos>=nCurves) return -1;
//xx setCurvePen(curves[pos],QPen(QColor(r,g,b),width,(Qt::PenStyle) style));
QPen pen(QColor(r,g,b));
pen.setWidth(width);
pen.setStyle((Qt::PenStyle) style);
if(curves[pos] != NULL) curves[pos]->setPen(pen);
}
else if(isCommand("setCurveSymbol("))
{
int pos,symbol,r1,g1,b1,r2,g2,b2,w,h;
sscanf(command,"setCurveSymbol(%d,%d,%d,%d,%d,%d,%d,%d,%d,%d",&pos,&symbol,
&r1,&g1,&b1,&r2,&g2,&b2,&w,&h);
if(pos<0 || pos>=nCurves) return -1;
//xx setCurveSymbol(curves[pos], QwtSymbol((QwtSymbol::Style) symbol, QColor(r1,g1,b1), QColor(r2,g2,b2), QSize(w,h)));
if(curves[pos] != NULL) curves[pos]->setSymbol(QwtSymbol((QwtSymbol::Style) symbol, QColor(r1,g1,b1), QColor(r2,g2,b2), QSize(w,h)));
}
else if(isCommand("setCurveYAxis("))
{
int pos,pos2;
sscanf(command,"setCurveYAxis(%d,%d",&pos,&pos2);
if(pos<0 || pos>=nCurves) return -1;
//xx setCurveYAxis(curves[pos],pos2); rl2013
if(curves[pos] != NULL) curves[pos]->setYAxis(pos2);
}
else if(isCommand("insertMarker("))
{
int pos;
sscanf(command,"insertMarker(%d",&pos);
if(pos<0 || pos>=nMarker) return -1;
//xx marker[pos] = insertMarker();
if(marker[pos] != NULL) delete marker[pos];
marker[pos] = new QwtPlotMarker();
marker[pos]->attach(this);
}
else if(isCommand("setMarkerLineStyle("))
{
int pos,style;
sscanf(command,"setMarkerLineStyle(%d,%d",&pos,&style);
if(pos<0 || pos>=nMarker) return -1;
//xx setMarkerLineStyle(marker[pos],(QwtMarker::LineStyle) style);
if(marker[pos] != NULL) marker[pos]->setLineStyle((QwtPlotMarker::LineStyle) style);
}
else if(isCommand("setMarkerPos("))
{
int pos;
float x,y;
sscanf(command,"setMarkerPos(%d,%f,%f",&pos,&x,&y);
if(pos<0 || pos>=nMarker) return -1;
//xx setMarkerPos(marker[pos],x,y);
if(marker[pos] != NULL) marker[pos]->setValue(x,y);
}
else if(isCommand("setMarkerLabelAlign("))
{
int pos,align;
sscanf(command,"setMarkerLabelAlign(%d,%d",&pos,&align);
if(pos<0 || pos>=nMarker) return -1;
//xx setMarkerLabelAlign(marker[pos],align);
if(marker[pos] != NULL) marker[pos]->setLabelAlignment((Qt::Alignment) align);
}
else if(isCommand("setMarkerLabel("))
{
int pos;
QString text;
sscanf( command, "setMarkerLabel(%d",&pos );
if(getText(command, text) != 0 ) return -1;
//xx setMarkerLabel(marker[pos], text );
if(marker[pos] != NULL) marker[pos]->setLabel(text);
}
else if(isCommand("setMarkerPen("))
{
int pos,r,g,b,style;
sscanf(command,"setMarkerPen(%d,%d,%d,%d,%d",&pos,&r,&g,&b,&style);
if(pos<0 || pos>=nMarker) return -1;
//xx setMarkerPen(marker[pos],QPen(QColor(r,g,b),0,(Qt::PenStyle) style));
if(marker[pos] != NULL) marker[pos]->setLinePen(QPen(QColor(r,g,b)));
}
else if(isCommand("setMarkerFont("))
{
int pos,size,style;
QString family;
sscanf(command,"setMarkerFont(%d,%d,%d",&pos,&size,&style);
if(pos<0 || pos>=nMarker) return -1;
if(getText(command,family) != 0) return -1;
//xx setMarkerFont(marker[pos],QFont(family,size,style));
}
else if(isCommand("setMarkerSymbol("))
{
int pos,symbol,r1,g1,b1,r2,g2,b2,w,h;
sscanf(command,"setMarkerSymbol(%d,%d,%d,%d,%d,%d,%d,%d,%d,%d",
&pos,&symbol,&r1,&g1,&b1,&r2,&g2,&b2,&w,&h);
if(pos<0 || pos>=nMarker) return -1;
//xx setMarkerSymbol(marker[pos], QwtSymbol((QwtSymbol::Style) symbol, QColor(r1,g1,b1), QColor(r2,g2,b2), QSize(w,h)));
if(marker[pos] != NULL) marker[pos]->setSymbol(QwtSymbol((QwtSymbol::Style) symbol, QColor(r1,g1,b1), QColor(r2,g2,b2), QSize(w,h)));
}
else if(isCommand("insertLineMarker("))
{
int pos,pos2;
QString text;
sscanf(command,"insertLineMarker(%d,%d",&pos,&pos2);
if(getText(command,text) != 0) return -1;
if(pos<0 || pos>=nMarker) return -1;
//xx marker[pos] = insertLineMarker(text, pos2);
if(marker[pos] != NULL) delete marker[pos];
marker[pos] = new QwtPlotMarker();
marker[pos]->attach(this);
if(marker[pos] != NULL) marker[pos]->setLabel(text);
}
else if( isCommand("setAxisScaleDraw("))
{
int pos;
QString qtext;
char text[1024];
sscanf( command, "setAxisScaleDraw(%d",&pos );
if( getText(command, qtext) != 0 ) return -1;
if(qtext.length() < ((int) sizeof(text) -1))
{
strcpy(text,qtext.toUtf8());
}
else
{
strcpy(text,"text too long");
}
if(opt.arg_debug) printf("setAxisScaleDraw(%s)\n",text);
setAxisScaleDraw( pos, new UserScaleDraw( text ));
}
else if( isCommand("setAxisScale("))
{
int pos;
float min,max,step;
sscanf( command, "setAxisScale(%d,%f,%f,%f",&pos ,&min, &max, &step);
if(opt.arg_debug) printf("setAxisScale(%d,%f,%f,%f)\n",pos,min,max,step);
setAxisScale(pos,min,max,step);
}
else
{
return -1;
}
return 0;
}
bool CopasiPlot::initFromSpec(const CPlotSpecification* plotspec)
{
mIgnoreUpdate = true;
mpPlotSpecification = plotspec;
if (mpZoomer) mpZoomer->setEnabled(false);
// size_t k, kmax = mpPlotSpecification->getItems().size();
setTitle(FROM_UTF8(mpPlotSpecification->getTitle()));
mCurves.resize(mpPlotSpecification->getItems().size());
mCurves = NULL;
std::map< std::string, C2DPlotCurve * >::iterator found;
CCopasiVector< CPlotItem >::const_iterator itPlotItem = mpPlotSpecification->getItems().begin();
CCopasiVector< CPlotItem >::const_iterator endPlotItem = mpPlotSpecification->getItems().end();
CVector< bool > Visible(mpPlotSpecification->getItems().size());
Visible = true;
bool * pVisible = Visible.array();
for (; itPlotItem != endPlotItem; ++itPlotItem, ++pVisible)
{
// Qwt does not like it to reuse the curve as this may lead to access
// violation. We therefore delete the curves but remember their visibility.
if ((found = mCurveMap.find((*itPlotItem)->CCopasiParameter::getKey())) != mCurveMap.end())
{
*pVisible = found->second->isVisible();
}
}
// Remove unused curves if definition has changed
std::map< std::string, C2DPlotCurve * >::iterator it = mCurveMap.begin();
std::map< std::string, C2DPlotCurve * >::iterator end = mCurveMap.end();
for (; it != end; ++it)
pdelete(it->second);
mCurveMap.clear();
itPlotItem = mpPlotSpecification->getItems().begin();
pVisible = Visible.array();
C2DPlotCurve ** ppCurve = mCurves.array();
unsigned long int k = 0;
bool needLeft = false;
bool needRight = false;
for (; itPlotItem != endPlotItem; ++itPlotItem, ++pVisible, ++ppCurve, ++k)
{
// set up the curve
C2DPlotCurve * pCurve = new C2DPlotCurve(&mMutex,
(*itPlotItem)->getType(),
(*itPlotItem)->getActivity(),
FROM_UTF8((*itPlotItem)->getTitle()));
*ppCurve = pCurve;
mCurveMap[(*itPlotItem)->CCopasiParameter::getKey()] = pCurve;
//color handling should be similar for different curve types
QColor color;
if (pCurve->getType() == CPlotItem::curve2d
|| pCurve->getType() == CPlotItem::histoItem1d
|| pCurve->getType() == CPlotItem::bandedGraph)
{
std::string colorstr = *(*itPlotItem)->getValue("Color").pSTRING;
color = CQPlotColors::getColor(colorstr, k);
}
pCurve->setPen(color);
pCurve->attach(this);
showCurve(pCurve, *pVisible);
if (pCurve->getType() == CPlotItem::curve2d
|| pCurve->getType() == CPlotItem::bandedGraph)
{
needLeft = true;
pCurve->setRenderHint(QwtPlotItem::RenderAntialiased);
unsigned C_INT32 linetype = *(*itPlotItem)->getValue("Line type").pUINT;
if (linetype == 0 //line
|| linetype == 3) //line+symbols
{
pCurve->setStyle(QwtPlotCurve::Lines);
unsigned C_INT32 linesubtype = *(*itPlotItem)->getValue("Line subtype").pUINT;
C_FLOAT64 width = *(*itPlotItem)->getValue("Line width").pUDOUBLE;
switch (linesubtype) //symbol type
{
case 1:
pCurve->setPen(QPen(QBrush(color), width, Qt::DotLine, Qt::FlatCap));
break;
case 2:
pCurve->setPen(QPen(QBrush(color), width, Qt::DashLine));
break;
case 3:
pCurve->setPen(QPen(QBrush(color), width, Qt::DashDotLine));
break;
case 4:
pCurve->setPen(QPen(QBrush(color), width, Qt::DashDotDotLine));
break;
case 0:
default:
pCurve->setPen(QPen(QBrush(color), width, Qt::SolidLine));
break;
}
}
if (linetype == 1) //points
{
C_FLOAT64 width = *(*itPlotItem)->getValue("Line width").pUDOUBLE;
pCurve->setPen(QPen(color, width, Qt::SolidLine, Qt::RoundCap));
pCurve->setStyle(QwtPlotCurve::Dots);
}
if (linetype == 2) //only symbols
{
pCurve->setStyle(QwtPlotCurve::NoCurve);
}
if (linetype == 2 //symbols
|| linetype == 3) //line+symbols
{
unsigned C_INT32 symbolsubtype = *(*itPlotItem)->getValue("Symbol subtype").pUINT;
switch (symbolsubtype) //symbol type
{
case 1:
pCurve->setSymbol(QwtSymbol(QwtSymbol::Cross, QBrush(), QPen(QBrush(color), 2), QSize(7, 7)));
break;
case 2:
pCurve->setSymbol(QwtSymbol(QwtSymbol::Ellipse, QBrush(), QPen(QBrush(color), 1), QSize(8, 8)));
break;
case 0:
default:
pCurve->setSymbol(QwtSymbol(QwtSymbol::Cross, QBrush(color), QPen(QBrush(color), 1), QSize(5, 5)));
break;
}
}
} //2d curves and banded graphs
if (pCurve->getType() == CPlotItem::bandedGraph)
{
//set fill color
QColor c = color;
c.setAlpha(64);
pCurve->setBrush(c);
}
if (pCurve->getType() == CPlotItem::histoItem1d)
{
pCurve->setIncrement(*(*itPlotItem)->getValue("increment").pDOUBLE);
pCurve->setStyle(QwtPlotCurve::Steps);
pCurve->setYAxis(QwtPlot::yRight);
pCurve->setCurveAttribute(QwtPlotCurve::Inverted);
needRight = true;
}
}
if (plotspec->isLogX())
setAxisScaleEngine(xBottom, new QwtLog10ScaleEngine());
else
setAxisScaleEngine(xBottom, new QwtLinearScaleEngine());
setAxisAutoScale(xBottom);
if (plotspec->isLogY())
setAxisScaleEngine(yLeft, new QwtLog10ScaleEngine());
else
setAxisScaleEngine(yLeft, new QwtLinearScaleEngine());
setAxisAutoScale(yLeft);
enableAxis(yLeft, needLeft);
if (needRight)
{
setAxisScaleEngine(yRight, new QwtLinearScaleEngine());
setAxisTitle(yRight, "Percent %");
enableAxis(yRight);
}
mIgnoreUpdate = false;
return true; //TODO really check!
}