58 void QgsCompositionConverter::initPropertyDefinitions()
60 if ( !sPropertyDefinitions.isEmpty() )
68 "<b>B5</b>|<b>B4</b>|<b>B3</b>|<b>B2</b>|<b>B1</b>|<b>B0</b>" 69 "<b>Legal</b>|<b>Ansi A</b>|<b>Ansi B</b>|<b>Ansi C</b>|<b>Ansi D</b>|<b>Ansi E</b>" 70 "<b>Arch A</b>|<b>Arch B</b>|<b>Arch C</b>|<b>Arch D</b>|<b>Arch E</b>|<b>Arch E1</b>]" 114 QgsCompositionConverter::initPropertyDefinitions();
115 return sPropertyDefinitions;
121 initPropertyDefinitions();
123 QDomElement parentElement = composerElement.parentNode().toElement();
125 std::unique_ptr< QgsPrintLayout > layout = qgis::make_unique< QgsPrintLayout >( project );
126 layout->undoStack()->blockCommands(
true );
129 layout->guides().setVisible( composerElement.attribute( QStringLiteral(
"guidesVisible" ), QStringLiteral(
"1" ) ).toInt() != 0 );
131 int printResolution = composerElement.attribute(
"printResolution",
"300" ).toInt();
132 layout->renderContext().setDpi( printResolution );
135 int pages = composerElement.attribute( QStringLiteral(
"numPages" ) ).toInt( );
136 float paperHeight = composerElement.attribute( QStringLiteral(
"paperHeight" ) ).toDouble( );
137 float paperWidth = composerElement.attribute( QStringLiteral(
"paperWidth" ) ).toDouble( );
139 if ( composerElement.elementsByTagName( QStringLiteral(
"symbol" ) ).size() )
141 QDomElement symbolElement = composerElement.elementsByTagName( QStringLiteral(
"symbol" ) ).at( 0 ).toElement();
145 std::unique_ptr< QgsFillSymbol > symbol( QgsSymbolLayerUtils::loadSymbol<QgsFillSymbol>( symbolElement, context ) );
147 layout->pageCollection()->setPageStyleSymbol( symbol.get() );
150 QString name = composerElement.attribute( QStringLiteral(
"name" ) );
152 if ( name.isEmpty() )
153 name = composerElement.attribute( QStringLiteral(
"title" ) );
155 if ( name.isEmpty() )
156 name = parentElement.attribute( QStringLiteral(
"title" ) );
157 layout->setName( name );
159 for (
int j = 0; j < pages; j++ )
163 layout->pageCollection()->addPage( page );
165 QDomNodeList snapLineNodes = composerElement.elementsByTagName( QStringLiteral(
"SnapLine" ) );
166 for (
int i = 0; i < snapLineNodes.size(); ++i )
168 QDomElement snapLineElem = snapLineNodes.at( i ).toElement();
169 double x1 = snapLineElem.attribute( QStringLiteral(
"x1" ) ).toDouble();
170 double y1 = snapLineElem.attribute( QStringLiteral(
"y1" ) ).toDouble();
171 double x2 = snapLineElem.attribute( QStringLiteral(
"x2" ) ).toDouble();
173 Qt::Orientation orientation( x1 == x2 ? Qt::Orientation::Vertical : Qt::Orientation::Horizontal );
175 std::unique_ptr< QgsLayoutGuide > guide = qgis::make_unique< QgsLayoutGuide >( orientation, position, page );
176 layout->guides().addGuide( guide.release() );
182 if ( parentElement.elementsByTagName( QStringLiteral(
"Atlas" ) ).size() )
184 QDomElement atlasElement = parentElement.elementsByTagName( QStringLiteral(
"Atlas" ) ).at( 0 ).toElement();
185 readAtlasXml( layout->atlas(), atlasElement, layout->project() );
188 layout->undoStack()->blockCommands(
false );
193 void QgsCompositionConverter::adjustPos(
QgsPrintLayout *layout,
QgsLayoutItem *layoutItem, QPointF *position,
bool &pasteInPlace,
int zOrderOffset, QPointF &pasteShiftPos,
int &pageNumber )
203 layoutItem->
attemptMoveBy( pasteShiftPos.x(), pasteShiftPos.y() );
208 layoutItem->setZValue( layoutItem->zValue() + zOrderOffset );
211 void QgsCompositionConverter::restoreGeneralComposeItemProperties(
QgsLayoutItem *layoutItem,
const QDomElement &itemElem )
214 QDomNodeList composerItemList = itemElem.elementsByTagName( QStringLiteral(
"ComposerItem" ) );
215 if ( !composerItemList.isEmpty() )
217 QDomElement composerItemElem = composerItemList.at( 0 ).toElement();
220 if ( !
qgsDoubleNear( composerItemElem.attribute( QStringLiteral(
"rotation" ), QStringLiteral(
"0" ) ).toDouble(), 0.0 ) )
223 layoutItem->
setItemRotation( composerItemElem.attribute( QStringLiteral(
"rotation" ), QStringLiteral(
"0" ) ).toDouble(), false );
225 QgsCompositionConverter::readXml( layoutItem, composerItemElem );
229 QRectF QgsCompositionConverter::itemPosition(
QgsLayoutItem *layoutItem,
const QDomElement &itemElem )
232 double x, y, pagex, pagey, width, height;
233 bool xOk, yOk, pageOk, pagexOk, pageyOk, widthOk, heightOk, positionModeOk;
235 x = itemElem.attribute( QStringLiteral(
"x" ) ).toDouble( &xOk );
236 y = itemElem.attribute( QStringLiteral(
"y" ) ).toDouble( &yOk );
237 page = itemElem.attribute( QStringLiteral(
"page" ) ).toInt( &pageOk );
238 pagex = itemElem.attribute( QStringLiteral(
"pagex" ) ).toDouble( &pagexOk );
239 pagey = itemElem.attribute( QStringLiteral(
"pagey" ) ).toDouble( &pageyOk );
240 width = itemElem.attribute( QStringLiteral(
"width" ) ).toDouble( &widthOk );
241 height = itemElem.attribute( QStringLiteral(
"height" ) ).toDouble( &heightOk );
244 layoutItem->mReferencePoint =
static_cast< QgsLayoutItem::ReferencePoint >( itemElem.attribute( QStringLiteral(
"positionMode" ) ).toInt( &positionModeOk ) );
245 if ( !positionModeOk )
250 if ( pageOk && pagexOk && pageyOk )
256 if ( page <= layoutItem->layout()->pageCollection()->pageCount() )
269 return QRectF( x, y, width, height );
272 QPointF QgsCompositionConverter::minPointFromXml(
const QDomElement &elem )
274 double minX = std::numeric_limits<double>::max();
275 double minY = std::numeric_limits<double>::max();
276 QDomNodeList composerItemList = elem.elementsByTagName( QStringLiteral(
"ComposerItem" ) );
277 for (
int i = 0; i < composerItemList.size(); ++i )
279 QDomElement currentComposerItemElem = composerItemList.at( i ).toElement();
282 x = currentComposerItemElem.attribute( QStringLiteral(
"x" ) ).toDouble( &xOk );
283 y = currentComposerItemElem.attribute( QStringLiteral(
"y" ) ).toDouble( &yOk );
288 minX = std::min( minX, x );
289 minY = std::min( minY, y );
291 if ( minX < std::numeric_limits<double>::max() )
293 return QPointF( minX, minY );
297 return QPointF( 0, 0 );
304 initPropertyDefinitions();
306 QList< QgsLayoutObject * > newItems;
311 int zOrderOffset = layout->mItemsModel->zOrderListSize();
313 QPointF pasteShiftPos;
320 QPointF minItemPos = minPointFromXml( parentElement );
323 pasteShiftPos = *position - minItemPos;
326 pageNumber = layout->mPageCollection->pageNumberForPoint( *position );
333 for (
int i = 0; i < parentElement.elementsByTagName( QStringLiteral(
"ComposerMap" ) ).size(); i++ )
335 QDomNode itemNode( parentElement.elementsByTagName( QStringLiteral(
"ComposerMap" ) ).at( i ) );
337 readMapXml( layoutItem, itemNode.toElement(), layout->
project(), mapIdUiidMap );
338 adjustPos( layout, layoutItem, position, pasteInPlace, zOrderOffset, pasteShiftPos, pageNumber );
339 newItems << layoutItem ;
343 for (
int i = 0; i < parentElement.elementsByTagName( QStringLiteral(
"ComposerLabel" ) ).size(); i++ )
345 QDomNode itemNode( parentElement.elementsByTagName( QStringLiteral(
"ComposerLabel" ) ).at( i ) );
347 readLabelXml( layoutItem, itemNode.toElement(), layout->
project() );
348 adjustPos( layout, layoutItem, position, pasteInPlace, zOrderOffset, pasteShiftPos, pageNumber );
349 newItems << layoutItem ;
353 for (
int i = 0; i < parentElement.elementsByTagName( QStringLiteral(
"ComposerShape" ) ).size(); i++ )
355 QDomNode itemNode( parentElement.elementsByTagName( QStringLiteral(
"ComposerShape" ) ).at( i ) );
357 readShapeXml( layoutItem, itemNode.toElement(), layout->
project() );
358 adjustPos( layout, layoutItem, position, pasteInPlace, zOrderOffset, pasteShiftPos, pageNumber );
359 newItems << layoutItem ;
363 for (
int i = 0; i < parentElement.elementsByTagName( QStringLiteral(
"ComposerPicture" ) ).size(); i++ )
365 QDomNode itemNode( parentElement.elementsByTagName( QStringLiteral(
"ComposerPicture" ) ).at( i ) );
367 readPictureXml( layoutItem, itemNode.toElement(), layout->
project(), mapIdUiidMap );
368 adjustPos( layout, layoutItem, position, pasteInPlace, zOrderOffset, pasteShiftPos, pageNumber );
369 newItems << layoutItem ;
373 for (
int i = 0; i < parentElement.elementsByTagName( QStringLiteral(
"ComposerPolygon" ) ).size(); i++ )
375 QDomNode itemNode( parentElement.elementsByTagName( QStringLiteral(
"ComposerPolygon" ) ).at( i ) );
377 readPolyXml<QgsLayoutItemPolygon, QgsFillSymbol>( layoutItem, itemNode.toElement(), layout->
project() );
378 adjustPos( layout, layoutItem, position, pasteInPlace, zOrderOffset, pasteShiftPos, pageNumber );
379 newItems << layoutItem ;
383 for (
int i = 0; i < parentElement.elementsByTagName( QStringLiteral(
"ComposerPolyline" ) ).size(); i++ )
385 QDomNode itemNode( parentElement.elementsByTagName( QStringLiteral(
"ComposerPolyline" ) ).at( i ) );
387 readPolyXml<QgsLayoutItemPolyline, QgsLineSymbol>( layoutItem, itemNode.toElement(), layout->
project() );
388 adjustPos( layout, layoutItem, position, pasteInPlace, zOrderOffset, pasteShiftPos, pageNumber );
389 newItems << layoutItem ;
393 for (
int i = 0; i < parentElement.elementsByTagName( QStringLiteral(
"ComposerArrow" ) ).size(); i++ )
395 QDomNode itemNode( parentElement.elementsByTagName( QStringLiteral(
"ComposerArrow" ) ).at( i ) );
397 readArrowXml( layoutItem, itemNode.toElement(), layout->
project() );
398 adjustPos( layout, layoutItem, position, pasteInPlace, zOrderOffset, pasteShiftPos, pageNumber );
399 newItems << layoutItem ;
403 for (
int i = 0; i < parentElement.elementsByTagName( QStringLiteral(
"ComposerScaleBar" ) ).size(); i++ )
405 QDomNode itemNode( parentElement.elementsByTagName( QStringLiteral(
"ComposerScaleBar" ) ).at( i ) );
407 readScaleBarXml( layoutItem, itemNode.toElement(), layout->
project(), mapIdUiidMap );
408 adjustPos( layout, layoutItem, position, pasteInPlace, zOrderOffset, pasteShiftPos, pageNumber );
409 newItems << layoutItem ;
413 for (
int i = 0; i < parentElement.elementsByTagName( QStringLiteral(
"ComposerLegend" ) ).size(); i++ )
415 QDomNode itemNode( parentElement.elementsByTagName( QStringLiteral(
"ComposerLegend" ) ).at( i ) );
417 readLegendXml( layoutItem, itemNode.toElement(), layout->
project(), mapIdUiidMap );
418 adjustPos( layout, layoutItem, position, pasteInPlace, zOrderOffset, pasteShiftPos, pageNumber );
419 newItems << layoutItem ;
423 for (
int i = 0; i < parentElement.elementsByTagName( QStringLiteral(
"ComposerHtml" ) ).size(); i++ )
425 QDomNode itemNode( parentElement.elementsByTagName( QStringLiteral(
"ComposerHtml" ) ).at( i ) );
427 readHtmlXml( layoutItem, itemNode.toElement(), layout->
project() );
429 const QList<QgsLayoutFrame *> framesList( layoutItem->frames() );
430 for (
const auto &frame : framesList )
432 adjustPos( layout, frame, position, pasteInPlace, zOrderOffset, pasteShiftPos, pageNumber );
434 newItems << layoutItem ;
438 for (
int i = 0; i < parentElement.elementsByTagName( QStringLiteral(
"ComposerAttributeTableV2" ) ).size(); i++ )
440 QDomNode itemNode( parentElement.elementsByTagName( QStringLiteral(
"ComposerAttributeTableV2" ) ).at( i ) );
442 readTableXml( layoutItem, itemNode.toElement(), layout->
project() );
444 const QList<QgsLayoutFrame *> framesList( layoutItem->frames() );
445 for (
const auto &frame : framesList )
447 adjustPos( layout, frame, position, pasteInPlace, zOrderOffset, pasteShiftPos, pageNumber );
449 newItems << layoutItem ;
457 return document.elementsByTagName( QStringLiteral(
"Composition" ) ).count() > 0;
466 if ( document.elementsByTagName( QStringLiteral(
"Composition" ) ).count( ) > 0 )
468 QDomElement composerElem = document.elementsByTagName( QStringLiteral(
"Composition" ) ).at( 0 ).toElement( );
472 QDomElement elem = layout->writeXml( doc, context );
473 doc.appendChild( elem );
481 if ( itemElem.isNull() )
486 restoreGeneralComposeItemProperties( layoutItem, itemElem );
489 layoutItem->
setText( itemElem.attribute( QStringLiteral(
"labelText" ) ) );
492 layoutItem->
setMode( itemElem.attribute( QStringLiteral(
"htmlState" ) ).toInt() == Qt::Checked ? QgsLayoutItemLabel::Mode::ModeHtml : QgsLayoutItemLabel::Mode::ModeFont );
495 bool marginXOk =
false;
496 bool marginYOk =
false;
497 double marginX = itemElem.attribute( QStringLiteral(
"marginX" ) ).toDouble( &marginXOk );
498 double marginY = itemElem.attribute( QStringLiteral(
"marginY" ) ).toDouble( &marginYOk );
499 if ( !marginXOk || !marginYOk )
502 double margin = itemElem.attribute( QStringLiteral(
"margin" ), QStringLiteral(
"1.0" ) ).toDouble();
510 layoutItem->
setHAlign( static_cast< Qt::AlignmentFlag >( itemElem.attribute( QStringLiteral(
"halign" ) ).toInt() ) );
513 layoutItem->
setVAlign( static_cast< Qt::AlignmentFlag >( itemElem.attribute( QStringLiteral(
"valign" ) ).toInt() ) );
522 QDomNodeList fontColorList = itemElem.elementsByTagName( QStringLiteral(
"FontColor" ) );
523 if ( !fontColorList.isEmpty() )
525 QDomElement fontColorElem = fontColorList.at( 0 ).toElement();
526 int red = fontColorElem.attribute( QStringLiteral(
"red" ), QStringLiteral(
"0" ) ).toInt();
527 int green = fontColorElem.attribute( QStringLiteral(
"green" ), QStringLiteral(
"0" ) ).toInt();
528 int blue = fontColorElem.attribute( QStringLiteral(
"blue" ), QStringLiteral(
"0" ) ).toInt();
542 layoutItem->
setShapeType( static_cast<QgsLayoutItemShape::Shape>( itemElem.attribute( QStringLiteral(
"shapeType" ), QStringLiteral(
"0" ) ).toInt() ) );
545 restoreGeneralComposeItemProperties( layoutItem, itemElem );
551 if ( itemElem.elementsByTagName( QStringLiteral(
"symbol" ) ).size() )
553 QDomElement symbolElement = itemElem.elementsByTagName( QStringLiteral(
"symbol" ) ).at( 0 ).toElement();
554 QgsFillSymbol *shapeStyleSymbol = QgsSymbolLayerUtils::loadSymbol<QgsFillSymbol>( symbolElement, context );
555 if ( shapeStyleSymbol )
556 layoutItem->
setSymbol( shapeStyleSymbol );
565 properties.insert( QStringLiteral(
"style" ), QStringLiteral(
"solid" ) );
569 properties.insert( QStringLiteral(
"style" ), QStringLiteral(
"no" ) );
573 properties.insert( QStringLiteral(
"style_border" ), QStringLiteral(
"solid" ) );
577 properties.insert( QStringLiteral(
"style_border" ), QStringLiteral(
"no" ) );
580 properties.insert( QStringLiteral(
"width_border" ), QString::number( layoutItem->pen().widthF() ) );
583 QDomNodeList outlineColorList = itemElem.elementsByTagName( QStringLiteral(
"OutlineColor" ) );
584 if ( !outlineColorList.isEmpty() )
586 QDomElement frameColorElem = outlineColorList.at( 0 ).toElement();
587 bool redOk, greenOk, blueOk, alphaOk, widthOk;
588 int penRed, penGreen, penBlue, penAlpha;
591 penWidth = itemElem.attribute( QStringLiteral(
"outlineWidth" ) ).toDouble( &widthOk );
592 penRed = frameColorElem.attribute( QStringLiteral(
"red" ) ).toInt( &redOk );
593 penGreen = frameColorElem.attribute( QStringLiteral(
"green" ) ).toInt( &greenOk );
594 penBlue = frameColorElem.attribute( QStringLiteral(
"blue" ) ).toInt( &blueOk );
595 penAlpha = frameColorElem.attribute( QStringLiteral(
"alpha" ) ).toInt( &alphaOk );
597 if ( redOk && greenOk && blueOk && alphaOk && widthOk )
600 properties.insert( QStringLiteral(
"width_border" ), QString::number( penWidth ) );
603 QDomNodeList fillColorList = itemElem.elementsByTagName( QStringLiteral(
"FillColor" ) );
604 if ( !fillColorList.isEmpty() )
606 QDomElement fillColorElem = fillColorList.at( 0 ).toElement();
607 bool redOk, greenOk, blueOk, alphaOk;
608 int fillRed, fillGreen, fillBlue, fillAlpha;
610 fillRed = fillColorElem.attribute( QStringLiteral(
"red" ) ).toInt( &redOk );
611 fillGreen = fillColorElem.attribute( QStringLiteral(
"green" ) ).toInt( &greenOk );
612 fillBlue = fillColorElem.attribute( QStringLiteral(
"blue" ) ).toInt( &blueOk );
613 fillAlpha = fillColorElem.attribute( QStringLiteral(
"alpha" ) ).toInt( &alphaOk );
615 if ( redOk && greenOk && blueOk && alphaOk )
618 properties.insert( QStringLiteral(
"style" ), QStringLiteral(
"solid" ) );
621 if ( itemElem.hasAttribute( QStringLiteral(
"transparentFill" ) ) )
624 bool hasOldTransparentFill = itemElem.attribute( QStringLiteral(
"transparentFill" ), QStringLiteral(
"0" ) ).toInt();
625 if ( hasOldTransparentFill )
627 properties.insert( QStringLiteral(
"style" ), QStringLiteral(
"no" ) );
642 restoreGeneralComposeItemProperties( layoutItem, itemElem );
646 bool positionModeOk =
false;
647 layoutItem->mReferencePoint =
static_cast< QgsLayoutItem::ReferencePoint >( itemElem.attribute( QStringLiteral(
"positionMode" ) ).toInt( &positionModeOk ) );
648 if ( !positionModeOk )
650 layoutItem->mReferencePoint = QgsLayoutItem::ReferencePoint::UpperLeft;
652 bool anchorPointOk =
false;
654 layoutItem->
setPictureAnchor( static_cast< QgsLayoutItem::ReferencePoint >( itemElem.attribute( QStringLiteral(
"anchorPoint" ), QString::number( QgsLayoutItem::ReferencePoint::Middle ) ).toInt( &anchorPointOk ) ) );
655 if ( !anchorPointOk )
657 layoutItem->mPictureAnchor = QgsLayoutItem::ReferencePoint::UpperLeft;
661 layoutItem->mSvgStrokeWidth = itemElem.attribute( QStringLiteral(
"svgBorderWidth" ), QStringLiteral(
"0.2" ) ).toDouble();
663 QString imagePath = itemElem.attribute( QStringLiteral(
"file" ) );
668 if ( imagePath.endsWith( QLatin1String(
".svg" ), Qt::CaseInsensitive ) )
671 imagePath = pathResolver.
readPath( imagePath );
674 layoutItem->mPictureHeight = itemElem.attribute( QStringLiteral(
"pictureHeight" ), QStringLiteral(
"10" ) ).toDouble();
675 layoutItem->mPictureWidth = itemElem.attribute( QStringLiteral(
"pictureWidth" ), QStringLiteral(
"10" ) ).toDouble();
678 if ( !
qgsDoubleNear( itemElem.attribute( QStringLiteral(
"pictureRotation" ), QStringLiteral(
"0" ) ).toDouble(), 0.0 ) )
680 layoutItem->mPictureRotation = itemElem.attribute( QStringLiteral(
"pictureRotation" ), QStringLiteral(
"0" ) ).toDouble();
684 layoutItem->mNorthMode =
static_cast< QgsLayoutItemPicture::NorthMode >( itemElem.attribute( QStringLiteral(
"northMode" ), QStringLiteral(
"0" ) ).toInt() );
685 layoutItem->mNorthOffset = itemElem.attribute( QStringLiteral(
"northOffset" ), QStringLiteral(
"0" ) ).toDouble();
687 QString rotationMapId = itemElem.attribute( QStringLiteral(
"mapId" ), QStringLiteral(
"-1" ) );
688 if ( rotationMapId != QStringLiteral(
"-1" ) )
702 readPolyXml<QgsLayoutItemPolyline, QgsLineSymbol>( layoutItem, itemElem, project );
704 QDomNodeList startPointList = itemElem.elementsByTagName( QStringLiteral(
"StartPoint" ) );
705 if ( ! startPointList.isEmpty() )
707 QDomElement node = startPointList.at( 0 ).toElement();
708 polygon.append( QPointF( node.attribute( QStringLiteral(
"x" ) ).toDouble( ), node.attribute( QStringLiteral(
"y" ) ).toDouble() ) );
710 QDomNodeList stopPointList = itemElem.elementsByTagName( QStringLiteral(
"StopPoint" ) );
711 if ( ! stopPointList.isEmpty() )
713 QDomElement node = stopPointList.at( 0 ).toElement();
714 polygon.append( QPointF( node.attribute( QStringLiteral(
"x" ) ).toDouble( ), node.attribute( QStringLiteral(
"y" ) ).toDouble() ) );
719 if ( markerMode == QgsCompositionConverter::MarkerMode::DefaultMarker )
721 layoutItem->setEndMarker( QgsLayoutItemPolyline::MarkerMode::ArrowHead );
722 layoutItem->setStartMarker( QgsLayoutItemPolyline::MarkerMode::NoMarker );
725 layoutItem->setArrowHeadStrokeWidth( itemElem.attribute( QStringLiteral(
"outlineWidth" ), QStringLiteral(
"1.0" ) ).toDouble( ) );
726 layoutItem->setArrowHeadWidth( itemElem.attribute( QStringLiteral(
"arrowHeadWidth" ), QStringLiteral(
"1.0" ) ).toDouble( ) );
728 else if ( markerMode == QgsCompositionConverter::MarkerMode::SVGMarker )
730 QString endMarkerFile = itemElem.attribute( QStringLiteral(
"endMarkerFile" ) );
731 QString startMarkerFile = itemElem.attribute( QStringLiteral(
"endMarkerFile" ) );
738 if ( !endMarkerFile.isEmpty() )
740 if ( endMarkerFile.endsWith( QLatin1String(
".svg" ), Qt::CaseInsensitive ) )
743 endMarkerFile = pathResolver.
readPath( endMarkerFile );
745 if ( !startMarkerFile.isEmpty() )
747 if ( startMarkerFile.endsWith( QLatin1String(
".svg" ), Qt::CaseInsensitive ) )
750 startMarkerFile = pathResolver.
readPath( startMarkerFile );
753 if ( !endMarkerFile.isEmpty() )
755 layoutItem->setEndMarker( QgsLayoutItemPolyline::MarkerMode::SvgMarker );
756 layoutItem->setEndSvgMarkerPath( endMarkerFile );
758 if ( !startMarkerFile.isEmpty() )
760 layoutItem->setStartMarker( QgsLayoutItemPolyline::MarkerMode::SvgMarker );
761 layoutItem->setStartSvgMarkerPath( startMarkerFile );
766 layoutItem->setEndMarker( QgsLayoutItemPolyline::MarkerMode::NoMarker );
767 layoutItem->setStartMarker( QgsLayoutItemPolyline::MarkerMode::NoMarker );
770 double margin = polygon.boundingRect().left() - layoutItem->pos().x();
771 polygon.translate( - polygon.boundingRect().left() + margin, - polygon.boundingRect().top() + margin );
772 layoutItem->setNodes( polygon );
779 restoreGeneralComposeItemProperties( layoutItem, itemElem );
781 mapId2Uuid[ itemElem.attribute( QStringLiteral(
"id" ) ) ] = layoutItem->
uuid();
792 QDomNodeList extentNodeList = itemElem.elementsByTagName( QStringLiteral(
"Extent" ) );
793 if ( !extentNodeList.isEmpty() )
795 QDomElement extentElem = extentNodeList.at( 0 ).toElement();
796 double xmin, xmax, ymin, ymax;
797 xmin = extentElem.attribute( QStringLiteral(
"xmin" ) ).toDouble();
798 xmax = extentElem.attribute( QStringLiteral(
"xmax" ) ).toDouble();
799 ymin = extentElem.attribute( QStringLiteral(
"ymin" ) ).toDouble();
800 ymax = extentElem.attribute( QStringLiteral(
"ymax" ) ).toDouble();
804 QDomNodeList crsNodeList = itemElem.elementsByTagName( QStringLiteral(
"crs" ) );
805 if ( !crsNodeList.isEmpty() )
807 QDomElement crsElem = crsNodeList.at( 0 ).toElement();
816 if ( !
qgsDoubleNear( itemElem.attribute( QStringLiteral(
"mapRotation" ), QStringLiteral(
"0" ) ).toDouble(), 0.0 ) )
818 layoutItem->
setMapRotation( itemElem.attribute( QStringLiteral(
"mapRotation" ), QStringLiteral(
"0" ) ).toDouble() );
822 layoutItem->
setFollowVisibilityPreset( itemElem.attribute( QStringLiteral(
"followPreset" ) ).compare( QLatin1String(
"true" ) ) == 0 );
826 QString keepLayerSetFlag = itemElem.attribute( QStringLiteral(
"keepLayerSet" ) );
827 if ( keepLayerSetFlag.compare( QLatin1String(
"true" ), Qt::CaseInsensitive ) == 0 )
836 QString drawCanvasItemsFlag = itemElem.attribute( QStringLiteral(
"drawCanvasItems" ), QStringLiteral(
"true" ) );
837 if ( drawCanvasItemsFlag.compare( QLatin1String(
"true" ), Qt::CaseInsensitive ) == 0 )
846 layoutItem->mLayerStyleOverrides.clear();
849 layoutItem->mLayers.clear();
851 QDomNodeList layerSetNodeList = itemElem.elementsByTagName( QStringLiteral(
"LayerSet" ) );
852 if ( !layerSetNodeList.isEmpty() )
854 QDomElement layerSetElem = layerSetNodeList.at( 0 ).toElement();
855 QDomNodeList layerIdNodeList = layerSetElem.elementsByTagName( QStringLiteral(
"Layer" ) );
856 layoutItem->mLayers.reserve( layerIdNodeList.size() );
857 for (
int i = 0; i < layerIdNodeList.size(); ++i )
859 QDomElement layerElem = layerIdNodeList.at( i ).toElement();
860 QString layerId = layerElem.text();
861 QString layerName = layerElem.attribute( QStringLiteral(
"name" ) );
862 QString layerSource = layerElem.attribute( QStringLiteral(
"source" ) );
863 QString layerProvider = layerElem.attribute( QStringLiteral(
"provider" ) );
865 QgsMapLayerRef ref( layerId, layerName, layerSource, layerProvider );
867 layoutItem->mLayers << ref;
872 QDomNodeList layerStylesNodeList = itemElem.elementsByTagName( QStringLiteral(
"LayerStyles" ) );
873 layoutItem->mKeepLayerStyles = !layerStylesNodeList.isEmpty();
874 if ( layoutItem->mKeepLayerStyles )
876 QDomElement layerStylesElem = layerStylesNodeList.at( 0 ).toElement();
877 QDomNodeList layerStyleNodeList = layerStylesElem.elementsByTagName( QStringLiteral(
"LayerStyle" ) );
878 for (
int i = 0; i < layerStyleNodeList.size(); ++i )
880 const QDomElement &layerStyleElement = layerStyleNodeList.at( i ).toElement();
881 QString layerId = layerStyleElement.attribute( QStringLiteral(
"layerid" ) );
882 QString layerName = layerStyleElement.attribute( QStringLiteral(
"name" ) );
883 QString layerSource = layerStyleElement.attribute( QStringLiteral(
"source" ) );
884 QString layerProvider = layerStyleElement.attribute( QStringLiteral(
"provider" ) );
885 QgsMapLayerRef ref( layerId, layerName, layerSource, layerProvider );
889 style.
readXml( layerStyleElement );
890 layoutItem->mLayerStyleOverrides.insert( ref.
layerId, style.
xmlData() );
894 layoutItem->mDrawing =
false;
895 layoutItem->mNumCachedLayers = 0;
896 layoutItem->mCacheInvalidated =
true;
900 QDomNodeList mapOverviewNodeList = itemElem.elementsByTagName( QStringLiteral(
"ComposerMapOverview" ) );
901 for (
int i = 0; i < mapOverviewNodeList.size(); ++i )
903 QDomElement mapOverviewElem = mapOverviewNodeList.at( i ).toElement();
904 std::unique_ptr<QgsLayoutItemMapOverview> mapOverview(
new QgsLayoutItemMapOverview( mapOverviewElem.attribute( QStringLiteral(
"name" ) ), layoutItem ) );
905 mapOverview->readXml( mapOverviewElem, doc, context );
906 QString frameMapId = mapOverviewElem.attribute( QStringLiteral(
"frameMap" ), QStringLiteral(
"-1" ) );
907 if ( frameMapId != QStringLiteral(
"-1" ) && mapId2Uuid.contains( frameMapId ) )
912 mapOverview->setLinkedMap( mapInstance );
914 layoutItem->mOverviewStack->addOverview( mapOverview.release() );
919 layoutItem->mGridStack->readXml( itemElem, doc, context );
924 QDomNodeList gridNodeList = itemElem.elementsByTagName( QStringLiteral(
"Grid" ) );
925 if ( layoutItem->mGridStack->size() == 0 && !gridNodeList.isEmpty() )
927 QDomElement gridElem = gridNodeList.at( 0 ).toElement();
929 mapGrid->
setEnabled( gridElem.attribute( QStringLiteral(
"show" ), QStringLiteral(
"0" ) ) != QLatin1String(
"0" ) );
931 mapGrid->
setIntervalX( gridElem.attribute( QStringLiteral(
"intervalX" ), QStringLiteral(
"0" ) ).toDouble() );
932 mapGrid->
setIntervalY( gridElem.attribute( QStringLiteral(
"intervalY" ), QStringLiteral(
"0" ) ).toDouble() );
933 mapGrid->
setOffsetX( gridElem.attribute( QStringLiteral(
"offsetX" ), QStringLiteral(
"0" ) ).toDouble() );
934 mapGrid->
setOffsetY( gridElem.attribute( QStringLiteral(
"offsetY" ), QStringLiteral(
"0" ) ).toDouble() );
935 mapGrid->
setCrossLength( gridElem.attribute( QStringLiteral(
"crossLength" ), QStringLiteral(
"3" ) ).toDouble() );
936 mapGrid->
setFrameStyle( static_cast< QgsLayoutItemMapGrid::FrameStyle >( gridElem.attribute( QStringLiteral(
"gridFrameStyle" ), QStringLiteral(
"0" ) ).toInt() ) );
937 mapGrid->
setFrameWidth( gridElem.attribute( QStringLiteral(
"gridFrameWidth" ), QStringLiteral(
"2.0" ) ).toDouble() );
938 mapGrid->
setFramePenSize( gridElem.attribute( QStringLiteral(
"gridFramePenThickness" ), QStringLiteral(
"0.5" ) ).toDouble() );
943 QDomElement gridSymbolElem = gridElem.firstChildElement( QStringLiteral(
"symbol" ) );
945 if ( gridSymbolElem.isNull() )
949 lineSymbol->
setWidth( gridElem.attribute( QStringLiteral(
"penWidth" ), QStringLiteral(
"0" ) ).toDouble() );
950 lineSymbol->
setColor( QColor( gridElem.attribute( QStringLiteral(
"penColorRed" ), QStringLiteral(
"0" ) ).toInt(),
951 gridElem.attribute( QStringLiteral(
"penColorGreen" ), QStringLiteral(
"0" ) ).toInt(),
952 gridElem.attribute( QStringLiteral(
"penColorBlue" ), QStringLiteral(
"0" ) ).toInt() ) );
956 lineSymbol = QgsSymbolLayerUtils::loadSymbol<QgsLineSymbol>( gridSymbolElem, context );
961 QDomNodeList annotationNodeList = gridElem.elementsByTagName( QStringLiteral(
"Annotation" ) );
962 if ( !annotationNodeList.isEmpty() )
964 QDomElement annotationElem = annotationNodeList.at( 0 ).toElement();
965 mapGrid->
setAnnotationEnabled( annotationElem.attribute( QStringLiteral(
"show" ), QStringLiteral(
"0" ) ) != QLatin1String(
"0" ) );
975 mapGrid->
setAnnotationFrameDistance( annotationElem.attribute( QStringLiteral(
"frameDistance" ), QStringLiteral(
"0" ) ).toDouble() );
976 QFont annotationFont;
977 annotationFont.fromString( annotationElem.attribute( QStringLiteral(
"font" ), QLatin1String(
"" ) ) );
981 mapGrid->
setAnnotationPrecision( annotationElem.attribute( QStringLiteral(
"precision" ), QStringLiteral(
"3" ) ).toInt() );
983 layoutItem->mGridStack->addGrid( mapGrid );
987 QDomNodeList atlasNodeList = itemElem.elementsByTagName( QStringLiteral(
"AtlasMap" ) );
988 if ( !atlasNodeList.isEmpty() )
990 QDomElement atlasElem = atlasNodeList.at( 0 ).toElement();
991 layoutItem->mAtlasDriven = ( atlasElem.attribute( QStringLiteral(
"atlasDriven" ), QStringLiteral(
"0" ) ) != QLatin1String(
"0" ) );
992 if ( atlasElem.hasAttribute( QStringLiteral(
"fixedScale" ) ) )
994 layoutItem->
setAtlasScalingMode( atlasElem.attribute( QStringLiteral(
"fixedScale" ), QStringLiteral(
"0" ) ) != QLatin1String(
"0" ) ? QgsLayoutItemMap::AtlasScalingMode::Fixed : QgsLayoutItemMap::AtlasScalingMode::Auto );
996 else if ( atlasElem.hasAttribute( QStringLiteral(
"scalingMode" ) ) )
998 layoutItem->
setAtlasScalingMode( static_cast<QgsLayoutItemMap::AtlasScalingMode>( atlasElem.attribute( QStringLiteral(
"scalingMode" ) ).toInt() ) );
1000 layoutItem->
setAtlasMargin( atlasElem.attribute( QStringLiteral(
"margin" ), QStringLiteral(
"0.1" ) ).toDouble() );
1010 Q_UNUSED( project );
1011 restoreGeneralComposeItemProperties( layoutItem, itemElem );
1013 layoutItem->
setHeight( itemElem.attribute( QStringLiteral(
"height" ), QStringLiteral(
"5.0" ) ).toDouble() );
1014 layoutItem->
setHeight( itemElem.attribute( QStringLiteral(
"height" ), QStringLiteral(
"5.0" ) ).toDouble() );
1015 layoutItem->
setLabelBarSpace( itemElem.attribute( QStringLiteral(
"labelBarSpace" ), QStringLiteral(
"3.0" ) ).toDouble() );
1016 layoutItem->
setBoxContentSpace( itemElem.attribute( QStringLiteral(
"boxContentSpace" ), QStringLiteral(
"1.0" ) ).toDouble() );
1017 layoutItem->
setNumberOfSegments( itemElem.attribute( QStringLiteral(
"numSegments" ), QStringLiteral(
"2" ) ).toInt() );
1018 layoutItem->
setNumberOfSegmentsLeft( itemElem.attribute( QStringLiteral(
"numSegmentsLeft" ), QStringLiteral(
"0" ) ).toInt() );
1019 layoutItem->
setUnitsPerSegment( itemElem.attribute( QStringLiteral(
"numUnitsPerSegment" ), QStringLiteral(
"1.0" ) ).toDouble() );
1020 layoutItem->
setSegmentSizeMode( static_cast<QgsScaleBarSettings::SegmentSizeMode>( itemElem.attribute( QStringLiteral(
"segmentSizeMode" ), QStringLiteral(
"0" ) ).toInt() ) );
1021 layoutItem->
setMinimumBarWidth( itemElem.attribute( QStringLiteral(
"minBarWidth" ), QStringLiteral(
"50" ) ).toDouble() );
1022 layoutItem->
setMaximumBarWidth( itemElem.attribute( QStringLiteral(
"maxBarWidth" ), QStringLiteral(
"150" ) ).toDouble() );
1023 layoutItem->mSegmentMillimeters = itemElem.attribute( QStringLiteral(
"segmentMillimeters" ), QStringLiteral(
"0.0" ) ).toDouble();
1024 layoutItem->
setMapUnitsPerScaleBarUnit( itemElem.attribute( QStringLiteral(
"numMapUnitsPerScaleBarUnit" ), QStringLiteral(
"1.0" ) ).toDouble() );
1025 layoutItem->
setLineWidth( itemElem.attribute( QStringLiteral(
"outlineWidth" ), QStringLiteral(
"0.3" ) ).toDouble() );
1026 layoutItem->
setUnitLabel( itemElem.attribute( QStringLiteral(
"unitLabel" ) ) );
1032 f.fromString( itemElem.attribute( QStringLiteral(
"font" ), QLatin1String(
"" ) ) );
1038 QDomNodeList fillColorList = itemElem.elementsByTagName( QStringLiteral(
"fillColor" ) );
1039 if ( !fillColorList.isEmpty() )
1041 QDomElement fillColorElem = fillColorList.at( 0 ).toElement();
1042 bool redOk, greenOk, blueOk, alphaOk;
1043 int fillRed, fillGreen, fillBlue, fillAlpha;
1045 fillRed = fillColorElem.attribute( QStringLiteral(
"red" ) ).toDouble( &redOk );
1046 fillGreen = fillColorElem.attribute( QStringLiteral(
"green" ) ).toDouble( &greenOk );
1047 fillBlue = fillColorElem.attribute( QStringLiteral(
"blue" ) ).toDouble( &blueOk );
1048 fillAlpha = fillColorElem.attribute( QStringLiteral(
"alpha" ) ).toDouble( &alphaOk );
1050 if ( redOk && greenOk && blueOk && alphaOk )
1052 layoutItem->
setFillColor( QColor( fillRed, fillGreen, fillBlue, fillAlpha ) );
1057 layoutItem->
setFillColor( QColor( itemElem.attribute( QStringLiteral(
"brushColor" ), QStringLiteral(
"#000000" ) ) ) );
1061 QDomNodeList fillColor2List = itemElem.elementsByTagName( QStringLiteral(
"fillColor2" ) );
1062 if ( !fillColor2List.isEmpty() )
1064 QDomElement fillColor2Elem = fillColor2List.at( 0 ).toElement();
1065 bool redOk, greenOk, blueOk, alphaOk;
1066 int fillRed, fillGreen, fillBlue, fillAlpha;
1068 fillRed = fillColor2Elem.attribute( QStringLiteral(
"red" ) ).toDouble( &redOk );
1069 fillGreen = fillColor2Elem.attribute( QStringLiteral(
"green" ) ).toDouble( &greenOk );
1070 fillBlue = fillColor2Elem.attribute( QStringLiteral(
"blue" ) ).toDouble( &blueOk );
1071 fillAlpha = fillColor2Elem.attribute( QStringLiteral(
"alpha" ) ).toDouble( &alphaOk );
1073 if ( redOk && greenOk && blueOk && alphaOk )
1075 layoutItem->
setFillColor2( QColor( fillRed, fillGreen, fillBlue, fillAlpha ) );
1080 layoutItem->
setFillColor2( QColor( itemElem.attribute( QStringLiteral(
"brush2Color" ), QStringLiteral(
"#ffffff" ) ) ) );
1084 QDomNodeList strokeColorList = itemElem.elementsByTagName( QStringLiteral(
"strokeColor" ) );
1085 if ( !strokeColorList.isEmpty() )
1087 QDomElement strokeColorElem = strokeColorList.at( 0 ).toElement();
1088 bool redOk, greenOk, blueOk, alphaOk;
1089 int strokeRed, strokeGreen, strokeBlue, strokeAlpha;
1091 strokeRed = strokeColorElem.attribute( QStringLiteral(
"red" ) ).toDouble( &redOk );
1092 strokeGreen = strokeColorElem.attribute( QStringLiteral(
"green" ) ).toDouble( &greenOk );
1093 strokeBlue = strokeColorElem.attribute( QStringLiteral(
"blue" ) ).toDouble( &blueOk );
1094 strokeAlpha = strokeColorElem.attribute( QStringLiteral(
"alpha" ) ).toDouble( &alphaOk );
1096 if ( redOk && greenOk && blueOk && alphaOk )
1098 layoutItem->
setLineColor( QColor( strokeRed, strokeGreen, strokeBlue, strokeAlpha ) );
1099 QPen p = layoutItem->mSettings.
pen();
1100 p.setColor( layoutItem->mSettings.
lineColor() );
1101 layoutItem->setPen( p );
1106 layoutItem->
setLineColor( QColor( itemElem.attribute( QStringLiteral(
"penColor" ), QStringLiteral(
"#000000" ) ) ) );
1107 QPen p = layoutItem->mSettings.
pen();
1108 p.setColor( layoutItem->mSettings.
lineColor() );
1109 layoutItem->setPen( p );
1113 QDomNodeList textColorList = itemElem.elementsByTagName( QStringLiteral(
"textColor" ) );
1114 if ( !textColorList.isEmpty() )
1116 QDomElement textColorElem = textColorList.at( 0 ).toElement();
1117 bool redOk, greenOk, blueOk, alphaOk;
1118 int textRed, textGreen, textBlue, textAlpha;
1120 textRed = textColorElem.attribute( QStringLiteral(
"red" ) ).toDouble( &redOk );
1121 textGreen = textColorElem.attribute( QStringLiteral(
"green" ) ).toDouble( &greenOk );
1122 textBlue = textColorElem.attribute( QStringLiteral(
"blue" ) ).toDouble( &blueOk );
1123 textAlpha = textColorElem.attribute( QStringLiteral(
"alpha" ) ).toDouble( &alphaOk );
1125 if ( redOk && greenOk && blueOk && alphaOk )
1127 layoutItem->
setFontColor( QColor( textRed, textGreen, textBlue, textAlpha ) );
1133 c.setNamedColor( itemElem.attribute( QStringLiteral(
"fontColor" ), QStringLiteral(
"#000000" ) ) );
1138 QString styleString = itemElem.attribute( QStringLiteral(
"style" ), QLatin1String(
"" ) );
1139 layoutItem->
setStyle( QObject::tr( styleString.toLocal8Bit().data() ) );
1141 if ( itemElem.attribute( QStringLiteral(
"unitType" ) ).isEmpty() )
1144 switch ( itemElem.attribute( QStringLiteral(
"units" ) ).toInt() )
1165 layoutItem->
setAlignment( static_cast< QgsScaleBarSettings::Alignment >( itemElem.attribute( QStringLiteral(
"alignment" ), QStringLiteral(
"0" ) ).toInt() ) );
1168 QString mapId = itemElem.attribute( QStringLiteral(
"mapId" ), QStringLiteral(
"-1" ) );
1169 if ( mapId != QStringLiteral(
"-1" ) && mapId2Uuid.contains( mapId ) )
1183 restoreGeneralComposeItemProperties( layoutItem, itemElem );
1192 QString mapId = itemElem.attribute( QStringLiteral(
"map" ), QStringLiteral(
"-1" ) );
1193 if ( mapId != QStringLiteral(
"-1" ) && mapId2Uuid.contains( mapId ) )
1203 layoutItem->
setTitle( itemElem.attribute( QStringLiteral(
"title" ) ) );
1204 if ( !itemElem.attribute( QStringLiteral(
"titleAlignment" ) ).isEmpty() )
1206 layoutItem->
setTitleAlignment( static_cast< Qt::AlignmentFlag >( itemElem.attribute( QStringLiteral(
"titleAlignment" ) ).toInt() ) );
1208 int colCount = itemElem.attribute( QStringLiteral(
"columnCount" ), QStringLiteral(
"1" ) ).toInt();
1209 if ( colCount < 1 ) colCount = 1;
1211 layoutItem->
setSplitLayer( itemElem.attribute( QStringLiteral(
"splitLayer" ), QStringLiteral(
"0" ) ).toInt() == 1 );
1212 layoutItem->
setEqualColumnWidth( itemElem.attribute( QStringLiteral(
"equalColumnWidth" ), QStringLiteral(
"0" ) ).toInt() == 1 );
1214 QDomNodeList stylesNodeList = itemElem.elementsByTagName( QStringLiteral(
"styles" ) );
1215 if ( !stylesNodeList.isEmpty() )
1217 QDomNode stylesNode = stylesNodeList.at( 0 );
1218 for (
int i = 0; i < stylesNode.childNodes().size(); i++ )
1220 QDomElement styleElem = stylesNode.childNodes().at( i ).toElement();
1222 style.
readXml( styleElem, QDomDocument() );
1223 QString name = styleElem.attribute( QStringLiteral(
"name" ) );
1237 fontClr.setNamedColor( itemElem.attribute( QStringLiteral(
"fontColor" ), QStringLiteral(
"#000000" ) ) );
1241 layoutItem->
setBoxSpace( itemElem.attribute( QStringLiteral(
"boxSpace" ), QStringLiteral(
"2.0" ) ).toDouble() );
1242 layoutItem->
setColumnSpace( itemElem.attribute( QStringLiteral(
"columnSpace" ), QStringLiteral(
"2.0" ) ).toDouble() );
1244 layoutItem->
setSymbolWidth( itemElem.attribute( QStringLiteral(
"symbolWidth" ), QStringLiteral(
"7.0" ) ).toDouble() );
1245 layoutItem->
setSymbolHeight( itemElem.attribute( QStringLiteral(
"symbolHeight" ), QStringLiteral(
"14.0" ) ).toDouble() );
1246 layoutItem->
setWmsLegendWidth( itemElem.attribute( QStringLiteral(
"wmsLegendWidth" ), QStringLiteral(
"50" ) ).toDouble() );
1247 layoutItem->
setWmsLegendHeight( itemElem.attribute( QStringLiteral(
"wmsLegendHeight" ), QStringLiteral(
"25" ) ).toDouble() );
1248 layoutItem->
setLineSpacing( itemElem.attribute( QStringLiteral(
"lineSpacing" ), QStringLiteral(
"1.0" ) ).toDouble() );
1250 layoutItem->
setDrawRasterStroke( itemElem.attribute( QStringLiteral(
"rasterBorder" ), QStringLiteral(
"1" ) ) != QLatin1String(
"0" ) );
1252 layoutItem->
setRasterStrokeWidth( itemElem.attribute( QStringLiteral(
"rasterBorderWidth" ), QStringLiteral(
"0" ) ).toDouble() );
1254 layoutItem->
setWrapString( itemElem.attribute( QStringLiteral(
"wrapChar" ) ) );
1256 layoutItem->mSizeToContents = itemElem.attribute( QStringLiteral(
"resizeToContents" ), QStringLiteral(
"1" ) ) != QLatin1String(
"0" );
1257 layoutItem->mLegendFilterByMap = itemElem.attribute( QStringLiteral(
"legendFilterByMap" ), QStringLiteral(
"0" ) ).toInt();
1258 layoutItem->mFilterOutAtlas = itemElem.attribute( QStringLiteral(
"legendFilterByAtlas" ), QStringLiteral(
"0" ) ).toInt();
1261 QDomElement layerTreeElem = itemElem.firstChildElement( QStringLiteral(
"layer-tree" ) );
1262 if ( layerTreeElem.isNull() )
1263 layerTreeElem = itemElem.firstChildElement( QStringLiteral(
"layer-tree-group" ) );
1265 if ( !layerTreeElem.isNull() )
1270 layoutItem->setCustomLayerTree( tree );
1274 layoutItem->setCustomLayerTree(
nullptr );
1280 bool QgsCompositionConverter::readAtlasXml(
QgsLayoutAtlas *atlasItem,
const QDomElement &itemElem,
const QgsProject *project )
1282 atlasItem->
setEnabled( itemElem.attribute( QStringLiteral(
"enabled" ), QStringLiteral(
"false" ) ) == QLatin1String(
"true" ) );
1285 QString layerId = itemElem.attribute( QStringLiteral(
"coverageLayer" ) );
1286 QString layerName = itemElem.attribute( QStringLiteral(
"coverageLayerName" ) );
1287 QString layerSource = itemElem.attribute( QStringLiteral(
"coverageLayerSource" ) );
1288 QString layerProvider = itemElem.attribute( QStringLiteral(
"coverageLayerProvider" ) );
1293 atlasItem->
setPageNameExpression( itemElem.attribute( QStringLiteral(
"pageNameExpression" ), QString() ) );
1294 QString errorString;
1295 atlasItem->
setFilenameExpression( itemElem.attribute( QStringLiteral(
"filenamePattern" ), QLatin1String(
"" ) ), errorString );
1297 atlasItem->
setSortFeatures( itemElem.attribute( QStringLiteral(
"sortFeatures" ), QStringLiteral(
"false" ) ) == QLatin1String(
"true" ) );
1300 atlasItem->
setSortExpression( itemElem.attribute( QStringLiteral(
"sortKey" ), QLatin1String(
"" ) ) );
1301 atlasItem->
setSortAscending( itemElem.attribute( QStringLiteral(
"sortAscending" ), QStringLiteral(
"true" ) ) == QLatin1String(
"true" ) );
1303 atlasItem->
setFilterFeatures( itemElem.attribute( QStringLiteral(
"filterFeatures" ), QStringLiteral(
"false" ) ) == QLatin1String(
"true" ) );
1306 QString expErrorString;
1307 atlasItem->
setFilterExpression( itemElem.attribute( QStringLiteral(
"featureFilter" ), QLatin1String(
"" ) ), expErrorString );
1311 atlasItem->
setHideCoverage( itemElem.attribute( QStringLiteral(
"hideCoverage" ), QStringLiteral(
"false" ) ) == QLatin1String(
"true" ) );
1317 bool QgsCompositionConverter::readHtmlXml(
QgsLayoutItemHtml *layoutItem,
const QDomElement &itemElem,
const QgsProject *project )
1319 Q_UNUSED( project );
1320 readOldComposerObjectXml( layoutItem, itemElem );
1323 layoutItem->
setResizeMode( static_cast< QgsLayoutMultiFrame::ResizeMode >( itemElem.attribute( QStringLiteral(
"resizeMode" ), QStringLiteral(
"0" ) ).toInt() ) );
1324 QDomNodeList frameList = itemElem.elementsByTagName( QStringLiteral(
"ComposerFrame" ) );
1325 for (
int i = 0; i < frameList.size(); ++i )
1327 QDomElement frameElem = frameList.at( i ).toElement();
1329 restoreGeneralComposeItemProperties( newFrame, frameElem );
1331 double x = itemElem.attribute( QStringLiteral(
"sectionX" ) ).toDouble();
1332 double y = itemElem.attribute( QStringLiteral(
"sectionY" ) ).toDouble();
1333 double width = itemElem.attribute( QStringLiteral(
"sectionWidth" ) ).toDouble();
1334 double height = itemElem.attribute( QStringLiteral(
"sectionHeight" ) ).toDouble();
1336 newFrame->
setHidePageIfEmpty( itemElem.attribute( QStringLiteral(
"hidePageIfEmpty" ), QStringLiteral(
"0" ) ).toInt() );
1337 newFrame->
setHideBackgroundIfEmpty( itemElem.attribute( QStringLiteral(
"hideBackgroundIfEmpty" ), QStringLiteral(
"0" ) ).toInt() );
1338 layoutItem->
addFrame( newFrame,
false );
1342 layoutItem->
setContentMode( static_cast< QgsLayoutItemHtml::ContentMode >( itemElem.attribute( QStringLiteral(
"contentMode" ) ).toInt( &contentModeOK ) ) );
1343 if ( !contentModeOK )
1345 layoutItem->
setContentMode( QgsLayoutItemHtml::ContentMode::Url );
1347 layoutItem->
setEvaluateExpressions( itemElem.attribute( QStringLiteral(
"evaluateExpressions" ), QStringLiteral(
"true" ) ) == QLatin1String(
"true" ) );
1348 layoutItem->
setUseSmartBreaks( itemElem.attribute( QStringLiteral(
"useSmartBreaks" ), QStringLiteral(
"true" ) ) == QLatin1String(
"true" ) );
1349 layoutItem->
setMaxBreakDistance( itemElem.attribute( QStringLiteral(
"maxBreakDistance" ), QStringLiteral(
"10" ) ).toDouble() );
1350 layoutItem->
setHtml( itemElem.attribute( QStringLiteral(
"html" ) ) );
1351 layoutItem->
setUserStylesheet( itemElem.attribute( QStringLiteral(
"stylesheet" ) ) );
1352 layoutItem->
setUserStylesheetEnabled( itemElem.attribute( QStringLiteral(
"stylesheetEnabled" ), QStringLiteral(
"false" ) ) == QLatin1String(
"true" ) );
1355 QString urlString = itemElem.attribute( QStringLiteral(
"url" ) );
1356 if ( !urlString.isEmpty() )
1358 layoutItem->
setUrl( urlString );
1368 Q_UNUSED( project );
1369 readOldComposerObjectXml( layoutItem, itemElem );
1372 layoutItem->
setResizeMode( static_cast< QgsLayoutMultiFrame::ResizeMode >( itemElem.attribute( QStringLiteral(
"resizeMode" ), QStringLiteral(
"0" ) ).toInt() ) );
1373 QDomNodeList frameList = itemElem.elementsByTagName( QStringLiteral(
"ComposerFrame" ) );
1374 for (
int i = 0; i < frameList.size(); ++i )
1376 QDomElement frameElem = frameList.at( i ).toElement();
1378 restoreGeneralComposeItemProperties( newFrame, frameElem );
1380 double x = itemElem.attribute( QStringLiteral(
"sectionX" ) ).toDouble();
1381 double y = itemElem.attribute( QStringLiteral(
"sectionY" ) ).toDouble();
1382 double width = itemElem.attribute( QStringLiteral(
"sectionWidth" ) ).toDouble();
1383 double height = itemElem.attribute( QStringLiteral(
"sectionHeight" ) ).toDouble();
1385 newFrame->
setHidePageIfEmpty( itemElem.attribute( QStringLiteral(
"hidePageIfEmpty" ), QStringLiteral(
"0" ) ).toInt() );
1386 newFrame->
setHideBackgroundIfEmpty( itemElem.attribute( QStringLiteral(
"hideBackgroundIfEmpty" ), QStringLiteral(
"0" ) ).toInt() );
1387 layoutItem->
addFrame( newFrame,
false );
1390 layoutItem->
setEmptyTableBehavior( static_cast<QgsLayoutTable::EmptyTableMode>( itemElem.attribute( QStringLiteral(
"emptyTableMode" ), QStringLiteral(
"0" ) ).toInt() ) );
1391 layoutItem->
setEmptyTableMessage( itemElem.attribute( QStringLiteral(
"emptyTableMessage" ), QObject::tr(
"No matching records" ) ) );
1392 layoutItem->
setShowEmptyRows( itemElem.attribute( QStringLiteral(
"showEmptyRows" ), QStringLiteral(
"0" ) ).toInt() );
1395 layoutItem->
mHeaderFont.fromString( itemElem.attribute( QStringLiteral(
"headerFont" ), QLatin1String(
"" ) ) );
1398 layoutItem->
setHeaderHAlignment( static_cast<QgsLayoutTable::HeaderHAlignment>( itemElem.attribute( QStringLiteral(
"headerHAlignment" ), QStringLiteral(
"0" ) ).toInt() ) ) ;
1399 layoutItem->
setHeaderMode( static_cast<QgsLayoutTable::HeaderMode>( itemElem.attribute( QStringLiteral(
"headerMode" ), QStringLiteral(
"0" ) ).toInt() ) );
1402 layoutItem->
mContentFont.fromString( itemElem.attribute( QStringLiteral(
"contentFont" ), QLatin1String(
"" ) ) );
1405 layoutItem->
setCellMargin( itemElem.attribute( QStringLiteral(
"cellMargin" ), QStringLiteral(
"1.0" ) ).toDouble() );
1406 layoutItem->
setGridStrokeWidth( itemElem.attribute( QStringLiteral(
"gridStrokeWidth" ), QStringLiteral(
"0.5" ) ).toDouble() );
1407 layoutItem->
setHorizontalGrid( itemElem.attribute( QStringLiteral(
"horizontalGrid" ), QStringLiteral(
"1" ) ).toInt() );
1408 layoutItem->
setVerticalGrid( itemElem.attribute( QStringLiteral(
"verticalGrid" ), QStringLiteral(
"1" ) ).toInt() );
1409 layoutItem->
setShowGrid( itemElem.attribute( QStringLiteral(
"showGrid" ), QStringLiteral(
"1" ) ).toInt() );
1412 layoutItem->
setWrapBehavior( static_cast<QgsLayoutTable::WrapBehavior>( itemElem.attribute( QStringLiteral(
"wrapBehavior" ), QStringLiteral(
"0" ) ).toInt() ) );
1416 QDomNodeList columnsList = itemElem.elementsByTagName( QStringLiteral(
"displayColumns" ) );
1417 if ( !columnsList.isEmpty() )
1419 QDomElement columnsElem = columnsList.at( 0 ).toElement();
1420 QDomNodeList columnEntryList = columnsElem.elementsByTagName( QStringLiteral(
"column" ) );
1421 for (
int i = 0; i < columnEntryList.size(); ++i )
1423 QDomElement columnElem = columnEntryList.at( i ).toElement();
1425 column->mHAlignment =
static_cast< Qt::AlignmentFlag
>( columnElem.attribute( QStringLiteral(
"hAlignment" ), QString::number( Qt::AlignLeft ) ).toInt() );
1426 column->mVAlignment =
static_cast< Qt::AlignmentFlag
>( columnElem.attribute( QStringLiteral(
"vAlignment" ), QString::number( Qt::AlignVCenter ) ).toInt() );
1427 column->mHeading = columnElem.attribute( QStringLiteral(
"heading" ), QLatin1String(
"" ) );
1428 column->mAttribute = columnElem.attribute( QStringLiteral(
"attribute" ), QLatin1String(
"" ) );
1429 column->mSortByRank = columnElem.attribute( QStringLiteral(
"sortByRank" ), QStringLiteral(
"0" ) ).toInt();
1430 column->mSortOrder =
static_cast< Qt::SortOrder
>( columnElem.attribute( QStringLiteral(
"sortOrder" ), QString::number( Qt::AscendingOrder ) ).toInt() );
1431 column->mWidth = columnElem.attribute( QStringLiteral(
"width" ), QStringLiteral(
"0.0" ) ).toDouble();
1433 QDomNodeList bgColorList = columnElem.elementsByTagName( QStringLiteral(
"backgroundColor" ) );
1434 if ( !bgColorList.isEmpty() )
1436 QDomElement bgColorElem = bgColorList.at( 0 ).toElement();
1437 bool redOk, greenOk, blueOk, alphaOk;
1438 int bgRed, bgGreen, bgBlue, bgAlpha;
1439 bgRed = bgColorElem.attribute( QStringLiteral(
"red" ) ).toDouble( &redOk );
1440 bgGreen = bgColorElem.attribute( QStringLiteral(
"green" ) ).toDouble( &greenOk );
1441 bgBlue = bgColorElem.attribute( QStringLiteral(
"blue" ) ).toDouble( &blueOk );
1442 bgAlpha = bgColorElem.attribute( QStringLiteral(
"alpha" ) ).toDouble( &alphaOk );
1443 if ( redOk && greenOk && blueOk && alphaOk )
1445 column->mBackgroundColor = QColor( bgRed, bgGreen, bgBlue, bgAlpha );
1448 layoutItem->
mColumns.append( column );
1453 QDomNodeList stylesList = itemElem.elementsByTagName( QStringLiteral(
"cellStyles" ) );
1454 if ( !stylesList.isEmpty() )
1456 QDomElement stylesElem = stylesList.at( 0 ).toElement();
1458 QMap< QgsLayoutTable::CellStyleGroup, QString >::const_iterator it = layoutItem->mCellStyleNames.constBegin();
1459 for ( ; it != layoutItem->mCellStyleNames.constEnd(); ++it )
1461 QString styleName = it.value();
1462 QDomNodeList styleList = stylesElem.elementsByTagName( styleName );
1463 if ( !styleList.isEmpty() )
1465 QDomElement styleElem = styleList.at( 0 ).toElement();
1474 QString layerId = itemElem.attribute( QStringLiteral(
"vectorLayer" ) );
1475 QString layerName = itemElem.attribute( QStringLiteral(
"vectorLayerName" ) );
1476 QString layerSource = itemElem.attribute( QStringLiteral(
"vectorLayerSource" ) );
1477 QString layerProvider = itemElem.attribute( QStringLiteral(
"vectorLayerProvider" ) );
1486 template <
class T,
class T2>
1487 bool QgsCompositionConverter::readPolyXml( T *layoutItem,
const QDomElement &itemElem,
const QgsProject *project )
1489 restoreGeneralComposeItemProperties( layoutItem, itemElem );
1490 QDomNodeList nodeList = itemElem.elementsByTagName( QStringLiteral(
"node" ) );
1491 if ( !nodeList.isEmpty() )
1494 for (
int i = 0; i < nodeList.length(); i++ )
1496 QDomElement node = nodeList.at( i ).toElement();
1497 polygon.append( QPointF( node.attribute( QStringLiteral(
"x" ) ).toDouble( ), node.attribute( QStringLiteral(
"y" ) ).toDouble() ) );
1499 layoutItem->setNodes( polygon );
1501 if ( itemElem.elementsByTagName( QStringLiteral(
"symbol" ) ).size() )
1503 QDomElement symbolElement = itemElem.elementsByTagName( QStringLiteral(
"symbol" ) ).at( 0 ).toElement();
1507 T2 *styleSymbol = QgsSymbolLayerUtils::loadSymbol<T2>( symbolElement, context );
1509 layoutItem->setSymbol( styleSymbol );
1512 layoutItem->setFrameEnabled(
false );
1513 layoutItem->setBackgroundEnabled(
false );
1518 bool QgsCompositionConverter::readXml(
QgsLayoutItem *layoutItem,
const QDomElement &itemElem )
1520 if ( itemElem.isNull() )
1525 readOldComposerObjectXml( layoutItem, itemElem );
1528 layoutItem->mUuid = itemElem.attribute( QStringLiteral(
"uuid" ), QUuid::createUuid().toString() );
1531 layoutItem->mTemplateUuid = itemElem.attribute( QStringLiteral(
"templateUuid" ) );
1534 QString
id = itemElem.attribute( QStringLiteral(
"id" ), QStringLiteral(
"" ) );
1535 layoutItem->
setId(
id );
1538 QString frame = itemElem.attribute( QStringLiteral(
"frame" ) );
1539 layoutItem->
setFrameEnabled( frame.compare( QStringLiteral(
"true" ), Qt::CaseInsensitive ) == 0 ) ;
1542 QString background = itemElem.attribute( QStringLiteral(
"background" ) );
1543 layoutItem->
setBackgroundEnabled( background.compare( QStringLiteral(
"true" ), Qt::CaseInsensitive ) == 0 );
1546 QString positionLock = itemElem.attribute( QStringLiteral(
"positionLock" ) );
1547 layoutItem->
setLocked( positionLock.compare( QStringLiteral(
"true" ), Qt::CaseInsensitive ) == 0 );
1550 layoutItem->
setVisibility( itemElem.attribute( QStringLiteral(
"visibility" ), QStringLiteral(
"1" ) ) != QStringLiteral(
"0" ) );
1552 layoutItem->mParentGroupUuid = itemElem.attribute( QStringLiteral(
"groupUuid" ) );
1553 if ( !layoutItem->mParentGroupUuid.isEmpty() )
1557 group->addItem( layoutItem );
1560 layoutItem->mTemplateUuid = itemElem.attribute(
"templateUuid" );
1563 QRectF position = itemPosition( layoutItem, itemElem );
1568 layoutItem->setZValue( itemElem.attribute( QStringLiteral(
"zValue" ) ).toDouble() );
1571 QDomNodeList frameColorList = itemElem.elementsByTagName( QStringLiteral(
"FrameColor" ) );
1572 if ( !frameColorList.isEmpty() )
1574 QDomElement frameColorElem = frameColorList.at( 0 ).toElement();
1575 bool redOk, greenOk, blueOk, alphaOk, widthOk;
1576 int penRed, penGreen, penBlue, penAlpha;
1579 penWidth = itemElem.attribute( QStringLiteral(
"outlineWidth" ) ).toDouble( &widthOk );
1580 penRed = frameColorElem.attribute( QStringLiteral(
"red" ) ).toDouble( &redOk );
1581 penGreen = frameColorElem.attribute( QStringLiteral(
"green" ) ).toDouble( &greenOk );
1582 penBlue = frameColorElem.attribute( QStringLiteral(
"blue" ) ).toDouble( &blueOk );
1583 penAlpha = frameColorElem.attribute( QStringLiteral(
"alpha" ) ).toDouble( &alphaOk );
1586 if ( redOk && greenOk && blueOk && alphaOk && widthOk )
1593 layoutItem->setPen( framePen );
1600 QDomNodeList bgColorList = itemElem.elementsByTagName( QStringLiteral(
"BackgroundColor" ) );
1601 if ( !bgColorList.isEmpty() )
1603 QDomElement bgColorElem = bgColorList.at( 0 ).toElement();
1604 bool redOk, greenOk, blueOk, alphaOk;
1605 int bgRed, bgGreen, bgBlue, bgAlpha;
1606 bgRed = bgColorElem.attribute( QStringLiteral(
"red" ) ).toDouble( &redOk );
1607 bgGreen = bgColorElem.attribute( QStringLiteral(
"green" ) ).toDouble( &greenOk );
1608 bgBlue = bgColorElem.attribute( QStringLiteral(
"blue" ) ).toDouble( &blueOk );
1609 bgAlpha = bgColorElem.attribute( QStringLiteral(
"alpha" ) ).toDouble( &alphaOk );
1610 if ( redOk && greenOk && blueOk && alphaOk )
1612 layoutItem->mBackgroundColor = QColor( bgRed, bgGreen, bgBlue, bgAlpha );
1613 layoutItem->setBrush( QBrush( layoutItem->mBackgroundColor, Qt::SolidPattern ) );
1623 if ( itemElem.hasAttribute( QStringLiteral(
"opacity" ) ) )
1625 layoutItem->
setItemOpacity( itemElem.attribute( QStringLiteral(
"opacity" ), QStringLiteral(
"1" ) ).toDouble() );
1629 layoutItem->
setItemOpacity( 1.0 - itemElem.attribute( QStringLiteral(
"transparency" ), QStringLiteral(
"0" ) ).toInt() / 100.0 );
1632 layoutItem->mExcludeFromExports = itemElem.attribute( QStringLiteral(
"excludeFromExports" ), QStringLiteral(
"0" ) ).toInt();
1633 layoutItem->mEvaluatedExcludeFromExports = layoutItem->mExcludeFromExports;
1638 layoutItem->
setItemRotation( itemElem.attribute( QStringLiteral(
"itemRotation" ), QStringLiteral(
"0" ) ).toDouble(), false );
1640 layoutItem->mBlockUndoCommands =
false;
1647 bool QgsCompositionConverter::readOldComposerObjectXml(
QgsLayoutObject *layoutItem,
1648 const QDomElement &itemElem )
1650 if ( itemElem.isNull() )
1658 QDomNode propsNode = itemElem.namedItem( QStringLiteral(
"dataDefinedProperties" ) );
1659 if ( !propsNode.isNull() )
1667 exp = QStringLiteral(
"100.0 - (%1)" ).arg( exp );
1679 void QgsCompositionConverter::readOldDataDefinedPropertyMap(
const QDomElement &itemElem,
QgsPropertyCollection &dataDefinedProperties )
1682 QgsPropertiesDefinition::const_iterator i = defs.constBegin();
1683 for ( ; i != defs.constEnd(); ++i )
1685 QString elemName = i.value().name();
1686 QDomNodeList ddNodeList = itemElem.elementsByTagName( elemName );
1687 if ( !ddNodeList.isEmpty() )
1689 QDomElement ddElem = ddNodeList.at( 0 ).toElement();
1690 QgsProperty prop = readOldDataDefinedProperty( static_cast< QgsCompositionConverter::DataDefinedProperty >( i.key() ), ddElem );
1692 dataDefinedProperties.
setProperty( i.key(), prop );
1705 QString active = ddElem.attribute( QStringLiteral(
"active" ) );
1706 bool isActive =
false;
1707 if ( active.compare( QStringLiteral(
"true" ), Qt::CaseInsensitive ) == 0 )
1711 QString field = ddElem.attribute( QStringLiteral(
"field" ) );
1712 QString expr = ddElem.attribute( QStringLiteral(
"expr" ) );
1714 QString useExpr = ddElem.attribute( QStringLiteral(
"useExpr" ) );
1715 bool isExpression =
false;
1716 if ( useExpr.compare( QStringLiteral(
"true" ), Qt::CaseInsensitive ) == 0 )
1718 isExpression =
true;
void setProperty(int key, const QgsProperty &property)
Adds a property to the collection and takes ownership of it.
void setCoverageLayer(QgsVectorLayer *layer)
Sets the coverage layer to use for the atlas features.
void setColumnSpace(double spacing)
Sets the legend column spacing.
void setBlendMode(const QPainter::CompositionMode mode)
Sets the item's composition blending mode.
void setShapeType(QgsLayoutItemShape::Shape type)
Sets the type of shape (e.g.
void setFramePenSize(const double width)
Sets the width of the stroke drawn in the grid frame.
The class is used as a container of context for various read/write operations on other objects...
void setEqualColumnWidth(bool equalize)
Sets whether column widths should be equalized.
void setFontColor(const QColor &color)
Sets the legend font color.
void setIntervalY(double interval)
Sets the interval between grid lines in the y-direction.
void setFollowVisibilityPresetName(const QString &name)
Sets preset name for map rendering.
void setHorizontalGrid(const bool horizontalGrid)
Sets whether the grid's horizontal lines should be drawn in the table.
A rectangle specified with double values.
QString asExpression() const
Returns an expression string representing the state of the property, or an empty string if the proper...
void setLineWidth(double width)
Sets the line width in millimeters for lines in the scalebar.
void setWrapBehavior(WrapBehavior behavior)
Sets the wrap behavior for the table, which controls how text within cells is automatically wrapped...
void setTitle(const QString &title)
Sets the legend title.
void setPathResolver(const QgsPathResolver &resolver)
Sets up path resolver for conversion between relative and absolute paths.
Positive integer values (including 0)
QMap< CellStyleGroup, QgsLayoutTableStyle *> mCellStyles
void setSplitLayer(bool enabled)
Sets whether the legend items from a single layer can be split over multiple columns.
void setLineJoinStyle(Qt::PenJoinStyle style)
Sets the join style used when drawing the lines in the scalebar.
void setAnnotationFontColor(const QColor &color)
Sets the font color used for drawing grid annotations.
void setFrameFillColor1(const QColor &color)
Sets the first fill color used for the grid frame.
Base class for graphical items within a QgsLayout.
void setSymbolWidth(double width)
Sets the legend symbol width.
An individual overview which is drawn above the map content in a QgsLayoutItemMap, and shows the extent of another QgsLayoutItemMap.
void setVAlign(Qt::AlignmentFlag alignment)
Sets for the vertical alignment of the label.
void setUserStylesheet(const QString &stylesheet)
Sets the user stylesheet CSS rules to use while rendering the HTML content.
void setLocked(const bool locked)
Sets whether the item is locked, preventing mouse interactions with the item.
void refreshBackgroundColor(bool updateItem=true)
Refresh item's background color, considering data defined colors.
void readXml(const QDomNode &parentNode, const QString &keyStartsWith=QString())
Read store contents from XML.
QPen pen() const
Returns the pen used for drawing outlines in the scalebar.
A layout item subclass for text labels.
Preset paper size for composition.
QString readPath(const QString &filename) const
Turn filename read from the project file to an absolute path.
virtual bool readXml(const QDomElement &collectionElem, const QgsPropertiesDefinition &definitions)
Reads property collection state from an XML element.
QString xmlData() const
Return XML content of the style.
void readXml(const QDomElement &styleElement)
Read style configuration (for project file reading)
void setFontColor(const QColor &color)
Sets the color used for drawing text in the scalebar.
static QgsLineSymbol * createSimple(const QgsStringMap &properties)
Create a line symbol with one symbol layer: SimpleLine with specified properties. ...
void setExtent(const QgsRectangle &extent)
Sets a new extent for the map.
QgsObjectCustomProperties mCustomProperties
Custom properties for object.
static QgsFillSymbol * createSimple(const QgsStringMap &properties)
Create a fill symbol with one symbol layer: SimpleFill with specified properties. ...
void setLinkedMap(QgsLayoutItemMap *map)
Sets the map item linked to the scalebar.
void setSortAscending(bool ascending)
Sets whether features should be sorted in an ascending order.
void setBoxContentSpace(double space)
Sets the space (margin) between the scalebar box and content in millimeters.
QgsLayoutSize sizeWithUnits() const
Returns the item's current size, including units.
void setHeaderFontColor(const QColor &color)
Sets the color used to draw header text in the table.
QgsLayoutItem * itemByUuid(const QString &uuid, bool includeTemplateUuids=false) const
Returns the layout item with matching uuid unique identifier, or a nullptr if a matching item could n...
void setLineCapStyle(Qt::PenCapStyle style)
Sets the cap style used when drawing the lines in the scalebar.
bool frameEnabled() const
Returns true if the item includes a frame.
A container for grouping several QgsLayoutItems.
Styling option for a composer table cell.
static QgsProperty fromField(const QString &fieldName, bool isActive=true)
Returns a new FieldBasedProperty created from the specified field name.
TYPE * resolveWeakly(const QgsProject *project)
Resolves the map layer by attempting to find a matching layer in a project using a weak match...
Non-zero positive integer values.
void setReferencePoint(const ReferencePoint &point)
Sets the reference point for positioning of the layout item.
virtual void setVisibility(const bool visible)
Sets whether the item is visible.
void setEmptyTableMessage(const QString &message)
Sets the message for empty tables with no content rows.
void setHtml(const QString &html)
Sets the html to display in the item when the item is using the QgsLayoutItemHtml::ManualHtml mode...
A layout item subclass that displays SVG files or raster format images (jpg, png, ...
static QgsProperty fromExpression(const QString &expression, bool isActive=true)
Returns a new ExpressionBasedProperty created from the specified expression.
static std::unique_ptr< QgsPrintLayout > createLayoutFromCompositionXml(const QDomElement &composerElement, QgsProject *project)
createLayoutFromCompositionXml is a factory that creates layout instances from a QGIS 2...
static QDomDocument convertCompositionTemplate(const QDomDocument &document, QgsProject *project)
Convert a composition template document to a layout template.
void setHeight(double height)
Sets the scalebar height (in millimeters).
Composer legend components style.
void setFilterFeatures(bool filtered)
Sets whether features should be filtered in the coverage layer.
static QPainter::CompositionMode getCompositionMode(QgsPainting::BlendMode blendMode)
Returns a QPainter::CompositionMode corresponding to a BlendMode.
void setBlendMode(const QPainter::CompositionMode mode)
Sets the blending mode used for drawing the grid.
Color with alpha channel.
void setStyle(QgsLegendStyle::Style component, const QgsLegendStyle &style)
Sets the style of component to style for the legend.
void setAlignment(QgsScaleBarSettings::Alignment alignment)
Sets the scalebar alignment.
bool filterFeatures() const
Returns true if features should be filtered in the coverage layer.
void attemptMoveBy(double deltaX, double deltaY)
Attempts to shift the item's position by a specified deltaX and deltaY, in layout units...
static QString svgSymbolNameToPath(QString name, const QgsPathResolver &pathResolver)
Get SVG symbol's path from its name.
QList< QgsLayoutItemPage *> pages()
Returns a list of pages in the collection.
void setKeepLayerSet(bool enabled)
Sets whether the stored layer set should be used or the current layer set of the associated project...
void setFrameStrokeColor(const QColor &color)
Sets the frame stroke color.
Layout item for node based polygon shapes.
QColor lineColor() const
Returns the color used for lines in the scalebar.
void setMarginX(double margin)
Sets the horizontal margin between the edge of the frame and the label contents, in layout units...
static Q_INVOKABLE QgsUnitTypes::DistanceUnit decodeDistanceUnit(const QString &string, bool *ok=nullptr)
Decodes a distance unit from a string.
void setPictureAnchor(QgsLayoutItem::ReferencePoint anchor)
Sets the picture's anchor point, which controls how it is placed within the picture item's frame...
Positive double value (including 0)
void resolveReferences(const QgsProject *project, bool looseMatching=false) override
Calls resolveReferences() on child tree nodes.
void setShowGrid(const bool showGrid)
Sets whether grid lines should be drawn in the table.
void setLineColor(const QColor &color)
Sets the color used for lines in the scalebar.
void setSegmentSizeMode(QgsScaleBarSettings::SegmentSizeMode mode)
Sets the size mode for scale bar segments.
void setShowEmptyRows(const bool showEmpty)
Sets whether empty rows should be drawn.
QMap< QString, QString > QgsStringMap
bool qgsDoubleNear(double a, double b, double epsilon=4 *DBL_EPSILON)
Compare two doubles (but allow some difference)
void setStyle(const QString &name)
Sets the scale bar style by name.
void setUserStylesheetEnabled(const bool enabled)
Sets whether user stylesheets are enabled for the HTML content.
Rotation (value between 0-360 degrees)
static Qt::PenJoinStyle decodePenJoinStyle(const QString &str)
void setSortExpression(const QString &expression)
Sets the expression (or field name) to use for sorting features.
Stores properties of a column for a QgsLayoutTable.
void setVerticalGrid(const bool verticalGrid)
Sets whether the grid's vertical lines should be drawn in the table.
bool isActive(int key) const override
Returns true if the collection contains an active property with the specified key.
void setFrameWidth(const double width)
Sets the grid frame width (in layout units).
void setContentSection(const QRectF §ion)
Sets the visible part of the multiframe's content which is visible within this frame (relative to the...
QgsLayoutMeasurement frameStrokeWidth() const
Returns the frame's stroke width.
void setDrawRasterStroke(bool enabled)
Sets whether a stroke will be drawn around raster symbol items.
double spaceBetweenPages() const
Returns the space between pages, in layout units.
static QString encodeColor(const QColor &color)
This class provides a method of storing points, consisting of an x and y coordinate, for use in QGIS layouts.
void setAnnotationFont(const QFont &font)
Sets the font used for drawing grid annotations.
ReferencePoint
Fixed position reference point.
Exclude item from exports.
void setFillColor(const QColor &color)
Sets the color used for fills in the scalebar.
bool setFilenameExpression(const QString &expression, QString &errorString)
Sets the filename expression used for generating output filenames for each atlas page.
Stores style information (renderer, opacity, labeling, diagrams etc.) applicable to a map layer...
void setMaximumBarWidth(double maxWidth)
Sets the maximum width (in millimeters) for scale bar segments.
void setEvaluateExpressions(bool evaluateExpressions)
Sets whether the html item will evaluate QGIS expressions prior to rendering the HTML content...
Layout graphical items for displaying a map.
Layout item for node based polyline shapes.
virtual void setId(const QString &id)
Set the item's id name.
QString layerId
Original layer ID.
QgsPropertyCollection mDataDefinedProperties
const QgsLayout * layout() const
Returns the layout the object is attached to.
void setNumberOfSegments(int segments)
Sets the number of segments included in the scalebar.
void setHAlign(Qt::AlignmentFlag alignment)
Sets the horizontal alignment of the label.
Namespace with helper functions for layer tree operations.
This class provides a method of storing measurements for use in QGIS layouts using a variety of diffe...
static bool isCompositionTemplate(const QDomDocument &document)
Check if the given document is a composition template.
QgsPathResolver pathResolver() const
Return path resolver object with considering whether the project uses absolute or relative paths and ...
bool hasBackground() const
Returns true if the item has a background.
void setMapUnitsPerScaleBarUnit(double units)
Sets the number of map units per scale bar unit used by the scalebar.
void setUseSmartBreaks(bool useSmartBreaks)
Sets whether the html item should use smart breaks.
void setFrameFillColor2(const QColor &color)
Sets the second fill color used for the grid frame.
void setWidth(double width)
QgsLayoutPageCollection * pageCollection()
Returns a pointer to the layout's page collection, which stores and manages page items in the layout...
void setEmptyTableBehavior(const EmptyTableMode mode)
Sets the behavior mode for empty tables with no content rows.
void setOffsetY(const double offset)
Sets the offset for grid lines in the y-direction.
void attemptSetSceneRect(const QRectF &rect, bool includesFrame=false)
Attempts to update the item's position and size to match the passed rect in layout coordinates...
void setResizeMode(ResizeMode mode)
Sets the resize mode for the multiframe, and recalculates frame sizes to match.
Layout item for basic filled shapes (e.g.
void setFramePenColor(const QColor &color)
Sets the color of the stroke drawn in the grid frame.
Class used to render an Atlas, iterating over geometry features.
void setMinimumBarWidth(double minWidth)
Sets the minimum width (in millimeters) for scale bar segments.
void setMode(Mode mode)
Sets the label's current mode, allowing the label to switch between font based and HTML based renderi...
void setRasterStrokeColor(const QColor &color)
Sets the stroke color for the stroke drawn around raster symbol items.
virtual void setItemRotation(double rotation, bool adjustPosition=true)
Sets the layout item's rotation, in degrees clockwise.
void setOffsetX(const double offset)
Sets the offset for grid lines in the x-direction.
void setAnnotationEnabled(const bool enabled)
Sets whether annotations should be shown for the grid.
void setLinkedMap(QgsLayoutItemMap *map)
Sets the map object for rotation.
Scalebar secondary fill color.
void setMarginY(double margin)
Sets the vertical margin between the edge of the frame and the label contents, in layout units...
Reads and writes project states.
void setFrameStyle(const FrameStyle style)
Sets the grid frame style.
A layout table subclass that displays attributes from a vector layer.
Item transparency (deprecated)
static bool setFromXmlChildNode(QFont &font, const QDomElement &element, const QString &childNode)
Sets the properties of a font to match the properties stored in an XML child node.
void setContentFontColor(const QColor &color)
Sets the color used to draw text in table body cells.
virtual void setFrameStrokeWidth(const QgsLayoutMeasurement &width)
Sets the frame stroke width.
void setCrs(const QgsCoordinateReferenceSystem &crs)
Sets the map's preset crs (coordinate reference system).
void setHideCoverage(bool hide)
Sets whether the coverage layer should be hidden in map items in the layouts.
static Qt::PenCapStyle decodePenCapStyle(const QString &str)
void setLineSpacing(double spacing)
Sets the spacing in-between multiple lines.
void setHidePageIfEmpty(const bool hidePageIfEmpty)
Sets whether the page should be hidden (ie, not included in layout exports) if this frame is empty...
QFont mHeaderFont
Header font.
void setPicturePath(const QString &path)
Sets the source path of the image (may be svg or a raster format).
void setUnitLabel(const QString &label)
Sets the label for units.
AnnotationFormat
Format for displaying grid annotations.
void setHideBackgroundIfEmpty(const bool hideBackgroundIfEmpty)
Sets whether the background and frame stroke should be hidden if this frame is empty.
A store for object properties.
void setFillColor2(const QColor &color)
Sets the secondary color used for fills in the scalebar.
QColor frameStrokeColor() const
Returns the frame's stroke color.
void setAtlasScalingMode(AtlasScalingMode mode)
Sets the current atlas scaling mode.
Double value (including negative values)
void setWrapString(const QString &string)
Sets the legend text wrapping string.
void setContentMode(ContentMode mode)
Sets the source mode for item's HTML content.
void setCellMargin(const double margin)
Sets the margin distance in mm between cell borders and their contents.
void setVectorLayer(QgsVectorLayer *layer)
Sets the vector layer from which to display feature attributes.
void setGridStrokeWidth(const double width)
Sets the width in mm for grid lines in the table.
An individual grid which is drawn above the map content in a QgsLayoutItemMap.
AnnotationDirection
Direction of grid annotations.
Definition for a property.
QFont mContentFont
Table contents font.
void setLineSymbol(QgsLineSymbol *symbol)
Sets the line symbol used for drawing grid lines.
QMap< int, QgsPropertyDefinition > QgsPropertiesDefinition
Definition of available properties.
void setColumnCount(int count)
Sets the legend column count.
AnnotationPosition
Position for grid annotations.
void setUrl(const QUrl &url)
Sets the url for content to display in the item when the item is using the QgsLayoutItemHtml::Url mod...
void setBackgroundEnabled(bool drawBackground)
Sets whether this item has a background drawn under it or not.
void setFont(const QFont &font)
Sets the font used for drawing text in the scalebar.
DistanceUnit
Units of distance.
Number of pages in composition.
void setAnnotationDirection(const AnnotationDirection direction, const BorderSide side)
Sets the direction for drawing frame annotations for the specified map side.
void setAtlasMargin(double margin)
Sets the margin size (percentage) used when the map is in atlas mode.
void setFontColor(const QColor &color)
Sets the label font color.
bool setFilterExpression(const QString &expression, QString &errorString)
Sets the expression used for filtering features in the coverage layer.
void readXml(const QDomElement &elem, const QDomDocument &doc)
void setFollowVisibilityPreset(bool follow)
Sets whether the map should follow a map theme.
void setAnnotationPrecision(const int precision)
Sets the coordinate precision for grid annotations.
void setHeaderHAlignment(const HeaderHAlignment alignment)
Sets the horizontal alignment for table headers.
void setFrameJoinStyle(const Qt::PenJoinStyle style)
Sets the join style used when drawing the item's frame.
MarkerMode
The MarkerMode enum is the old QGIS 2.x arrow marker mode.
QgsLayoutTableColumns mColumns
Columns to show in table.
static QList< QgsLayoutObject * > addItemsFromCompositionXml(QgsPrintLayout *layout, const QDomElement &parentElement, QPointF *position=nullptr, bool pasteInPlace=false)
addItemsFromCompositionXml parse a QGIS 2.x composition XML in the parentElement, converts the 2...
double length() const
Returns the length of the measurement.
void setAnnotationPosition(const AnnotationPosition position, const BorderSide side)
Sets the position for the grid annotations on a specified side of the map frame.
void setMapRotation(double rotation)
Sets the rotation for the map - this does not affect the layout item shape, only the way the map is d...
void setLinkedMap(QgsLayoutItemMap *map)
Sets the map to associate with the legend.
bool readXml(const QDomElement &styleElem)
Reads the style's properties from XML.
void setSymbol(QgsFillSymbol *symbol)
Sets the fill symbol used to draw the shape.
NorthMode
Method for syncing rotation to a map's North direction.
Dummy property with no effect on item.
void setHeaderMode(const HeaderMode mode)
Sets the display mode for headers in the table.
void setDrawAnnotations(bool draw)
Sets whether annotations are drawn within the map.
void setCrossLength(const double length)
Sets the length (in layout units) of the cross segments drawn for the grid.
Property requires a string value.
void setAnnotationFormat(const AnnotationFormat format)
Sets the format for drawing grid annotations.
Qt::PenJoinStyle frameJoinStyle() const
Returns the join style used for drawing the item's frame.
QgsCoordinateReferenceSystem crs() const
Returns coordinate reference system used for rendering the map.
void setUnits(QgsUnitTypes::DistanceUnit units)
Sets the distance units used by the scalebar.
DataDefinedProperty
Composition data defined properties for different item types.
void setFont(const QFont &font)
Sets the label's current font.
static QgsLayerTree * readXml(QDomElement &element, const QgsReadWriteContext &context)
Load the layer tree from an XML element.
void updateBoundingRect()
Updates the bounding rect of this item. Call this function before doing any changes related to annota...
void setEnabled(bool enabled)
Sets whether the atlas is enabled.
virtual void attemptMove(const QgsLayoutPoint &point, bool useReferencePoint=true, bool includesFrame=false, int page=-1)
Attempts to move the item to a specified point.
ResizeMode
Controls how pictures are scaled within the item's frame.
virtual QString uuid() const
Returns the item identification string.
This class represents a coordinate reference system (CRS).
void addLayoutItem(QgsLayoutItem *item)
Adds an item to the layout.
void refreshFrame(bool updateItem=true)
Refresh item's frame, considering data defined colors and frame size.
static QgsLayoutItemPage * create(QgsLayout *layout)
Returns a new page item for the specified layout.
virtual void setFrameEnabled(bool drawFrame)
Sets whether this item has a frame drawn around it or not.
void setMaxBreakDistance(double distance)
Sets the maximum distance allowed when calculating where to place page breaks in the html...
void loadHtml(const bool useCache=false, const QgsExpressionContext *context=nullptr)
Reloads the html source from the url and redraws the item.
QgsProject * project() const
The project associated with the layout.
bool readXml(const QDomNode &node)
Restores state from the given DOM node.
void setRasterStrokeWidth(double width)
Sets the stroke width for the stroke drawn around raster symbol items.
A layout item subclass for scale bars.
A base class for objects which belong to a layout.
void setNumberOfSegmentsLeft(int segments)
Sets the number of segments included in the left part of the scalebar.
void setBackgroundColor(const QColor &color)
Sets the color used for background of table.
A grouped map of multiple QgsProperty objects, each referenced by a integer key value.
void setWmsLegendHeight(double height)
Sets the WMS legend height.
void setWmsLegendWidth(double width)
Sets the WMS legend width.
void setAnnotationFrameDistance(const double distance)
Sets the distance between the map frame and annotations.
void setIntervalX(double interval)
Sets the interval between grid lines in the x-direction.
void setPageSize(const QgsLayoutSize &size)
Sets the size of the page.
GridStyle
Grid drawing style.
Print layout, a QgsLayout subclass for static or atlas-based layouts.
A layout item subclass for map legends.
virtual void addFrame(QgsLayoutFrame *frame, bool recalcFrameSizes=true)
Adds a frame to the multiframe.
void setSortFeatures(bool enabled)
Sets whether features should be sorted in the atlas.
Page number for item placement.
void setSymbolHeight(double height)
Sets the legend symbol height.
Resolves relative paths into absolute paths and vice versa.
This class provides a method of storing sizes, consisting of a width and height, for use in QGIS layo...
void setStyle(const GridStyle style)
Sets the grid style, which controls how the grid is drawn over the map's contents.
void setBoxSpace(double space)
Sets the legend box space.
void setEnabled(bool enabled)
Controls whether the item will be drawn.
void setPageNameExpression(const QString &expression)
Sets the expression (or field name) used for calculating the page name.
double height() const
Returns the height of the size.
QgsLayoutItemGroup * parentGroup() const
Returns the item's parent group, if the item is part of a QgsLayoutItemGroup group.
Base class for frame items, which form a layout multiframe item.
void setUnitsPerSegment(double units)
Sets the number of scalebar units per segment.
A layout multiframe subclass for HTML content.
void setTitleAlignment(Qt::AlignmentFlag alignment)
Sets the alignment of the legend title.
bool sortFeatures() const
Returns true if features should be sorted in the atlas.
Layer and style map theme.
void setGridColor(const QColor &color)
Sets the color used for grid lines in the table.
void setText(const QString &text)
Sets the label's preset text.
void setItemOpacity(double opacity)
Sets the item's opacity.
QgsProperty property(int key) const override
Returns a matching property from the collection, if one exists.
void setCornerRadius(QgsLayoutMeasurement radius)
Sets the corner radius for rounded rectangle corners.
static QColor decodeColor(const QString &str)
Item representing the paper in a layout.
void setColor(const QColor &color)
void setLabelBarSpace(double space)
Sets the spacing (in millimeters) between labels and the scalebar.