10 #include "qwt_symbol.h" 
   11 #include "qwt_painter.h" 
   12 #include "qwt_graphic.h" 
   16 #include <qpainterpath.h> 
   18 #include <qpaintengine.h> 
   20 #include <qsvgrenderer.h> 
   34 static QwtGraphic qwtPathGraphic( 
const QPainterPath& path,
 
   35     const QPen& pen, 
const QBrush& brush )
 
   40     QPainter painter( &graphic );
 
   41     painter.setPen( pen );
 
   42     painter.setBrush( brush );
 
   43     painter.drawPath( path );
 
   49 static inline QRectF qwtScaledBoundingRect(
 
   52     QSizeF scaledSize = size;
 
   53     if ( scaledSize.isEmpty() )
 
   59     if ( sz.width() > 0.0 )
 
   60         sx = scaledSize.width() / sz.width();
 
   63     if ( sz.height() > 0.0 )
 
   64         sy = scaledSize.height() / sz.height();
 
   69 static inline void qwtDrawPixmapSymbols( QPainter* painter,
 
   70     const QPointF* points, 
int numPoints, 
const QwtSymbol& symbol )
 
   72     QSize size = symbol.
size();
 
   74         size = symbol.
pixmap().size();
 
   76     const QTransform transform = painter->transform();
 
   77     if ( transform.isScaling() )
 
   79         const QRect r( 0, 0, size.width(), size.height() );
 
   80         size = transform.mapRect( r ).size();
 
   83     QPixmap pm = symbol.
pixmap();
 
   84     if ( pm.size() != size )
 
   85         pm = pm.scaled( size );
 
   87     QPointF pinPoint( 0.5 * size.width(), 0.5 * size.height() );
 
   91     painter->resetTransform();
 
   93     for ( 
int i = 0; i < numPoints; i++ )
 
   95         const QPointF pos = transform.map( points[i] ) - pinPoint;
 
   98             QRect( pos.toPoint(), pm.size() ), pm );
 
  104 static inline void qwtDrawSvgSymbols( QPainter* painter,
 
  105     const QPointF* points, 
int numPoints,
 
  106     QSvgRenderer* renderer, 
const QwtSymbol& symbol )
 
  108     if ( renderer == NULL || !renderer->isValid() )
 
  111     const QRectF viewBox = renderer->viewBoxF();
 
  112     if ( viewBox.isEmpty() )
 
  115     QSizeF sz = symbol.
size();
 
  119     const double sx = sz.width() / viewBox.width();
 
  120     const double sy = sz.height() / viewBox.height();
 
  122     QPointF pinPoint = viewBox.center();
 
  126     const double dx = sx * ( pinPoint.x() - viewBox.left() );
 
  127     const double dy = sy * ( pinPoint.y() - viewBox.top() );
 
  129     for ( 
int i = 0; i < numPoints; i++ )
 
  131         const double x = points[i].x() - dx;
 
  132         const double y = points[i].y() - dy;
 
  134         renderer->render( painter,
 
  135             QRectF( x, y, sz.width(), sz.height() ) );
 
  141 static inline void qwtDrawGraphicSymbols( QPainter* painter,
 
  142     const QPointF* points, 
int numPoints, 
const QwtGraphic& graphic,
 
  146     if ( pointRect.isEmpty() )
 
  152     const QSize sz = symbol.
size();
 
  155         sx = sz.width() / pointRect.width();
 
  156         sy = sz.height() / pointRect.height();
 
  159     QPointF pinPoint = pointRect.center();
 
  163     const QTransform transform = painter->transform();
 
  165     for ( 
int i = 0; i < numPoints; i++ )
 
  167         QTransform tr = transform;
 
  168         tr.translate( points[i].x(), points[i].y() );
 
  170         tr.translate( -pinPoint.x(), -pinPoint.y() );
 
  172         painter->setTransform( tr );
 
  174         graphic.
render( painter );
 
  177     painter->setTransform( transform );
 
  180 static inline void qwtDrawEllipseSymbols( QPainter* painter,
 
  181     const QPointF* points, 
int numPoints, 
const QwtSymbol& symbol )
 
  183     painter->setBrush( symbol.
brush() );
 
  184     painter->setPen( symbol.
pen() );
 
  186     const QSize size = symbol.
size();
 
  190         const int sw = size.width();
 
  191         const int sh = size.height();
 
  192         const int sw2 = size.width() / 2;
 
  193         const int sh2 = size.height() / 2;
 
  195         for ( 
int i = 0; i < numPoints; i++ )
 
  197             const int x = qRound( points[i].x() );
 
  198             const int y = qRound( points[i].y() );
 
  200             const QRectF r( x - sw2, y - sh2, sw, sh );
 
  206         const double sw = size.width();
 
  207         const double sh = size.height();
 
  208         const double sw2 = 0.5 * size.width();
 
  209         const double sh2 = 0.5 * size.height();
 
  211         for ( 
int i = 0; i < numPoints; i++ )
 
  213             const double x = points[i].x();
 
  214             const double y = points[i].y();
 
  216             const QRectF r( x - sw2, y - sh2, sw, sh );
 
  222 static inline void qwtDrawRectSymbols( QPainter* painter,
 
  223     const QPointF* points, 
int numPoints, 
const QwtSymbol& symbol )
 
  225     const QSize size = symbol.
size();
 
  227     QPen pen = symbol.
pen();
 
  228     pen.setJoinStyle( Qt::MiterJoin );
 
  229     painter->setPen( pen );
 
  230     painter->setBrush( symbol.
brush() );
 
  231     painter->setRenderHint( QPainter::Antialiasing, 
false );
 
  235         const int sw = size.width();
 
  236         const int sh = size.height();
 
  237         const int sw2 = size.width() / 2;
 
  238         const int sh2 = size.height() / 2;
 
  240         for ( 
int i = 0; i < numPoints; i++ )
 
  242             const int x = qRound( points[i].x() );
 
  243             const int y = qRound( points[i].y() );
 
  245             const QRect r( x - sw2, y - sh2, sw, sh );
 
  251         const double sw = size.width();
 
  252         const double sh = size.height();
 
  253         const double sw2 = 0.5 * size.width();
 
  254         const double sh2 = 0.5 * size.height();
 
  256         for ( 
int i = 0; i < numPoints; i++ )
 
  258             const double x = points[i].x();
 
  259             const double y = points[i].y();
 
  261             const QRectF r( x - sw2, y - sh2, sw, sh );
 
  267 static inline void qwtDrawDiamondSymbols( QPainter* painter,
 
  268     const QPointF* points, 
int numPoints, 
const QwtSymbol& symbol )
 
  270     const QSize size = symbol.
size();
 
  272     QPen pen = symbol.
pen();
 
  273     pen.setJoinStyle( Qt::MiterJoin );
 
  274     painter->setPen( pen );
 
  275     painter->setBrush( symbol.
brush() );
 
  279         for ( 
int i = 0; i < numPoints; i++ )
 
  281             const int x = qRound( points[i].x() );
 
  282             const int y = qRound( points[i].y() );
 
  284             const int x1 = x - size.width() / 2;
 
  285             const int y1 = y - size.height() / 2;
 
  286             const int x2 = x1 + size.width();
 
  287             const int y2 = y1 + size.height();
 
  290             polygon += QPointF( x, y1 );
 
  291             polygon += QPointF( x1, y );
 
  292             polygon += QPointF( x, y2 );
 
  293             polygon += QPointF( x2, y );
 
  300         for ( 
int i = 0; i < numPoints; i++ )
 
  302             const QPointF& pos = points[i];
 
  304             const double x1 = pos.x() - 0.5 * size.width();
 
  305             const double y1 = pos.y() - 0.5 * size.height();
 
  306             const double x2 = x1 + size.width();
 
  307             const double y2 = y1 + size.height();
 
  310             polygon += QPointF( pos.x(), y1 );
 
  311             polygon += QPointF( x2, pos.y() );
 
  312             polygon += QPointF( pos.x(), y2 );
 
  313             polygon += QPointF( x1, pos.y() );
 
  320 static inline void qwtDrawTriangleSymbols(
 
  321     QPainter* painter, QwtTriangle::Type type,
 
  322     const QPointF* points, 
int numPoints,
 
  325     const QSize size = symbol.
size();
 
  327     QPen pen = symbol.
pen();
 
  328     pen.setJoinStyle( Qt::MiterJoin );
 
  329     painter->setPen( pen );
 
  331     painter->setBrush( symbol.
brush() );
 
  335     double sw2 = 0.5 * size.width();
 
  336     double sh2 = 0.5 * size.height();
 
  340         sw2 = std::floor( sw2 );
 
  341         sh2 = std::floor( sh2 );
 
  344     QPolygonF triangle( 3 );
 
  345     QPointF* trianglePoints = triangle.data();
 
  347     for ( 
int i = 0; i < numPoints; i++ )
 
  349         const QPointF& pos = points[i];
 
  360         const double x1 = x - sw2;
 
  361         const double x2 = x1 + size.width();
 
  362         const double y1 = y - sh2;
 
  363         const double y2 = y1 + size.height();
 
  367             case QwtTriangle::Left:
 
  369                 trianglePoints[0].rx() = x2;
 
  370                 trianglePoints[0].ry() = y1;
 
  372                 trianglePoints[1].rx() = x1;
 
  373                 trianglePoints[1].ry() = y;
 
  375                 trianglePoints[2].rx() = x2;
 
  376                 trianglePoints[2].ry() = y2;
 
  380             case QwtTriangle::Right:
 
  382                 trianglePoints[0].rx() = x1;
 
  383                 trianglePoints[0].ry() = y1;
 
  385                 trianglePoints[1].rx() = x2;
 
  386                 trianglePoints[1].ry() = y;
 
  388                 trianglePoints[2].rx() = x1;
 
  389                 trianglePoints[2].ry() = y2;
 
  393             case QwtTriangle::Up:
 
  395                 trianglePoints[0].rx() = x1;
 
  396                 trianglePoints[0].ry() = y2;
 
  398                 trianglePoints[1].rx() = x;
 
  399                 trianglePoints[1].ry() = y1;
 
  401                 trianglePoints[2].rx() = x2;
 
  402                 trianglePoints[2].ry() = y2;
 
  406             case QwtTriangle::Down:
 
  408                 trianglePoints[0].rx() = x1;
 
  409                 trianglePoints[0].ry() = y1;
 
  411                 trianglePoints[1].rx() = x;
 
  412                 trianglePoints[1].ry() = y2;
 
  414                 trianglePoints[2].rx() = x2;
 
  415                 trianglePoints[2].ry() = y1;
 
  424 static inline void qwtDrawLineSymbols(
 
  425     QPainter* painter, 
int orientations,
 
  426     const QPointF* points, 
int numPoints, 
const QwtSymbol& symbol )
 
  428     const QSize size = symbol.
size();
 
  432     QPen pen = symbol.
pen();
 
  433     if ( pen.width() > 1 )
 
  435         pen.setCapStyle( Qt::FlatCap );
 
  439     painter->setPen( pen );
 
  440     painter->setRenderHint( QPainter::Antialiasing, 
false );
 
  444         const int sw = qwtFloor( size.width() );
 
  445         const int sh = qwtFloor( size.height() );
 
  446         const int sw2 = size.width() / 2;
 
  447         const int sh2 = size.height() / 2;
 
  449         for ( 
int i = 0; i < numPoints; i++ )
 
  451             if ( orientations & Qt::Horizontal )
 
  453                 const int x = qRound( points[i].x() ) - sw2;
 
  454                 const int y = qRound( points[i].y() );
 
  458             if ( orientations & Qt::Vertical )
 
  460                 const int x = qRound( points[i].x() );
 
  461                 const int y = qRound( points[i].y() ) - sh2;
 
  469         const double sw = size.width();
 
  470         const double sh = size.height();
 
  471         const double sw2 = 0.5 * size.width();
 
  472         const double sh2 = 0.5 * size.height();
 
  474         for ( 
int i = 0; i < numPoints; i++ )
 
  476             if ( orientations & Qt::Horizontal )
 
  478                 const double x = points[i].x() - sw2;
 
  479                 const double y = points[i].y();
 
  483             if ( orientations & Qt::Vertical )
 
  485                 const double y = points[i].y() - sh2;
 
  486                 const double x = points[i].x();
 
  494 static inline void qwtDrawXCrossSymbols( QPainter* painter,
 
  495     const QPointF* points, 
int numPoints, 
const QwtSymbol& symbol )
 
  497     const QSize size = symbol.
size();
 
  500     QPen pen = symbol.
pen();
 
  501     if ( pen.width() > 1 )
 
  503         pen.setCapStyle( Qt::FlatCap );
 
  506     painter->setPen( pen );
 
  511         const int sw = size.width();
 
  512         const int sh = size.height();
 
  513         const int sw2 = size.width() / 2;
 
  514         const int sh2 = size.height() / 2;
 
  516         for ( 
int i = 0; i < numPoints; i++ )
 
  518             const QPointF& pos = points[i];
 
  520             const int x = qRound( pos.x() );
 
  521             const int y = qRound( pos.y() );
 
  523             const int x1 = x - sw2;
 
  524             const int x2 = x1 + sw + off;
 
  525             const int y1 = y - sh2;
 
  526             const int y2 = y1 + sh + off;
 
  534         const double sw = size.width();
 
  535         const double sh = size.height();
 
  536         const double sw2 = 0.5 * size.width();
 
  537         const double sh2 = 0.5 * size.height();
 
  539         for ( 
int i = 0; i < numPoints; i++ )
 
  541             const QPointF& pos = points[i];
 
  543             const double x1 = pos.x() - sw2;
 
  544             const double x2 = x1 + sw;
 
  545             const double y1 = pos.y() - sh2;
 
  546             const double y2 = y1 + sh;
 
  554 static inline void qwtDrawStar1Symbols( QPainter* painter,
 
  555     const QPointF* points, 
int numPoints, 
const QwtSymbol& symbol )
 
  557     const QSize size = symbol.
size();
 
  558     painter->setPen( symbol.
pen() );
 
  562         QRect r( 0, 0, size.width(), size.height() );
 
  564         for ( 
int i = 0; i < numPoints; i++ )
 
  566             r.moveCenter( points[i].toPoint() );
 
  568             const double sqrt1_2 = 0.70710678118654752440; 
 
  570             const double d1 = r.width() / 2.0 * ( 1.0 - sqrt1_2 );
 
  573                 qRound( r.left() + d1 ), qRound( r.top() + d1 ),
 
  574                 qRound( r.right() - d1 ), qRound( r.bottom() - d1 ) );
 
  576                 qRound( r.left() + d1 ), qRound( r.bottom() - d1 ),
 
  577                 qRound( r.right() - d1), qRound( r.top() + d1 ) );
 
  579             const QPoint c = r.center();
 
  582                 c.x(), r.top(), c.x(), r.bottom() );
 
  584                 r.left(), c.y(), r.right(), c.y() );
 
  589         QRectF r( 0, 0, size.width(), size.height() );
 
  591         for ( 
int i = 0; i < numPoints; i++ )
 
  593             r.moveCenter( points[i] );
 
  595             const double sqrt1_2 = 0.70710678118654752440; 
 
  597             const QPointF c = r.center();
 
  598             const double d1 = r.width() / 2.0 * ( 1.0 - sqrt1_2 );
 
  601                 r.left() + d1, r.top() + d1,
 
  602                 r.right() - d1, r.bottom() - d1 );
 
  604                 r.left() + d1, r.bottom() - d1,
 
  605                 r.right() - d1, r.top() + d1 );
 
  616 static inline void qwtDrawStar2Symbols( QPainter* painter,
 
  617     const QPointF* points, 
int numPoints, 
const QwtSymbol& symbol )
 
  619     QPen pen = symbol.
pen();
 
  620     if ( pen.width() > 1 )
 
  621         pen.setCapStyle( Qt::FlatCap );
 
  622     pen.setJoinStyle( Qt::MiterJoin );
 
  623     painter->setPen( pen );
 
  625     painter->setBrush( symbol.
brush() );
 
  627     const double cos30 = 0.866025; 
 
  629     const double dy = 0.25 * symbol.
size().height();
 
  630     const double dx = 0.5 * symbol.
size().width() * cos30 / 3.0;
 
  632     QPolygonF star( 12 );
 
  633     QPointF* starPoints = star.data();
 
  637     for ( 
int i = 0; i < numPoints; i++ )
 
  639         double x = points[i].x();
 
  640         double y = points[i].y();
 
  647         double x1 = x - 3 * dx;
 
  648         double y1 = y - 2 * dy;
 
  651             x1 = qRound( x - 3 * dx );
 
  652             y1 = qRound( y - 2 * dy );
 
  655         const double x2 = x1 + 1 * dx;
 
  656         const double x3 = x1 + 2 * dx;
 
  657         const double x4 = x1 + 3 * dx;
 
  658         const double x5 = x1 + 4 * dx;
 
  659         const double x6 = x1 + 5 * dx;
 
  660         const double x7 = x1 + 6 * dx;
 
  662         const double y2 = y1 + 1 * dy;
 
  663         const double y3 = y1 + 2 * dy;
 
  664         const double y4 = y1 + 3 * dy;
 
  665         const double y5 = y1 + 4 * dy;
 
  667         starPoints[0].rx() = x4;
 
  668         starPoints[0].ry() = y1;
 
  670         starPoints[1].rx() = x5;
 
  671         starPoints[1].ry() = y2;
 
  673         starPoints[2].rx() = x7;
 
  674         starPoints[2].ry() = y2;
 
  676         starPoints[3].rx() = x6;
 
  677         starPoints[3].ry() = y3;
 
  679         starPoints[4].rx() = x7;
 
  680         starPoints[4].ry() = y4;
 
  682         starPoints[5].rx() = x5;
 
  683         starPoints[5].ry() = y4;
 
  685         starPoints[6].rx() = x4;
 
  686         starPoints[6].ry() = y5;
 
  688         starPoints[7].rx() = x3;
 
  689         starPoints[7].ry() = y4;
 
  691         starPoints[8].rx() = x1;
 
  692         starPoints[8].ry() = y4;
 
  694         starPoints[9].rx() = x2;
 
  695         starPoints[9].ry() = y3;
 
  697         starPoints[10].rx() = x1;
 
  698         starPoints[10].ry() = y2;
 
  700         starPoints[11].rx() = x3;
 
  701         starPoints[11].ry() = y2;
 
  707 static inline void qwtDrawHexagonSymbols( QPainter* painter,
 
  708     const QPointF* points, 
int numPoints, 
const QwtSymbol& symbol )
 
  710     painter->setBrush( symbol.
brush() );
 
  711     painter->setPen( symbol.
pen() );
 
  713     const double cos30 = 0.866025; 
 
  714     const double dx = 0.5 * ( symbol.
size().width() - cos30 );
 
  716     const double dy = 0.25 * symbol.
size().height();
 
  718     QPolygonF hexaPolygon( 6 );
 
  719     QPointF* hexaPoints = hexaPolygon.data();
 
  723     for ( 
int i = 0; i < numPoints; i++ )
 
  725         double x = points[i].x();
 
  726         double y = points[i].y();
 
  734         double y1 = y - 2 * dy;
 
  737             x1 = std::ceil( x1 );
 
  738             y1 = std::ceil( y1 );
 
  741         const double x2 = x1 + 1 * dx;
 
  742         const double x3 = x1 + 2 * dx;
 
  744         const double y2 = y1 + 1 * dy;
 
  745         const double y3 = y1 + 3 * dy;
 
  746         const double y4 = y1 + 4 * dy;
 
  748         hexaPoints[0].rx() = x2;
 
  749         hexaPoints[0].ry() = y1;
 
  751         hexaPoints[1].rx() = x3;
 
  752         hexaPoints[1].ry() = y2;
 
  754         hexaPoints[2].rx() = x3;
 
  755         hexaPoints[2].ry() = y3;
 
  757         hexaPoints[3].rx() = x2;
 
  758         hexaPoints[3].ry() = y4;
 
  760         hexaPoints[4].rx() = x1;
 
  761         hexaPoints[4].ry() = y3;
 
  763         hexaPoints[5].rx() = x1;
 
  764         hexaPoints[5].ry() = y2;
 
  770 class QwtSymbol::PrivateData
 
  774             const QPen& pn, 
const QSize& sz )
 
  824         QSvgRenderer* renderer;
 
  845     m_data = 
new PrivateData( 
style, QBrush( Qt::gray ),
 
  846         QPen( Qt::black, 0 ), QSize() );
 
  859     const QPen& pen, 
const QSize& size )
 
  879     const QBrush& brush, 
const QPen& pen )
 
  902     if ( m_data->cache.policy != policy )
 
  904         m_data->cache.policy = policy;
 
  915     return m_data->cache.policy;
 
  969     m_data->path.path = 
path;
 
  970     m_data->path.graphic.reset();
 
  979     return m_data->path.path;
 
  995     m_data->pixmap.pixmap = 
pixmap;
 
 1004     return m_data->pixmap.pixmap;
 
 1020     m_data->graphic.graphic = 
graphic;
 
 1029     return m_data->graphic.graphic;
 
 1047     if ( m_data->svg.renderer == NULL )
 
 1048         m_data->svg.renderer = 
new QSvgRenderer();
 
 1050     m_data->svg.renderer->load( svgDocument );
 
 1069     if ( ( width >= 0 ) && ( height < 0 ) )
 
 1072     setSize( QSize( width, height ) );
 
 1083     if ( 
size.isValid() && 
size != m_data->size )
 
 1085         m_data->size = 
size;
 
 1096     return m_data->size;
 
 1109     if ( 
brush != m_data->brush )
 
 1111         m_data->brush = 
brush;
 
 1115             m_data->path.graphic.reset();
 
 1125     return m_data->brush;
 
 1142     qreal width, Qt::PenStyle style )
 
 1157     if ( 
pen != m_data->pen )
 
 1163             m_data->path.graphic.reset();
 
 1188     switch ( m_data->style )
 
 1201             if ( m_data->brush.color() != color )
 
 1203                 m_data->brush.setColor( color );
 
 1214             if ( m_data->pen.color() != color )
 
 1216                 m_data->pen.setColor( color );
 
 1223             if ( m_data->brush.color() != color ||
 
 1224                 m_data->pen.color() != color )
 
 1229             m_data->brush.setColor( color );
 
 1230             m_data->pen.setColor( color );
 
 1251     if ( m_data->pinPoint != pos )
 
 1253         m_data->pinPoint = pos;
 
 1254         if ( m_data->isPinPointEnabled )
 
 1269     return m_data->pinPoint;
 
 1280     if ( m_data->isPinPointEnabled != on )
 
 1282         m_data->isPinPointEnabled = on;
 
 1293     return m_data->isPinPointEnabled;
 
 1308     const QPointF* points, 
int numPoints )
 const 
 1310     if ( numPoints <= 0 )
 
 1313     bool useCache = 
false;
 
 1319         !painter->transform().isScaling() )
 
 1327             switch( painter->paintEngine()->type() )
 
 1329                 case QPaintEngine::OpenGL:
 
 1330                 case QPaintEngine::OpenGL2:
 
 1336                 case QPaintEngine::OpenVG:
 
 1337                 case QPaintEngine::SVG:
 
 1338                 case QPaintEngine::Pdf:
 
 1339                 case QPaintEngine::Picture:
 
 1345                 case QPaintEngine::X11:
 
 1347                     switch( m_data->style )
 
 1363                             if ( m_data->size.isEmpty() ||
 
 1364                                 m_data->size == m_data->pixmap.pixmap.size() )
 
 1390         if ( m_data->cache.pixmap.isNull() )
 
 1393             m_data->cache.pixmap.fill( Qt::transparent );
 
 1395             QPainter p( &m_data->cache.pixmap );
 
 1396             p.setRenderHints( painter->renderHints() );
 
 1397             p.translate( -br.topLeft() );
 
 1399             const QPointF pos( 0.0, 0.0 );
 
 1403         const int dx = br.left();
 
 1404         const int dy = br.top();
 
 1406         for ( 
int i = 0; i < numPoints; i++ )
 
 1408             const int left = qRound( points[i].x() ) + dx;
 
 1409             const int top = qRound( points[i].y() ) + dy;
 
 1411             painter->drawPixmap( left, top, m_data->cache.pixmap );
 
 1441         m_data->graphic.graphic.render(
 
 1442             painter, rect, Qt::KeepAspectRatio );
 
 1446         if ( m_data->path.graphic.isNull() )
 
 1448             m_data->path.graphic = qwtPathGraphic(
 
 1449                 m_data->path.path, m_data->pen, m_data->brush );
 
 1452         m_data->path.graphic.render(
 
 1453             painter, rect, Qt::KeepAspectRatio );
 
 1459         if ( m_data->svg.renderer )
 
 1463             QSizeF sz = m_data->svg.renderer->viewBoxF().size();
 
 1464             if ( !sz.isEmpty() )
 
 1466                 sz.scale( rect.size(), Qt::KeepAspectRatio );
 
 1467                 scaledRect.setSize( sz );
 
 1468                 scaledRect.moveCenter( rect.center() );
 
 1475             m_data->svg.renderer->render(
 
 1476                 painter, scaledRect );
 
 1486         const double ratio = qMin( rect.width() / br.width(),
 
 1487             rect.height() / br.height() );
 
 1491         painter->translate( rect.center() );
 
 1492         painter->scale( ratio, ratio );
 
 1495         m_data->isPinPointEnabled = 
false;
 
 1514     const QPointF* points, 
int numPoints )
 const 
 1516     switch ( m_data->style )
 
 1520             qwtDrawEllipseSymbols( painter, points, numPoints, *
this );
 
 1525             qwtDrawRectSymbols( painter, points, numPoints, *
this );
 
 1530             qwtDrawDiamondSymbols( painter, points, numPoints, *
this );
 
 1535             qwtDrawLineSymbols( painter, Qt::Horizontal | Qt::Vertical,
 
 1536                 points, numPoints, *
this );
 
 1541             qwtDrawXCrossSymbols( painter, points, numPoints, *
this );
 
 1547             qwtDrawTriangleSymbols( painter, QwtTriangle::Up,
 
 1548                 points, numPoints, *
this );
 
 1553             qwtDrawTriangleSymbols( painter, QwtTriangle::Down,
 
 1554                 points, numPoints, *
this );
 
 1559             qwtDrawTriangleSymbols( painter, QwtTriangle::Right,
 
 1560                 points, numPoints, *
this );
 
 1565             qwtDrawTriangleSymbols( painter, QwtTriangle::Left,
 
 1566                 points, numPoints, *
this );
 
 1571             qwtDrawLineSymbols( painter, Qt::Horizontal,
 
 1572                 points, numPoints, *
this );
 
 1577             qwtDrawLineSymbols( painter, Qt::Vertical,
 
 1578                 points, numPoints, *
this );
 
 1583             qwtDrawStar1Symbols( painter, points, numPoints, *
this );
 
 1588             qwtDrawStar2Symbols( painter, points, numPoints, *
this );
 
 1593             qwtDrawHexagonSymbols( painter, points, numPoints, *
this );
 
 1598             if ( m_data->path.graphic.isNull() )
 
 1600                 m_data->path.graphic = qwtPathGraphic( m_data->path.path,
 
 1601                     m_data->pen, m_data->brush );
 
 1604             qwtDrawGraphicSymbols( painter, points, numPoints,
 
 1605                 m_data->path.graphic, *
this );
 
 1610             qwtDrawPixmapSymbols( painter, points, numPoints, *
this );
 
 1615             qwtDrawGraphicSymbols( painter, points, numPoints,
 
 1616                 m_data->graphic.graphic, *
this );
 
 1622             qwtDrawSvgSymbols( painter, points, numPoints,
 
 1623                 m_data->svg.renderer, *
this );
 
 1641     bool pinPointTranslation = 
false;
 
 1643     switch ( m_data->style )
 
 1650             if ( m_data->pen.style() != Qt::NoPen )
 
 1653             rect.setSize( m_data->size + QSizeF( pw, pw ) );
 
 1654             rect.moveCenter( QPointF( 0.0, 0.0 ) );
 
 1669             if ( m_data->pen.style() != Qt::NoPen )
 
 1672             rect.setSize( m_data->size + QSizeF( 2 * pw, 2 * pw ) );
 
 1673             rect.moveCenter( QPointF( 0.0, 0.0 ) );
 
 1678             if ( m_data->path.graphic.isNull() )
 
 1680                 m_data->path.graphic = qwtPathGraphic(
 
 1681                     m_data->path.path, m_data->pen, m_data->brush );
 
 1684             rect = qwtScaledBoundingRect(
 
 1685                 m_data->path.graphic, m_data->size );
 
 1686             pinPointTranslation = 
true;
 
 1692             if ( m_data->size.isEmpty() )
 
 1693                 rect.setSize( m_data->pixmap.pixmap.size() );
 
 1695                 rect.setSize( m_data->size );
 
 1697             pinPointTranslation = 
true;
 
 1703             rect = qwtScaledBoundingRect(
 
 1704                 m_data->graphic.graphic, m_data->size );
 
 1705             pinPointTranslation = 
true;
 
 1712             if ( m_data->svg.renderer )
 
 1713                 rect = m_data->svg.renderer->viewBoxF();
 
 1715             if ( m_data->size.isValid() && !rect.isEmpty() )
 
 1717                 QSizeF sz = rect.size();
 
 1719                 const double sx = m_data->size.width() / sz.width();
 
 1720                 const double sy = m_data->size.height() / sz.height();
 
 1722                 QTransform transform;
 
 1723                 transform.scale( sx, sy );
 
 1725                 rect = transform.mapRect( rect );
 
 1727             pinPointTranslation = 
true;
 
 1733             rect.setSize( m_data->size );
 
 1734             rect.moveCenter( QPointF( 0.0, 0.0 ) );
 
 1738     if ( pinPointTranslation )
 
 1741         if ( m_data->isPinPointEnabled )
 
 1742             pinPoint = rect.center() - m_data->pinPoint;
 
 1748     r.setLeft( qwtFloor( rect.left() ) );
 
 1749     r.setTop( qwtFloor( rect.top() ) );
 
 1750     r.setRight( qwtCeil( rect.right() ) );
 
 1751     r.setBottom( qwtCeil( rect.bottom() ) );
 
 1754         r.adjust( -1, -1, 1, 1 ); 
 
 1772     if ( !m_data->cache.pixmap.isNull() )
 
 1773         m_data->cache.pixmap = QPixmap();
 
 1784     if ( m_data->style != 
style )
 
 1786         m_data->style = 
style;
 
 1797     return m_data->style;
 
A paint device for scalable graphics.
void setRenderHint(RenderHint, bool on=true)
QRectF controlPointRect() const
QSizeF defaultSize() const
Default size.
QRectF scaledBoundingRect(qreal sx, qreal sy) const
Calculate the target rectangle for scaling the graphic.
void render(QPainter *) const
Replay all recorded painter commands.
static void drawEllipse(QPainter *, const QRectF &)
Wrapper for QPainter::drawEllipse()
static void drawPolygon(QPainter *, const QPolygonF &)
Wrapper for QPainter::drawPolygon()
static qreal effectivePenWidth(const QPen &)
static void drawRect(QPainter *, qreal x, qreal y, qreal w, qreal h)
Wrapper for QPainter::drawRect()
static QPixmap backingStore(QWidget *, const QSize &)
static bool roundingAlignment()
static void drawPixmap(QPainter *, const QRectF &, const QPixmap &)
Wrapper for QPainter::drawPixmap()
static void drawLine(QPainter *, qreal x1, qreal y1, qreal x2, qreal y2)
Wrapper for QPainter::drawLine()
A class for drawing symbols.
const QPainterPath & path() const
virtual void setColor(const QColor &)
Set the color of the symbol.
const QBrush & brush() const
const QPixmap & pixmap() const
void setPen(const QColor &, qreal width=0.0, Qt::PenStyle=Qt::SolidLine)
void drawSymbol(QPainter *, const QRectF &) const
Draw the symbol into a rectangle.
void setCachePolicy(CachePolicy)
void setPinPointEnabled(bool)
virtual ~QwtSymbol()
Destructor.
virtual QRect boundingRect() const
void setSvgDocument(const QByteArray &)
void drawSymbols(QPainter *, const QPolygonF &) const
Draw symbols at the specified points.
@ Ellipse
Ellipse or circle.
@ LTriangle
Triangle pointing left.
@ Star1
X combined with +.
@ Triangle
Triangle pointing upwards.
@ XCross
Diagonal cross (X)
@ UTriangle
Triangle pointing upwards.
@ NoSymbol
No Style. The symbol cannot be drawn.
@ DTriangle
Triangle pointing downwards.
@ RTriangle
Triangle pointing right.
void setPath(const QPainterPath &)
Set a painter path as symbol.
void setPixmap(const QPixmap &)
QwtSymbol(Style=NoSymbol)
void setPinPoint(const QPointF &pos, bool enable=true)
Set and enable a pin point.
void setSize(const QSize &)
bool isPinPointEnabled() const
void setGraphic(const QwtGraphic &)
const QSize & size() const
virtual void renderSymbols(QPainter *, const QPointF *, int numPoints) const
@ Cache
Always use a pixmap cache.
CachePolicy cachePolicy() const
const QwtGraphic & graphic() const
void setBrush(const QBrush &)
Assign a brush.