QGIS API Documentation 3.38.0-Grenoble (exported)
Loading...
Searching...
No Matches
qgslayoutitempolyline.cpp
Go to the documentation of this file.
1/***************************************************************************
2 qgslayoutitempolyline.cpp
3 begin : March 2016
4 copyright : (C) 2016 Paul Blottiere, Oslandia
5 email : paul dot blottiere at oslandia dot com
6 ***************************************************************************/
7
8/***************************************************************************
9 * *
10 * This program is free software; you can redistribute it and/or modify *
11 * it under the terms of the GNU General Public License as published by *
12 * the Free Software Foundation; either version 2 of the License, or *
13 * (at your option) any later version. *
14 * *
15 ***************************************************************************/
16
19#include "qgssymbollayerutils.h"
20#include "qgscolorutils.h"
21#include "qgssymbol.h"
22#include "qgslayout.h"
24#include "qgslayoututils.h"
25#include "qgsreadwritecontext.h"
26#include "qgssvgcache.h"
28#include "qgslinesymbol.h"
29
30#include <QSvgRenderer>
31#include <limits>
32#include <QGraphicsPathItem>
33#include <QVector2D>
34
36 : QgsLayoutNodesItem( layout )
37{
38 createDefaultPolylineStyleSymbol();
39}
40
41QgsLayoutItemPolyline::QgsLayoutItemPolyline( const QPolygonF &polyline, QgsLayout *layout )
42 : QgsLayoutNodesItem( polyline, layout )
43{
44 createDefaultPolylineStyleSymbol();
45}
46
48
53
58
60{
61 return QgsApplication::getThemeIcon( QStringLiteral( "/mLayoutItemPolyline.svg" ) );
62}
63
64bool QgsLayoutItemPolyline::_addNode( const int indexPoint,
65 QPointF newPoint,
66 const double radius )
67{
68 const double distStart = computeDistance( newPoint, mPolygon[0] );
69 const double distEnd = computeDistance( newPoint, mPolygon[mPolygon.size() - 1] );
70
71 if ( indexPoint == ( mPolygon.size() - 1 ) )
72 {
73 if ( distEnd < radius )
74 mPolygon.append( newPoint );
75 else if ( distStart < radius )
76 mPolygon.insert( 0, newPoint );
77 }
78 else
79 mPolygon.insert( indexPoint + 1, newPoint );
80
81 return true;
82}
83
85{
86 if ( index < 0 || index >= mPolygon.size() )
87 return false;
88
89 mPolygon.remove( index );
90
91 if ( mPolygon.size() < 2 )
92 mPolygon.clear();
93 else
94 {
95 int newSelectNode = index;
96 if ( index >= mPolygon.size() )
97 newSelectNode = mPolygon.size() - 1;
98 setSelectedNode( newSelectNode );
99 }
100
101 return true;
102}
103
104void QgsLayoutItemPolyline::createDefaultPolylineStyleSymbol()
105{
106 QVariantMap properties;
107 properties.insert( QStringLiteral( "color" ), QStringLiteral( "0,0,0,255" ) );
108 properties.insert( QStringLiteral( "width" ), QStringLiteral( "0.3" ) );
109 properties.insert( QStringLiteral( "capstyle" ), QStringLiteral( "square" ) );
110
111 mPolylineStyleSymbol.reset( QgsLineSymbol::createSimple( properties ) );
112 refreshSymbol();
113}
114
115void QgsLayoutItemPolyline::refreshSymbol()
116{
117 if ( auto *lLayout = layout() )
118 {
119 const QgsRenderContext rc = QgsLayoutUtils::createRenderContextForLayout( lLayout, nullptr, lLayout->renderContext().dpi() );
120 mMaxSymbolBleed = ( 25.4 / lLayout->renderContext().dpi() ) * QgsSymbolLayerUtils::estimateMaxSymbolBleed( mPolylineStyleSymbol.get(), rc );
121 }
122
124
125 emit frameChanged();
126}
127
128void QgsLayoutItemPolyline::drawStartMarker( QPainter *painter )
129{
130 if ( mPolygon.size() < 2 )
131 return;
132
133 switch ( mStartMarker )
134 {
136 break;
137
139 {
140 // calculate angle at start of line
141 const QLineF startLine( mPolygon.at( 0 ), mPolygon.at( 1 ) );
142 const double angle = startLine.angle();
143 drawArrow( painter, mPolygon.at( 0 ), angle );
144 break;
145 }
146
148 {
149 // calculate angle at start of line
150 const QLineF startLine( mPolygon.at( 0 ), mPolygon.at( 1 ) );
151 const double angle = startLine.angle();
152 drawSvgMarker( painter, mPolygon.at( 0 ), angle, mStartMarkerFile, mStartArrowHeadHeight );
153 break;
154 }
155 }
156
157}
158
159void QgsLayoutItemPolyline::drawEndMarker( QPainter *painter )
160{
161 if ( mPolygon.size() < 2 )
162 return;
163
164 switch ( mEndMarker )
165 {
167 break;
168
170 {
171 // calculate angle at end of line
172 const QLineF endLine( mPolygon.at( mPolygon.count() - 2 ), mPolygon.at( mPolygon.count() - 1 ) );
173 const double angle = endLine.angle();
174
175 //move end point depending on arrow width
176 const QVector2D dir = QVector2D( endLine.dx(), endLine.dy() ).normalized();
177 QPointF endPoint = endLine.p2();
178 endPoint += ( dir * 0.5 * mArrowHeadWidth ).toPointF();
179
180 drawArrow( painter, endPoint, angle );
181 break;
182 }
184 {
185 // calculate angle at end of line
186 const QLineF endLine( mPolygon.at( mPolygon.count() - 2 ), mPolygon.at( mPolygon.count() - 1 ) );
187 const double angle = endLine.angle();
188 drawSvgMarker( painter, endLine.p2(), angle, mEndMarkerFile, mEndArrowHeadHeight );
189 break;
190 }
191 }
192}
193
194void QgsLayoutItemPolyline::drawArrow( QPainter *painter, QPointF center, double angle )
195{
196 // translate angle from ccw from axis to cw from north
197 angle = 90 - angle;
198 QPen p;
199 p.setColor( mArrowHeadStrokeColor );
200 p.setWidthF( mArrowHeadStrokeWidth );
201 painter->setPen( p );
202 QBrush b;
203 b.setColor( mArrowHeadFillColor );
204 painter->setBrush( b );
205
206 drawArrowHead( painter, center.x(), center.y(), angle, mArrowHeadWidth );
207}
208
209void QgsLayoutItemPolyline::updateMarkerSvgSizes()
210{
211 setStartSvgMarkerPath( mStartMarkerFile );
212 setEndSvgMarkerPath( mEndMarkerFile );
213}
214
215void QgsLayoutItemPolyline::drawArrowHead( QPainter *p, const double x, const double y, const double angle, const double arrowHeadWidth )
216{
217 if ( !p )
218 return;
219
220 const double angleRad = angle / 180.0 * M_PI;
221 const QPointF middlePoint( x, y );
222
223 //rotate both arrow points
224 const QPointF p1 = QPointF( -arrowHeadWidth / 2.0, arrowHeadWidth );
225 const QPointF p2 = QPointF( arrowHeadWidth / 2.0, arrowHeadWidth );
226
227 QPointF p1Rotated, p2Rotated;
228 p1Rotated.setX( p1.x() * std::cos( angleRad ) + p1.y() * -std::sin( angleRad ) );
229 p1Rotated.setY( p1.x() * std::sin( angleRad ) + p1.y() * std::cos( angleRad ) );
230 p2Rotated.setX( p2.x() * std::cos( angleRad ) + p2.y() * -std::sin( angleRad ) );
231 p2Rotated.setY( p2.x() * std::sin( angleRad ) + p2.y() * std::cos( angleRad ) );
232
233 QPolygonF arrowHeadPoly;
234 arrowHeadPoly << middlePoint;
235 arrowHeadPoly << QPointF( middlePoint.x() + p1Rotated.x(), middlePoint.y() + p1Rotated.y() );
236 arrowHeadPoly << QPointF( middlePoint.x() + p2Rotated.x(), middlePoint.y() + p2Rotated.y() );
237 QPen arrowPen = p->pen();
238 arrowPen.setJoinStyle( Qt::RoundJoin );
239 QBrush arrowBrush = p->brush();
240 arrowBrush.setStyle( Qt::SolidPattern );
241 p->setPen( arrowPen );
242 p->setBrush( arrowBrush );
243 arrowBrush.setStyle( Qt::SolidPattern );
244 p->drawPolygon( arrowHeadPoly );
245}
246
247void QgsLayoutItemPolyline::drawSvgMarker( QPainter *p, QPointF point, double angle, const QString &markerPath, double height ) const
248{
249 // translate angle from ccw from axis to cw from north
250 angle = 90 - angle;
251
252 if ( mArrowHeadWidth <= 0 || height <= 0 )
253 {
254 //bad image size
255 return;
256 }
257
258 if ( markerPath.isEmpty() )
259 return;
260
261 QSvgRenderer r;
262 const QByteArray &svgContent = QgsApplication::svgCache()->svgContent( markerPath, mArrowHeadWidth, mArrowHeadFillColor, mArrowHeadStrokeColor, mArrowHeadStrokeWidth,
263 1.0 );
264 r.load( svgContent );
265
266 const QgsScopedQPainterState painterState( p );
267 p->translate( point.x(), point.y() );
268 p->rotate( angle );
269 p->translate( -mArrowHeadWidth / 2.0, -height / 2.0 );
270 r.render( p, QRectF( 0, 0, mArrowHeadWidth, height ) );
271}
272
274{
275 if ( !id().isEmpty() )
276 return id();
277
278 return tr( "<Polyline>" );
279}
280
281void QgsLayoutItemPolyline::_draw( QgsLayoutItemRenderContext &context, const QStyleOptionGraphicsItem * )
282{
283 const QgsScopedQPainterState painterState( context.renderContext().painter() );
284 //setup painter scaling to dots so that raster symbology is drawn to scale
285 const double scale = context.renderContext().convertToPainterUnits( 1, Qgis::RenderUnit::Millimeters );
286 const QTransform t = QTransform::fromScale( scale, scale );
287
288 mPolylineStyleSymbol->startRender( context.renderContext() );
289 mPolylineStyleSymbol->renderPolyline( t.map( mPolygon ), nullptr, context.renderContext() );
290 mPolylineStyleSymbol->stopRender( context.renderContext() );
291
292 // painter is scaled to dots, so scale back to layout units
293 context.renderContext().painter()->scale( context.renderContext().scaleFactor(), context.renderContext().scaleFactor() );
294
295 drawStartMarker( context.renderContext().painter() );
296 drawEndMarker( context.renderContext().painter() );
297}
298
299void QgsLayoutItemPolyline::_readXmlStyle( const QDomElement &elmt, const QgsReadWriteContext &context )
300{
301 mPolylineStyleSymbol.reset( QgsSymbolLayerUtils::loadSymbol<QgsLineSymbol>( elmt, context ) );
302}
303
305{
306 mPolylineStyleSymbol.reset( static_cast<QgsLineSymbol *>( symbol->clone() ) );
307 refreshSymbol();
308}
309
311{
312 mStartMarker = mode;
313 update();
314}
315
317{
318 mEndMarker = mode;
319 update();
320}
321
323{
324 mArrowHeadWidth = width;
325 updateMarkerSvgSizes();
326 update();
327}
328
330{
331 QPainterPath path;
332 path.addPolygon( mPolygon );
333
334 QPainterPathStroker ps;
335
336 ps.setWidth( 2 * mMaxSymbolBleed );
337 const QPainterPath strokedOutline = ps.createStroke( path );
338
339 return strokedOutline;
340}
341
343{
344 return mPolylineStyleSymbol.get();
345}
346
348{
349 QSvgRenderer r;
350 mStartMarkerFile = path;
351 if ( path.isEmpty() || !r.load( path ) )
352 {
353 mStartArrowHeadHeight = 0;
354 }
355 else
356 {
357 //calculate mArrowHeadHeight from svg file and mArrowHeadWidth
358 const QRect viewBox = r.viewBox();
359 mStartArrowHeadHeight = mArrowHeadWidth / viewBox.width() * viewBox.height();
360 }
362}
363
365{
366 QSvgRenderer r;
367 mEndMarkerFile = path;
368 if ( path.isEmpty() || !r.load( path ) )
369 {
370 mEndArrowHeadHeight = 0;
371 }
372 else
373 {
374 //calculate mArrowHeadHeight from svg file and mArrowHeadWidth
375 const QRect viewBox = r.viewBox();
376 mEndArrowHeadHeight = mArrowHeadWidth / viewBox.width() * viewBox.height();
377 }
379}
380
382{
383 mArrowHeadStrokeColor = color;
384 update();
385}
386
388{
389 mArrowHeadFillColor = color;
390 update();
391}
392
394{
395 mArrowHeadStrokeWidth = width;
397 update();
398}
399
401{
402 if ( mPolylineStyleSymbol )
403 {
404 QgsStyleSymbolEntity entity( mPolylineStyleSymbol.get() );
405 if ( !visitor->visit( QgsStyleEntityVisitorInterface::StyleLeaf( &entity, uuid(), displayName() ) ) )
406 return false;
407 }
408
409 return true;
410}
411
412void QgsLayoutItemPolyline::_writeXmlStyle( QDomDocument &doc, QDomElement &elmt, const QgsReadWriteContext &context ) const
413{
414 const QDomElement pe = QgsSymbolLayerUtils::saveSymbol( QString(),
415 mPolylineStyleSymbol.get(),
416 doc,
417 context );
418 elmt.appendChild( pe );
419}
420
421bool QgsLayoutItemPolyline::writePropertiesToElement( QDomElement &elmt, QDomDocument &doc, const QgsReadWriteContext &context ) const
422{
424
425 // absolute paths to relative
426 const QString startMarkerPath = QgsSymbolLayerUtils::svgSymbolPathToName( mStartMarkerFile, context.pathResolver() );
427 const QString endMarkerPath = QgsSymbolLayerUtils::svgSymbolPathToName( mEndMarkerFile, context.pathResolver() );
428
429 elmt.setAttribute( QStringLiteral( "arrowHeadWidth" ), QString::number( mArrowHeadWidth ) );
430 elmt.setAttribute( QStringLiteral( "arrowHeadFillColor" ), QgsColorUtils::colorToString( mArrowHeadFillColor ) );
431 elmt.setAttribute( QStringLiteral( "arrowHeadOutlineColor" ), QgsColorUtils::colorToString( mArrowHeadStrokeColor ) );
432 elmt.setAttribute( QStringLiteral( "outlineWidth" ), QString::number( mArrowHeadStrokeWidth ) );
433 elmt.setAttribute( QStringLiteral( "markerMode" ), mEndMarker );
434 elmt.setAttribute( QStringLiteral( "startMarkerMode" ), mStartMarker );
435 elmt.setAttribute( QStringLiteral( "startMarkerFile" ), startMarkerPath );
436 elmt.setAttribute( QStringLiteral( "endMarkerFile" ), endMarkerPath );
437
438 return true;
439}
440
441bool QgsLayoutItemPolyline::readPropertiesFromElement( const QDomElement &elmt, const QDomDocument &doc, const QgsReadWriteContext &context )
442{
443 mArrowHeadWidth = elmt.attribute( QStringLiteral( "arrowHeadWidth" ), QStringLiteral( "2.0" ) ).toDouble();
444 mArrowHeadFillColor = QgsColorUtils::colorFromString( elmt.attribute( QStringLiteral( "arrowHeadFillColor" ), QStringLiteral( "0,0,0,255" ) ) );
445 mArrowHeadStrokeColor = QgsColorUtils::colorFromString( elmt.attribute( QStringLiteral( "arrowHeadOutlineColor" ), QStringLiteral( "0,0,0,255" ) ) );
446 mArrowHeadStrokeWidth = elmt.attribute( QStringLiteral( "outlineWidth" ), QStringLiteral( "1.0" ) ).toDouble();
447 // relative paths to absolute
448 const QString startMarkerPath = elmt.attribute( QStringLiteral( "startMarkerFile" ), QString() );
449 const QString endMarkerPath = elmt.attribute( QStringLiteral( "endMarkerFile" ), QString() );
452 mEndMarker = static_cast< QgsLayoutItemPolyline::MarkerMode >( elmt.attribute( QStringLiteral( "markerMode" ), QStringLiteral( "0" ) ).toInt() );
453 mStartMarker = static_cast< QgsLayoutItemPolyline::MarkerMode >( elmt.attribute( QStringLiteral( "startMarkerMode" ), QStringLiteral( "0" ) ).toInt() );
454
456
458 return true;
459}
460
462{
463 QRectF br = rect();
464
465 double margin = std::max( mMaxSymbolBleed, computeMarkerMargin() );
466 if ( mEndMarker == ArrowHead )
467 {
468 margin += 0.5 * mArrowHeadWidth;
469 }
470 br.adjust( -margin, -margin, margin, margin );
471 prepareGeometryChange();
473
474 // update
475 update();
476}
477
478
479double QgsLayoutItemPolyline::computeMarkerMargin() const
480{
481 double margin = 0;
482
483 if ( mStartMarker == ArrowHead || mEndMarker == ArrowHead )
484 {
485 margin = mArrowHeadStrokeWidth / 2.0 + mArrowHeadWidth * M_SQRT2;
486 }
487
488 if ( mStartMarker == SvgMarker )
489 {
490 const double startMarkerMargin = std::sqrt( 0.25 * ( mStartArrowHeadHeight * mStartArrowHeadHeight + mArrowHeadWidth * mArrowHeadWidth ) );
491 margin = std::max( startMarkerMargin, margin );
492 }
493
494 if ( mEndMarker == SvgMarker )
495 {
496 const double endMarkerMargin = std::sqrt( 0.25 * ( mEndArrowHeadHeight * mEndArrowHeadHeight + mArrowHeadWidth * mArrowHeadWidth ) );
497 margin = std::max( endMarkerMargin, margin );
498 }
499
500 return margin;
501}
@ Millimeters
Millimeters.
static QIcon getThemeIcon(const QString &name, const QColor &fillColor=QColor(), const QColor &strokeColor=QColor())
Helper to get a theme icon.
static QgsSvgCache * svgCache()
Returns the application's SVG cache, used for caching SVG images and handling parameter replacement w...
static QColor colorFromString(const QString &string)
Decodes a string into a color value.
static QString colorToString(const QColor &color)
Encodes a color into a string value.
Layout item for node based polyline shapes.
void setArrowHeadWidth(double width)
Sets the width of line arrow heads in mm.
void setEndMarker(MarkerMode mode)
Sets the end marker mode, which controls what marker is drawn at the end of the line.
void setEndSvgMarkerPath(const QString &path)
Sets the path to a SVG marker to draw at the end of the line.
void _writeXmlStyle(QDomDocument &doc, QDomElement &elmt, const QgsReadWriteContext &context) const override
Method called in writeXml.
void setArrowHeadStrokeWidth(double width)
Sets the pen width in millimeters for the stroke of the arrow head.
void _readXmlStyle(const QDomElement &elmt, const QgsReadWriteContext &context) override
Method called in readXml.
void setArrowHeadFillColor(const QColor &color)
Sets the color used to fill the arrow head.
bool _removeNode(int nodeIndex) override
Method called in removeNode.
QgsLineSymbol * symbol()
Returns the line symbol used to draw the shape.
void setArrowHeadStrokeColor(const QColor &color)
Sets the color used to draw the stroke around the arrow head.
void setStartMarker(MarkerMode mode)
Sets the start marker mode, which controls what marker is drawn at the start of the line.
MarkerMode
Vertex marker mode.
@ ArrowHead
Show arrow marker.
@ NoMarker
Don't show marker.
QPainterPath shape() const override
~QgsLayoutItemPolyline() override
bool accept(QgsStyleEntityVisitorInterface *visitor) const override
Accepts the specified style entity visitor, causing it to visit all style entities associated with th...
bool readPropertiesFromElement(const QDomElement &element, const QDomDocument &document, const QgsReadWriteContext &context) override
Sets item state from a DOM element.
QString displayName() const override
Gets item display name.
static QgsLayoutItemPolyline * create(QgsLayout *layout)
Returns a new polyline item for the specified layout.
bool _addNode(int indexPoint, QPointF newPoint, double radius) override
Method called in addNode.
void setSymbol(QgsLineSymbol *symbol)
Sets the symbol used to draw the shape.
QIcon icon() const override
Returns the item's icon.
double arrowHeadWidth() const
Returns the width of line arrow heads in mm.
bool writePropertiesToElement(QDomElement &element, QDomDocument &document, const QgsReadWriteContext &context) const override
Stores item state within an XML DOM element.
void _draw(QgsLayoutItemRenderContext &context, const QStyleOptionGraphicsItem *itemStyle=nullptr) override
Method called in paint.
void setStartSvgMarkerPath(const QString &path)
Sets the path to a SVG marker to draw at the start of the line.
QgsLayoutItemPolyline(QgsLayout *layout)
Constructor for QgsLayoutItemPolyline for the specified layout.
@ LayoutPolyline
Polyline shape item.
Contains settings and helpers relating to a render of a QgsLayoutItem.
QgsRenderContext & renderContext()
Returns a reference to the context's render context.
virtual QString uuid() const
Returns the item identification string.
QString id() const
Returns the item's ID name.
void frameChanged()
Emitted if the item's frame style changes.
An abstract layout item that provides generic methods for node based shapes such as polygon or polyli...
double mMaxSymbolBleed
Max symbol bleed.
QRectF mCurrentRectangle
Current bounding rectangle of shape.
bool readPropertiesFromElement(const QDomElement &element, const QDomDocument &document, const QgsReadWriteContext &context) override
Sets item state from a DOM element.
bool setSelectedNode(int index)
Selects a node by index.
bool writePropertiesToElement(QDomElement &element, QDomDocument &document, const QgsReadWriteContext &context) const override
Stores item state within an XML DOM element.
void updateSceneRect()
Update the current scene rectangle for this item.
double computeDistance(QPointF pt1, QPointF pt2) const
Compute an euclidean distance between 2 nodes.
QPolygonF mPolygon
Shape's nodes.
const QgsLayout * layout() const
Returns the layout the object is attached to.
static QgsRenderContext createRenderContextForLayout(QgsLayout *layout, QPainter *painter, double dpi=-1)
Creates a render context suitable for the specified layout and painter destination.
Base class for layouts, which can contain items such as maps, labels, scalebars, etc.
Definition qgslayout.h:49
A line symbol type, for rendering LineString and MultiLineString geometries.
QgsLineSymbol * clone() const override
Returns a deep copy of this symbol.
static QgsLineSymbol * createSimple(const QVariantMap &properties)
Create a line symbol with one symbol layer: SimpleLine with specified properties.
The class is used as a container of context for various read/write operations on other objects.
const QgsPathResolver & pathResolver() const
Returns path resolver for conversion between relative and absolute paths.
Contains information about the context of a rendering operation.
double scaleFactor() const
Returns the scaling factor for the render to convert painter units to physical sizes.
double convertToPainterUnits(double size, Qgis::RenderUnit unit, const QgsMapUnitScale &scale=QgsMapUnitScale(), Qgis::RenderSubcomponentProperty property=Qgis::RenderSubcomponentProperty::Generic) const
Converts a size from the specified units to painter units (pixels).
QPainter * painter()
Returns the destination QPainter for the render operation.
Scoped object for saving and restoring a QPainter object's state.
An interface for classes which can visit style entity (e.g.
virtual bool visit(const QgsStyleEntityVisitorInterface::StyleLeaf &entity)
Called when the visitor will visit a style entity.
A symbol entity for QgsStyle databases.
Definition qgsstyle.h:1372
QByteArray svgContent(const QString &path, double size, const QColor &fill, const QColor &stroke, double strokeWidth, double widthScaleFactor, double fixedAspectRatio=0, bool blocking=false, const QMap< QString, QString > &parameters=QMap< QString, QString >(), bool *isMissingImage=nullptr)
Gets the SVG content corresponding to the given path.
static QString svgSymbolPathToName(const QString &path, const QgsPathResolver &pathResolver)
Determines an SVG symbol's name from its path.
static QString svgSymbolNameToPath(const QString &name, const QgsPathResolver &pathResolver)
Determines an SVG symbol's path from its name.
static QDomElement saveSymbol(const QString &symbolName, const QgsSymbol *symbol, QDomDocument &doc, const QgsReadWriteContext &context)
Writes a symbol definition to XML.
static double estimateMaxSymbolBleed(QgsSymbol *symbol, const QgsRenderContext &context)
Returns the maximum estimated bleed for the symbol.
double ANALYSIS_EXPORT angle(QgsPoint *p1, QgsPoint *p2, QgsPoint *p3, QgsPoint *p4)
Calculates the angle between two segments (in 2 dimension, z-values are ignored)
Contains information relating to the style entity currently being visited.