void QwtErrorPlotCurve::drawErrorBars(QPainter *painter,
const QwtScaleMap &xMap, const QwtScaleMap &yMap, int from, int to) const
{
int sh = 0, sw =0;
const QwtSymbol symbol = d_master_curve->symbol();
if (symbol.style() != QwtSymbol::NoSymbol){
sh = symbol.size().height();
sw = symbol.size().width();
}
double d_xOffset = 0.0;
double d_yOffset = 0.0;
if (d_master_curve->type() == Graph::VerticalBars)
d_xOffset = ((QwtBarCurve *)d_master_curve)->dataOffset();
else if (d_master_curve->type() == Graph::HorizontalBars)
d_yOffset = ((QwtBarCurve *)d_master_curve)->dataOffset();
ScaleEngine *yScaleEngine = (ScaleEngine *)plot()->axisScaleEngine(yAxis());
bool logYScale = (yScaleEngine->type() == QwtScaleTransformation::Log10) ? true : false;
for (int i = from; i <= to; i++){
const int xi = xMap.transform(x(i) + d_xOffset);
const int yi = yMap.transform(y(i) + d_yOffset);
if (type == Vertical){
const int yh = yMap.transform(y(i) + err[i]);
const int yl = yMap.transform(y(i) - err[i]);
const int yhl = yi - sh/2;
const int ylh = yi + sh/2;
if (plus){
QwtPainter::drawLine(painter, xi, yhl, xi, yh);
QwtPainter::drawLine(painter, xi - cap/2, yh, xi + cap/2, yh);
}
if (minus && (!logYScale || (logYScale && yl > 0))){
QwtPainter::drawLine(painter, xi, ylh, xi, yl);
QwtPainter::drawLine(painter, xi - cap/2, yl, xi + cap/2, yl);
}
if (through)
QwtPainter::drawLine(painter, xi, yhl, xi, ylh);
} else if (type == Horizontal) {
const int xp = xMap.transform(x(i) + err[i]);
const int xm = xMap.transform(x(i) - err[i]);
const int xpm = xi + sw/2;
const int xmp = xi - sw/2;
if (plus){
QwtPainter::drawLine(painter, xp, yi, xpm, yi);
QwtPainter::drawLine(painter, xp, yi - cap/2, xp, yi + cap/2);
}
if (minus){
QwtPainter::drawLine(painter, xm, yi, xmp, yi);
QwtPainter::drawLine(painter, xm, yi - cap/2, xm, yi + cap/2);
}
if (through)
QwtPainter::drawLine(painter, xmp, yi, xpm, yi);
}
}
}
static inline void qwtDrawPixmapSymbols( QPainter *painter,
const QPointF *points, int numPoints, const QwtSymbol &symbol )
{
QSize size = symbol.size();
if ( size.isEmpty() )
size = symbol.pixmap().size();
const QTransform transform = painter->transform();
if ( transform.isScaling() )
{
const QRect r( 0, 0, size.width(), size.height() );
size = transform.mapRect( r ).size();
}
QPixmap pm = symbol.pixmap();
if ( pm.size() != size )
pm = pm.scaled( size );
QPointF pinPoint( 0.5 * size.width(), 0.5 * size.height() );
if ( symbol.isPinPointEnabled() )
pinPoint = symbol.pinPoint();
painter->resetTransform();
for ( int i = 0; i < numPoints; i++ )
{
const QPointF pos = transform.map( points[i] ) - pinPoint;
QwtPainter::drawPixmap( painter,
QRect( pos.toPoint(), pm.size() ), pm );
}
}
static inline void qwtDrawSvgSymbols( QPainter *painter,
const QPointF *points, int numPoints,
QSvgRenderer *renderer, const QwtSymbol &symbol )
{
if ( renderer == NULL || !renderer->isValid() )
return;
const QRectF viewBox = renderer->viewBoxF();
if ( viewBox.isEmpty() )
return;
QSizeF sz = symbol.size();
if ( !sz.isValid() )
sz = viewBox.size();
const double sx = sz.width() / viewBox.width();
const double sy = sz.height() / viewBox.height();
QPointF pinPoint = viewBox.center();
if ( symbol.isPinPointEnabled() )
pinPoint = symbol.pinPoint();
const double dx = sx * ( pinPoint.x() - viewBox.left() );
const double dy = sy * ( pinPoint.y() - viewBox.top() );
for ( int i = 0; i < numPoints; i++ )
{
const double x = points[i].x() - dx;
const double y = points[i].y() - dy;
renderer->render( painter,
QRectF( x, y, sz.width(), sz.height() ) );
}
}
/*!
\brief Draw symbols
\param painter Painter
\param symbol Curve symbol
\param xMap x map
\param yMap y map
\param from index of the first point to be painted
\param to index of the last point to be painted
\sa setSymbol(), draw(), drawCurve()
*/
void PlotCurve::drawSymbols(QPainter *painter, const QwtSymbol &symbol, const QwtScaleMap &xMap,
const QwtScaleMap &yMap, int from, int to) const
{
painter->translate(d_x_offset,-d_y_offset); // For waterfall plots (will be zero otherwise)
// Don't really know why you'd want symbols on a waterfall plot, but just in case...
if (d_skip_symbols < 2)
{
QwtPlotCurve::drawSymbols(painter, symbol, xMap, yMap, from, to);
return;
}
painter->setBrush(symbol.brush());
//QtiPlot has added method to QwtPainter: painter->setPen(QwtPainter::scaledPen(symbol.pen()));
painter->setPen(symbol.pen());
const QwtMetricsMap &metricsMap = QwtPainter::metricsMap();
QRect rect;
rect.setSize(metricsMap.screenToLayout(symbol.size()));
for (int i = from; i <= to; i += d_skip_symbols)
{
const int xi = xMap.transform(x(i));
const int yi = yMap.transform(y(i));
rect.moveCenter(QPoint(xi, yi));
symbol.draw(painter, rect);
}
}
/*!
\brief Draw symbols
\param painter Painter
\param symbol Curve symbol
\param xMap x map
\param yMap y map
\param from index of the first point to be painted
\param to index of the last point to be painted
\sa setSymbol(), draw(), drawCurve()
*/
void PlotCurve::drawSymbols(QPainter *painter, const QwtSymbol &symbol,
const QwtScaleMap &xMap, const QwtScaleMap &yMap,
int from, int to) const {
if (d_skip_symbols < 2) {
QwtPlotCurve::drawSymbols(painter, symbol, xMap, yMap, from, to);
return;
}
painter->setBrush(symbol.brush());
// QtiPlot has added method to QwtPainter:
// painter->setPen(QwtPainter::scaledPen(symbol.pen()));
painter->setPen(symbol.pen());
const QwtMetricsMap &metricsMap = QwtPainter::metricsMap();
QRect rect;
rect.setSize(metricsMap.screenToLayout(symbol.size()));
for (int i = from; i <= to; i += d_skip_symbols) {
const int xi = xMap.transform(x(i));
const int yi = yMap.transform(y(i));
rect.moveCenter(QPoint(xi, yi));
symbol.draw(painter, rect);
}
}
static inline void qwtDrawXCrossSymbols( QPainter *painter,
const QPointF *points, int numPoints, const QwtSymbol &symbol )
{
const QSize size = symbol.size();
int off = 0;
QPen pen = symbol.pen();
if ( pen.width() > 1 )
{
pen.setCapStyle( Qt::FlatCap );
off = 1;
}
painter->setPen( pen );
if ( QwtPainter::roundingAlignment( painter ) )
{
const int sw = size.width();
const int sh = size.height();
const int sw2 = size.width() / 2;
const int sh2 = size.height() / 2;
for ( int i = 0; i < numPoints; i++ )
{
const QPointF &pos = points[i];
const int x = qRound( pos.x() );
const int y = qRound( pos.y() );
const int x1 = x - sw2;
const int x2 = x1 + sw + off;
const int y1 = y - sh2;
const int y2 = y1 + sh + off;
QwtPainter::drawLine( painter, x1, y1, x2, y2 );
QwtPainter::drawLine( painter, x2, y1, x1, y2 );
}
}
else
{
const double sw = size.width();
const double sh = size.height();
const double sw2 = 0.5 * size.width();
const double sh2 = 0.5 * size.height();
for ( int i = 0; i < numPoints; i++ )
{
const QPointF &pos = points[i];
const double x1 = pos.x() - sw2;
const double x2 = x1 + sw;
const double y1 = pos.y() - sh2;
const double y2 = y1 + sh;
QwtPainter::drawLine( painter, x1, y1, x2, y2 );
QwtPainter::drawLine( painter, x1, y2, x2, y1 );
}
}
}
QString PlotCurve::saveCurveLayout()
{
Plot *plot = static_cast<Plot *>(this->plot());
Graph *g = static_cast<Graph *>(plot->parent());
int index = g->curveIndex(static_cast<QwtPlotCurve *>(this));
int style = g->curveType(index);
QString s = "<Style>" + QString::number(style) + "</Style>\n";
if (style == Graph::Spline)
s += "<LineStyle>5</LineStyle>\n";
else if (style == Graph::VerticalSteps)
s += "<LineStyle>6</LineStyle>\n";
else
s += "<LineStyle>" + QString::number(this->style()) + "</LineStyle>\n";
QPen pen = this->pen();
if (pen.style() != Qt::NoPen){
s += "<Pen>\n";
s += "\t<Color>" + pen.color().name() + "</Color>\n";
s += "\t<Style>" + QString::number(pen.style()-1) + "</Style>\n";
s += "\t<Width>" + QString::number(pen.widthF()) + "</Width>\n";
s += "</Pen>\n";
}
QBrush brush = this->brush();
if (brush.style() != Qt::NoBrush){
s += "<Brush>\n";
s += "\t<Color>" + brush.color().name() + "</Color>\n";
s += "\t<Style>" + QString::number(PatternBox::patternIndex(brush.style())) + "</Style>\n";
s += "</Brush>\n";
}
const QwtSymbol symbol = this->symbol();
if (symbol.style() != QwtSymbol::NoSymbol){
s += "<Symbol>\n";
s += "\t<Style>" + QString::number(SymbolBox::symbolIndex(symbol.style())) + "</Style>\n";
s += "\t<Size>" + QString::number(symbol.size().width()) + "</Size>\n";
s += "\t<SymbolPen>\n";
s += "\t\t<Color>" + symbol.pen().color().name() + "</Color>\n";
s += "\t\t<Width>" + QString::number(symbol.pen().widthF()) + "</Width>\n";
s += "\t</SymbolPen>\n";
brush = this->brush();
if (brush.style() != Qt::NoBrush){
s += "\t<SymbolBrush>\n";
s += "\t\t<Color>" + symbol.brush().color().name() + "</Color>\n";
s += "\t\t<Style>" + QString::number(PatternBox::patternIndex(symbol.brush().style())) + "</Style>\n";
s += "\t</SymbolBrush>\n";
}
s += "</Symbol>\n";
}
s += "<xAxis>" + QString::number(xAxis()) + "</xAxis>\n";
s += "<yAxis>" + QString::number(yAxis()) + "</yAxis>\n";
s += "<Visible>" + QString::number(isVisible()) + "</Visible>\n";
return s;
}
static inline void qwtDrawDiamondSymbols( QPainter *painter,
const QPointF *points, int numPoints, const QwtSymbol &symbol )
{
const QSize size = symbol.size();
QPen pen = symbol.pen();
pen.setJoinStyle( Qt::MiterJoin );
painter->setPen( pen );
painter->setBrush( symbol.brush() );
if ( QwtPainter::roundingAlignment( painter ) )
{
for ( int i = 0; i < numPoints; i++ )
{
const int x = qRound( points[i].x() );
const int y = qRound( points[i].y() );
const int x1 = x - size.width() / 2;
const int y1 = y - size.height() / 2;
const int x2 = x1 + size.width();
const int y2 = y1 + size.height();
QPolygonF polygon;
polygon += QPointF( x, y1 );
polygon += QPointF( x1, y );
polygon += QPointF( x, y2 );
polygon += QPointF( x2, y );
QwtPainter::drawPolygon( painter, polygon );
}
}
else
{
for ( int i = 0; i < numPoints; i++ )
{
const QPointF &pos = points[i];
const double x1 = pos.x() - 0.5 * size.width();
const double y1 = pos.y() - 0.5 * size.height();
const double x2 = x1 + size.width();
const double y2 = y1 + size.height();
QPolygonF polygon;
polygon += QPointF( pos.x(), y1 );
polygon += QPointF( x2, pos.y() );
polygon += QPointF( pos.x(), y2 );
polygon += QPointF( x1, pos.y() );
QwtPainter::drawPolygon( painter, polygon );
}
}
}
void LegendWidget::drawSymbol(PlotCurve *c, int point, QPainter *p, int x, int y, int l)
{
if (!c || c->rtti() == QwtPlotItem::Rtti_PlotSpectrogram)
return;
if (c->type() == Graph::VectXYXY || c->type() == Graph::VectXYAM){
drawVector(c, p, x, y, l);
return;
}
if (c->type() == Graph::Pie){
QwtPieCurve *pie = (QwtPieCurve *)c;
const QBrush br = QBrush(pie->color(point), pie->pattern());
QPen pen = pie->pen();
p->save();
p->setPen (QPen(pen.color(), pen.widthF(), Qt::SolidLine));
QRect lr = QRect(x, y - 4, l, 10);
p->setBrush(br);
QwtPainter::drawRect(p, lr);
p->restore();
return;
}
QwtSymbol symb = c->symbol();
const QBrush br = c->brush();
QPen pen = c->pen();
p->save();
if (c->style()!=0){
p->setPen (pen);
if (br.style() != Qt::NoBrush || c->type() == Graph::Box){
QRect lr = QRect(x, y-4, l, 10);
p->setBrush(br);
QwtPainter::drawRect(p, lr);
} else
QwtPainter::drawLine(p, x, y, x + l, y);
}
int symb_size = symb.size().width();
if (symb_size > 15)
symb_size = 15;
else if (symb_size < 3)
symb_size = 3;
symb.setSize(symb_size);
symb.draw(p, x + l/2, y);
p->restore();
}
void PlotPropertiesGUI::consistCurveTab(const QString &name)
{
QwtPlotCurve *plotCurve = internalCurves.value(name)->plotCurve;
QwtSymbol symbol = plotCurve->symbol();
ui->symbolSizeSpinBox->setValue( symbol.size().width() );
ui->curveSymbolCombo->setCurrentIndex( (int)symbol.style() + 1); // Starts in -1
// Fixes bug built when used 'plotCurve->symbol()'
plotCurve->setSymbol(symbol);
ui->curveWidthSpinBox->setValue( plotCurve->pen().width() );
ui->curveStyleCombo->setCurrentIndex( (int)plotCurve->style() );
ui->lineStylecombo->setCurrentIndex( (int)plotCurve->pen().style() );
ui->curveColorButton->setStyleSheet(QString(" border-radius: 4px; "
"border: 1px solid rgb(0, 0, 0); background-color: %1")
.arg(plotCurve->pen().color().name()));
}
/*!
\brief Draw symbols
\param painter Painter
\param symbol Curve symbol
\param xMap x map
\param yMap y map
\param from index of the first point to be painted
\param to index of the last point to be painted
*/
void QwtCurve::drawSymbols(QPainter *painter, QwtSymbol &symbol,
const QwtDiMap &xMap, const QwtDiMap &yMap, int from, int to)
{
painter->setBrush(symbol.brush());
painter->setPen(symbol.pen());
QRect rect;
rect.setSize(QwtPainter::metricsMap().screenToLayout(symbol.size()));
for (int i = from; i <= to; i++)
{
const int xi = xMap.transform(x(i));
const int yi = yMap.transform(y(i));
rect.moveCenter(QPoint(xi, yi));
symbol.draw(painter, rect);
}
}
static inline void qwtDrawRectSymbols( QPainter *painter,
const QPointF *points, int numPoints, const QwtSymbol &symbol )
{
const QSize size = symbol.size();
QPen pen = symbol.pen();
pen.setJoinStyle( Qt::MiterJoin );
painter->setPen( pen );
painter->setBrush( symbol.brush() );
painter->setRenderHint( QPainter::Antialiasing, false );
if ( QwtPainter::roundingAlignment( painter ) )
{
const int sw = size.width();
const int sh = size.height();
const int sw2 = size.width() / 2;
const int sh2 = size.height() / 2;
for ( int i = 0; i < numPoints; i++ )
{
const int x = qRound( points[i].x() );
const int y = qRound( points[i].y() );
const QRect r( x - sw2, y - sh2, sw, sh );
QwtPainter::drawRect( painter, r );
}
}
else
{
const double sw = size.width();
const double sh = size.height();
const double sw2 = 0.5 * size.width();
const double sh2 = 0.5 * size.height();
for ( int i = 0; i < numPoints; i++ )
{
const double x = points[i].x();
const double y = points[i].y();
const QRectF r( x - sw2, y - sh2, sw, sh );
QwtPainter::drawRect( painter, r );
}
}
}
/*!
\brief Draw symbols
\param painter Painter
\param symbol Curve symbol
\param xMap x map
\param yMap y map
\param from index of the first point to be painted
\param to index of the last point to be painted
\sa setSymbol(), draw(), drawCurve()
*/
void QwtPlotCurve::drawSymbols(QPainter *painter, const QwtSymbol &symbol,
const QwtScaleMap &xMap, const QwtScaleMap &yMap,
int from, int to) const
{
painter->setBrush(symbol.brush());
painter->setPen(QwtPainter::scaledPen(symbol.pen()));
const QwtMetricsMap &metricsMap = QwtPainter::metricsMap();
QRect rect;
rect.setSize(metricsMap.screenToLayout(symbol.size()));
if ( to > from && d_data->paintAttributes & PaintFiltered )
{
const QRect window = painter->window();
if ( window.isEmpty() )
return;
PrivateData::PixelMatrix pixelMatrix(window);
for (int i = from; i <= to; i++)
{
const QPoint pi( xMap.transform(x(i)),
yMap.transform(y(i)) );
if ( pixelMatrix.testPixel(pi) )
{
rect.moveCenter(pi);
symbol.draw(painter, rect);
}
}
}
else
{
for (int i = from; i <= to; i++)
{
const int xi = xMap.transform(x(i));
const int yi = yMap.transform(y(i));
rect.moveCenter(QPoint(xi, yi));
symbol.draw(painter, rect);
}
}
}
static inline void qwtDrawEllipseSymbols( QPainter *painter,
const QPointF *points, int numPoints, const QwtSymbol &symbol )
{
painter->setBrush( symbol.brush() );
painter->setPen( symbol.pen() );
const QSize size = symbol.size();
if ( QwtPainter::roundingAlignment( painter ) )
{
const int sw = size.width();
const int sh = size.height();
const int sw2 = size.width() / 2;
const int sh2 = size.height() / 2;
for ( int i = 0; i < numPoints; i++ )
{
const int x = qRound( points[i].x() );
const int y = qRound( points[i].y() );
const QRectF r( x - sw2, y - sh2, sw, sh );
QwtPainter::drawEllipse( painter, r );
}
}
else
{
const double sw = size.width();
const double sh = size.height();
const double sw2 = 0.5 * size.width();
const double sh2 = 0.5 * size.height();
for ( int i = 0; i < numPoints; i++ )
{
const double x = points[i].x();
const double y = points[i].y();
const QRectF r( x - sw2, y - sh2, sw, sh );
QwtPainter::drawEllipse( painter, r );
}
}
}
/*!
Draw symbols
\param painter Painter
\param symbol Curve symbol
\param azimuthMap Maps azimuth values to values related to 0.0, M_2PI
\param radialMap Maps radius values into painter coordinates.
\param pole Position of the pole in painter coordinates
\param from index of the first point to be painted
\param to index of the last point to be painted.
\sa setSymbol(), draw(), drawCurve()
*/
void QwtPolarCurve::drawSymbols( QPainter *painter, const QwtSymbol &symbol,
const QwtScaleMap &azimuthMap, const QwtScaleMap &radialMap,
const QwtDoublePoint &pole, int from, int to ) const
{
painter->setBrush( symbol.brush() );
painter->setPen( symbol.pen() );
QRect rect;
rect.setSize( QwtPainter::metricsMap().screenToLayout( symbol.size() ) );
for ( int i = from; i <= to; i++ )
{
const QwtPolarPoint point = sample( i );
const double r = radialMap.xTransform( point.radius() );
const double a = azimuthMap.xTransform( point.azimuth() );
const QPoint pos = qwtPolar2Pos( pole, r, a ).toPoint();
rect.moveCenter( pos );
symbol.draw( painter, rect );
}
}
static inline void qwtDrawGraphicSymbols( QPainter *painter,
const QPointF *points, int numPoints, const QwtGraphic &graphic,
const QwtSymbol &symbol )
{
const QRectF pointRect = graphic.controlPointRect();
if ( pointRect.isEmpty() )
return;
double sx = 1.0;
double sy = 1.0;
const QSize sz = symbol.size();
if ( sz.isValid() )
{
sx = sz.width() / pointRect.width();
sy = sz.height() / pointRect.height();
}
QPointF pinPoint = pointRect.center();
if ( symbol.isPinPointEnabled() )
pinPoint = symbol.pinPoint();
const QTransform transform = painter->transform();
for ( int i = 0; i < numPoints; i++ )
{
QTransform tr = transform;
tr.translate( points[i].x(), points[i].y() );
tr.scale( sx, sy );
tr.translate( -pinPoint.x(), -pinPoint.y() );
painter->setTransform( tr );
graphic.render( painter );
}
painter->setTransform( transform );
}
static inline void qwtDrawTriangleSymbols(
QPainter *painter, QwtTriangle::Type type,
const QPointF *points, int numPoints,
const QwtSymbol &symbol )
{
const QSize size = symbol.size();
QPen pen = symbol.pen();
pen.setJoinStyle( Qt::MiterJoin );
painter->setPen( pen );
painter->setBrush( symbol.brush() );
const bool doAlign = QwtPainter::roundingAlignment( painter );
double sw2 = 0.5 * size.width();
double sh2 = 0.5 * size.height();
if ( doAlign )
{
sw2 = qFloor( sw2 );
sh2 = qFloor( sh2 );
}
QPolygonF triangle( 3 );
QPointF *trianglePoints = triangle.data();
for ( int i = 0; i < numPoints; i++ )
{
const QPointF &pos = points[i];
double x = pos.x();
double y = pos.y();
if ( doAlign )
{
x = qRound( x );
y = qRound( y );
}
const double x1 = x - sw2;
const double x2 = x1 + size.width();
const double y1 = y - sh2;
const double y2 = y1 + size.height();
switch ( type )
{
case QwtTriangle::Left:
{
trianglePoints[0].rx() = x2;
trianglePoints[0].ry() = y1;
trianglePoints[1].rx() = x1;
trianglePoints[1].ry() = y;
trianglePoints[2].rx() = x2;
trianglePoints[2].ry() = y2;
break;
}
case QwtTriangle::Right:
{
trianglePoints[0].rx() = x1;
trianglePoints[0].ry() = y1;
trianglePoints[1].rx() = x2;
trianglePoints[1].ry() = y;
trianglePoints[2].rx() = x1;
trianglePoints[2].ry() = y2;
break;
}
case QwtTriangle::Up:
{
trianglePoints[0].rx() = x1;
trianglePoints[0].ry() = y2;
trianglePoints[1].rx() = x;
trianglePoints[1].ry() = y1;
trianglePoints[2].rx() = x2;
trianglePoints[2].ry() = y2;
break;
}
case QwtTriangle::Down:
{
trianglePoints[0].rx() = x1;
trianglePoints[0].ry() = y1;
trianglePoints[1].rx() = x;
trianglePoints[1].ry() = y2;
trianglePoints[2].rx() = x2;
trianglePoints[2].ry() = y1;
break;
}
}
QwtPainter::drawPolygon( painter, triangle );
}
}
//! == operator
bool QwtSymbol::operator==(const QwtSymbol &other) const
{
return brush() == other.brush() && pen() == other.pen()
&& style() == other.style() && size() == other.size();
}
QString PlotCurve::saveCurveLayout()
{
QString s = "<Style>" + QString::number(d_plot_style) + "</Style>\n";
if (d_plot_style == Graph::Spline)
s += "<LineStyle>5</LineStyle>\n";
else if (d_plot_style == Graph::VerticalSteps)
s += "<LineStyle>6</LineStyle>\n";
else
s += "<LineStyle>" + QString::number(this->style()) + "</LineStyle>\n";
QPen pen = this->pen();
if (pen.style() != Qt::NoPen) {
s += "<Pen>\n";
s += "\t<Color>" + pen.color().name() + "</Color>\n";
if (pen.color().alpha() != 255)
s += "\t<Alpha>" + QString::number(pen.color().alpha()) + "</Alpha>\n";
s += "\t<Style>" + QString::number(pen.style()-1) + "</Style>\n";
s += "\t<Width>" + QString::number(pen.widthF()) + "</Width>\n";
s += "</Pen>\n";
}
QBrush brush = this->brush();
if (brush.style() != Qt::NoBrush) {
s += "<Brush>\n";
s += "\t<Color>" + brush.color().name() + "</Color>\n";
if (brush.color().alpha() != 255)
s += "\t<Alpha>" + QString::number(brush.color().alpha()) + "</Alpha>\n";
s += "\t<Style>" + QString::number(PatternBox::patternIndex(brush.style())) + "</Style>\n";
s += "</Brush>\n";
}
const QwtSymbol symbol = this->symbol();
if (symbol.style() != QwtSymbol::NoSymbol) {
s += "<Symbol>\n";
s += "\t<Style>" + QString::number(SymbolBox::symbolIndex(symbol.style())) + "</Style>\n";
s += "\t<Size>" + QString::number(symbol.size().width()) + "</Size>\n";
s += "\t<SymbolPen>\n";
s += "\t\t<Color>" + symbol.pen().color().name() + "</Color>\n";
if (symbol.pen().color().alpha() != 255)
s += "\t<Alpha>" + QString::number(symbol.pen().color().alpha()) + "</Alpha>\n";
s += "\t\t<Width>" + QString::number(symbol.pen().widthF()) + "</Width>\n";
s += "\t</SymbolPen>\n";
brush = this->brush();
if (brush.style() != Qt::NoBrush) {
s += "\t<SymbolBrush>\n";
s += "\t\t<Color>" + symbol.brush().color().name() + "</Color>\n";
if (symbol.brush().color().alpha() != 255)
s += "\t<Alpha>" + QString::number(symbol.brush().color().alpha()) + "</Alpha>\n";
s += "\t\t<Style>" + QString::number(PatternBox::patternIndex(symbol.brush().style())) + "</Style>\n";
s += "\t</SymbolBrush>\n";
}
s += "</Symbol>\n";
}
s += "<xAxis>" + QString::number(xAxis()) + "</xAxis>\n";
s += "<yAxis>" + QString::number(yAxis()) + "</yAxis>\n";
s += "<CurveType>" + QString::number(curveType()) + "</CurveType>\n";
s += "<Visible>" + QString::number(isVisible()) + "</Visible>\n";
return s;
}
static inline void qwtDrawHexagonSymbols( QPainter *painter,
const QPointF *points, int numPoints, const QwtSymbol &symbol )
{
painter->setBrush( symbol.brush() );
painter->setPen( symbol.pen() );
const double cos30 = 0.866025; // cos(30°)
const double dx = 0.5 * ( symbol.size().width() - cos30 );
const double dy = 0.25 * symbol.size().height();
QPolygonF hexaPolygon( 6 );
QPointF *hexaPoints = hexaPolygon.data();
const bool doAlign = QwtPainter::roundingAlignment( painter );
for ( int i = 0; i < numPoints; i++ )
{
double x = points[i].x();
double y = points[i].y();
if ( doAlign )
{
x = qRound( x );
y = qRound( y );
}
double x1 = x - dx;
double y1 = y - 2 * dy;
if ( doAlign )
{
x1 = qCeil( x1 );
y1 = qCeil( y1 );
}
const double x2 = x1 + 1 * dx;
const double x3 = x1 + 2 * dx;
const double y2 = y1 + 1 * dy;
const double y3 = y1 + 3 * dy;
const double y4 = y1 + 4 * dy;
hexaPoints[0].rx() = x2;
hexaPoints[0].ry() = y1;
hexaPoints[1].rx() = x3;
hexaPoints[1].ry() = y2;
hexaPoints[2].rx() = x3;
hexaPoints[2].ry() = y3;
hexaPoints[3].rx() = x2;
hexaPoints[3].ry() = y4;
hexaPoints[4].rx() = x1;
hexaPoints[4].ry() = y3;
hexaPoints[5].rx() = x1;
hexaPoints[5].ry() = y2;
QwtPainter::drawPolygon( painter, hexaPolygon );
}
}
static inline void qwtDrawStar2Symbols( QPainter *painter,
const QPointF *points, int numPoints, const QwtSymbol &symbol )
{
QPen pen = symbol.pen();
if ( pen.width() > 1 )
pen.setCapStyle( Qt::FlatCap );
pen.setJoinStyle( Qt::MiterJoin );
painter->setPen( pen );
painter->setBrush( symbol.brush() );
const double cos30 = 0.866025; // cos(30°)
const double dy = 0.25 * symbol.size().height();
const double dx = 0.5 * symbol.size().width() * cos30 / 3.0;
QPolygonF star( 12 );
QPointF *starPoints = star.data();
const bool doAlign = QwtPainter::roundingAlignment( painter );
for ( int i = 0; i < numPoints; i++ )
{
double x = points[i].x();
double y = points[i].y();
if ( doAlign )
{
x = qRound( x );
y = qRound( y );
}
double x1 = x - 3 * dx;
double y1 = y - 2 * dy;
if ( doAlign )
{
x1 = qRound( x - 3 * dx );
y1 = qRound( y - 2 * dy );
}
const double x2 = x1 + 1 * dx;
const double x3 = x1 + 2 * dx;
const double x4 = x1 + 3 * dx;
const double x5 = x1 + 4 * dx;
const double x6 = x1 + 5 * dx;
const double x7 = x1 + 6 * dx;
const double y2 = y1 + 1 * dy;
const double y3 = y1 + 2 * dy;
const double y4 = y1 + 3 * dy;
const double y5 = y1 + 4 * dy;
starPoints[0].rx() = x4;
starPoints[0].ry() = y1;
starPoints[1].rx() = x5;
starPoints[1].ry() = y2;
starPoints[2].rx() = x7;
starPoints[2].ry() = y2;
starPoints[3].rx() = x6;
starPoints[3].ry() = y3;
starPoints[4].rx() = x7;
starPoints[4].ry() = y4;
starPoints[5].rx() = x5;
starPoints[5].ry() = y4;
starPoints[6].rx() = x4;
starPoints[6].ry() = y5;
starPoints[7].rx() = x3;
starPoints[7].ry() = y4;
starPoints[8].rx() = x1;
starPoints[8].ry() = y4;
starPoints[9].rx() = x2;
starPoints[9].ry() = y3;
starPoints[10].rx() = x1;
starPoints[10].ry() = y2;
starPoints[11].rx() = x3;
starPoints[11].ry() = y2;
QwtPainter::drawPolygon( painter, star );
}
}
static inline void qwtDrawStar1Symbols( QPainter *painter,
const QPointF *points, int numPoints, const QwtSymbol &symbol )
{
const QSize size = symbol.size();
painter->setPen( symbol.pen() );
if ( QwtPainter::roundingAlignment( painter ) )
{
QRect r( 0, 0, size.width(), size.height() );
for ( int i = 0; i < numPoints; i++ )
{
r.moveCenter( points[i].toPoint() );
const double sqrt1_2 = 0.70710678118654752440; /* 1/sqrt(2) */
const double d1 = r.width() / 2.0 * ( 1.0 - sqrt1_2 );
QwtPainter::drawLine( painter,
qRound( r.left() + d1 ), qRound( r.top() + d1 ),
qRound( r.right() - d1 ), qRound( r.bottom() - d1 ) );
QwtPainter::drawLine( painter,
qRound( r.left() + d1 ), qRound( r.bottom() - d1 ),
qRound( r .right() - d1), qRound( r.top() + d1 ) );
const QPoint c = r.center();
QwtPainter::drawLine( painter,
c.x(), r.top(), c.x(), r.bottom() );
QwtPainter::drawLine( painter,
r.left(), c.y(), r.right(), c.y() );
}
}
else
{
QRectF r( 0, 0, size.width(), size.height() );
for ( int i = 0; i < numPoints; i++ )
{
r.moveCenter( points[i] );
const double sqrt1_2 = 0.70710678118654752440; /* 1/sqrt(2) */
const QPointF c = r.center();
const double d1 = r.width() / 2.0 * ( 1.0 - sqrt1_2 );
QwtPainter::drawLine( painter,
r.left() + d1, r.top() + d1,
r.right() - d1, r.bottom() - d1 );
QwtPainter::drawLine( painter,
r.left() + d1, r.bottom() - d1,
r.right() - d1, r.top() + d1 );
QwtPainter::drawLine( painter,
c.x(), r.top(),
c.x(), r.bottom() );
QwtPainter::drawLine( painter,
r.left(), c.y(),
r.right(), c.y() );
}
}
}
static inline void qwtDrawLineSymbols(
QPainter *painter, int orientations,
const QPointF *points, int numPoints, const QwtSymbol &symbol )
{
const QSize size = symbol.size();
int off = 0;
QPen pen = symbol.pen();
if ( pen.width() > 1 )
{
pen.setCapStyle( Qt::FlatCap );
off = 1;
}
painter->setPen( pen );
painter->setRenderHint( QPainter::Antialiasing, false );
if ( QwtPainter::roundingAlignment( painter ) )
{
const int sw = qFloor( size.width() );
const int sh = qFloor( size.height() );
const int sw2 = size.width() / 2;
const int sh2 = size.height() / 2;
for ( int i = 0; i < numPoints; i++ )
{
if ( orientations & Qt::Horizontal )
{
const int x = qRound( points[i].x() ) - sw2;
const int y = qRound( points[i].y() );
QwtPainter::drawLine( painter, x, y, x + sw + off, y );
}
if ( orientations & Qt::Vertical )
{
const int x = qRound( points[i].x() );
const int y = qRound( points[i].y() ) - sh2;
QwtPainter::drawLine( painter, x, y, x, y + sh + off );
}
}
}
else
{
const double sw = size.width();
const double sh = size.height();
const double sw2 = 0.5 * size.width();
const double sh2 = 0.5 * size.height();
for ( int i = 0; i < numPoints; i++ )
{
if ( orientations & Qt::Horizontal )
{
const double x = points[i].x() - sw2;
const double y = points[i].y();
QwtPainter::drawLine( painter, x, y, x + sw, y );
}
if ( orientations & Qt::Vertical )
{
const double y = points[i].y() - sh2;
const double x = points[i].x();
QwtPainter::drawLine( painter, x, y, x, y + sh );
}
}
}
}
/*!
\brief Copy constructor
\param other Symbol
*/
QwtSymbol::QwtSymbol( const QwtSymbol &other )
{
d_data = new PrivateData( other.style(), other.brush(),
other.pen(), other.size() );
};
