63void QgsCompositionConverter::initPropertyDefinitions()
65 if ( !sPropertyDefinitions.isEmpty() )
73 "|<b>B5</b>|<b>B4</b>|<b>B3</b>|<b>B2</b>|<b>B1</b>|<b>B0</b>"
74 "|<b>Legal</b>|<b>Ansi A</b>|<b>Ansi B</b>|<b>Ansi C</b>|<b>Ansi D</b>|<b>Ansi E</b>"
75 "|<b>Arch A</b>|<b>Arch B</b>|<b>Arch C</b>|<b>Arch D</b>|<b>Arch E</b>|<b>Arch E1</b>]"
119 QgsCompositionConverter::initPropertyDefinitions();
120 return sPropertyDefinitions;
126 initPropertyDefinitions();
128 const QDomElement parentElement = composerElement.parentNode().toElement();
130 std::unique_ptr< QgsPrintLayout > layout = std::make_unique< QgsPrintLayout >( project );
131 layout->undoStack()->blockCommands(
true );
133 layout->mCustomProperties.readXml( composerElement );
136 layout->guides().setVisible( composerElement.attribute( QStringLiteral(
"guidesVisible" ), QStringLiteral(
"1" ) ).toInt() != 0 );
138 const int printResolution = composerElement.attribute( QStringLiteral(
"printResolution" ), QStringLiteral(
"300" ) ).toInt();
139 layout->renderContext().setDpi( printResolution );
142 const int pages = composerElement.attribute( QStringLiteral(
"numPages" ) ).toInt( );
143 const float paperHeight = composerElement.attribute( QStringLiteral(
"paperHeight" ) ).toDouble( );
144 const float paperWidth = composerElement.attribute( QStringLiteral(
"paperWidth" ) ).toDouble( );
146 QString name = composerElement.attribute( QStringLiteral(
"name" ) );
148 if ( name.isEmpty() )
149 name = composerElement.attribute( QStringLiteral(
"title" ) );
151 if ( name.isEmpty() )
152 name = parentElement.attribute( QStringLiteral(
"title" ) );
153 layout->setName( name );
155 for (
int j = 0; j < pages; j++ )
159 layout->pageCollection()->addPage( page );
161 const QDomNodeList snapLineNodes = composerElement.elementsByTagName( QStringLiteral(
"SnapLine" ) );
162 for (
int i = 0; i < snapLineNodes.size(); ++i )
164 const QDomElement snapLineElem = snapLineNodes.at( i ).toElement();
165 const double x1 = snapLineElem.attribute( QStringLiteral(
"x1" ) ).toDouble();
166 const double y1 = snapLineElem.attribute( QStringLiteral(
"y1" ) ).toDouble();
167 const double x2 = snapLineElem.attribute( QStringLiteral(
"x2" ) ).toDouble();
169 const Qt::Orientation orientation( x1 == x2 ? Qt::Orientation::Vertical : Qt::Orientation::Horizontal );
171 std::unique_ptr< QgsLayoutGuide > guide = std::make_unique< QgsLayoutGuide >( orientation, position, page );
172 layout->guides().addGuide( guide.release() );
177 if ( composerElement.elementsByTagName( QStringLiteral(
"symbol" ) ).size() )
179 const QDomElement symbolElement = composerElement.elementsByTagName( QStringLiteral(
"symbol" ) ).at( 0 ).toElement();
183 const std::unique_ptr< QgsFillSymbol > symbol( QgsSymbolLayerUtils::loadSymbol<QgsFillSymbol>( symbolElement, context ) );
185 layout->pageCollection()->setPageStyleSymbol( symbol.get() );
191 if ( parentElement.elementsByTagName( QStringLiteral(
"Atlas" ) ).size() )
193 const QDomElement atlasElement = parentElement.elementsByTagName( QStringLiteral(
"Atlas" ) ).at( 0 ).toElement();
194 readAtlasXml( layout->atlas(), atlasElement, layout->project() );
198 layout->undoStack()->blockCommands(
false );
203void QgsCompositionConverter::adjustPos(
QgsPrintLayout *layout,
QgsLayoutItem *layoutItem, QPointF *position,
bool &pasteInPlace,
int zOrderOffset, QPointF &pasteShiftPos,
int &pageNumber )
213 layoutItem->
attemptMoveBy( pasteShiftPos.x(), pasteShiftPos.y() );
217 if ( !layoutItem->scene() )
219 layoutItem->setZValue( layoutItem->zValue() + zOrderOffset );
222void QgsCompositionConverter::restoreGeneralComposeItemProperties(
QgsLayoutItem *layoutItem,
const QDomElement &itemElem )
225 const QDomNodeList composerItemList = itemElem.elementsByTagName( QStringLiteral(
"ComposerItem" ) );
226 if ( !composerItemList.isEmpty() )
228 const QDomElement composerItemElem = composerItemList.at( 0 ).toElement();
231 if ( !
qgsDoubleNear( composerItemElem.attribute( QStringLiteral(
"rotation" ), QStringLiteral(
"0" ) ).toDouble(), 0.0 ) )
234 layoutItem->
setItemRotation( composerItemElem.attribute( QStringLiteral(
"rotation" ), QStringLiteral(
"0" ) ).toDouble(),
false );
236 QgsCompositionConverter::readXml( layoutItem, composerItemElem );
240QRectF QgsCompositionConverter::itemPosition(
QgsLayoutItem *layoutItem,
const QDomElement &itemElem )
243 double x, y, pagex, pagey, width, height;
244 bool xOk, yOk, pageOk, pagexOk, pageyOk, widthOk, heightOk, positionModeOk;
246 x = itemElem.attribute( QStringLiteral(
"x" ) ).toDouble( &xOk );
247 y = itemElem.attribute( QStringLiteral(
"y" ) ).toDouble( &yOk );
248 page = itemElem.attribute( QStringLiteral(
"page" ) ).toInt( &pageOk );
249 pagex = itemElem.attribute( QStringLiteral(
"pagex" ) ).toDouble( &pagexOk );
250 pagey = itemElem.attribute( QStringLiteral(
"pagey" ) ).toDouble( &pageyOk );
251 width = itemElem.attribute( QStringLiteral(
"width" ) ).toDouble( &widthOk );
252 height = itemElem.attribute( QStringLiteral(
"height" ) ).toDouble( &heightOk );
255 layoutItem->mReferencePoint =
static_cast< QgsLayoutItem::ReferencePoint >( itemElem.attribute( QStringLiteral(
"positionMode" ) ).toInt( &positionModeOk ) );
256 if ( !positionModeOk )
261 if ( pageOk && pagexOk && pageyOk )
280 return QRectF( x, y, width, height );
283QPointF QgsCompositionConverter::minPointFromXml(
const QDomElement &elem )
285 double minX = std::numeric_limits<double>::max();
286 double minY = std::numeric_limits<double>::max();
287 const QDomNodeList composerItemList = elem.elementsByTagName( QStringLiteral(
"ComposerItem" ) );
288 for (
int i = 0; i < composerItemList.size(); ++i )
290 const QDomElement currentComposerItemElem = composerItemList.at( i ).toElement();
293 x = currentComposerItemElem.attribute( QStringLiteral(
"x" ) ).toDouble( &xOk );
294 y = currentComposerItemElem.attribute( QStringLiteral(
"y" ) ).toDouble( &yOk );
299 minX = std::min( minX, x );
300 minY = std::min( minY, y );
302 if ( minX < std::numeric_limits<double>::max() )
304 return QPointF( minX, minY );
308 return QPointF( 0, 0 );
315 initPropertyDefinitions();
317 QList< QgsLayoutObject * > newItems;
322 const int zOrderOffset = layout->mItemsModel->zOrderListSize();
324 QPointF pasteShiftPos;
331 const QPointF minItemPos = minPointFromXml( parentElement );
334 pasteShiftPos = *position - minItemPos;
337 pageNumber = layout->mPageCollection->pageNumberForPoint( *position );
344 for (
int i = 0; i < parentElement.elementsByTagName( QStringLiteral(
"ComposerMap" ) ).size(); i++ )
346 const QDomNode itemNode( parentElement.elementsByTagName( QStringLiteral(
"ComposerMap" ) ).at( i ) );
348 readMapXml( layoutItem, itemNode.toElement(), layout->
project(), mapIdUiidMap );
349 adjustPos( layout, layoutItem, position, pasteInPlace, zOrderOffset, pasteShiftPos, pageNumber );
350 newItems << layoutItem ;
354 for (
int i = 0; i < parentElement.elementsByTagName( QStringLiteral(
"ComposerLabel" ) ).size(); i++ )
356 const QDomNode itemNode( parentElement.elementsByTagName( QStringLiteral(
"ComposerLabel" ) ).at( i ) );
358 readLabelXml( layoutItem, itemNode.toElement(), layout->
project() );
359 adjustPos( layout, layoutItem, position, pasteInPlace, zOrderOffset, pasteShiftPos, pageNumber );
360 newItems << layoutItem ;
364 for (
int i = 0; i < parentElement.elementsByTagName( QStringLiteral(
"ComposerShape" ) ).size(); i++ )
366 const QDomNode itemNode( parentElement.elementsByTagName( QStringLiteral(
"ComposerShape" ) ).at( i ) );
368 readShapeXml( layoutItem, itemNode.toElement(), layout->
project() );
369 adjustPos( layout, layoutItem, position, pasteInPlace, zOrderOffset, pasteShiftPos, pageNumber );
370 newItems << layoutItem ;
374 for (
int i = 0; i < parentElement.elementsByTagName( QStringLiteral(
"ComposerPicture" ) ).size(); i++ )
376 const QDomNode itemNode( parentElement.elementsByTagName( QStringLiteral(
"ComposerPicture" ) ).at( i ) );
378 readPictureXml( layoutItem, itemNode.toElement(), layout->
project(), mapIdUiidMap );
379 adjustPos( layout, layoutItem, position, pasteInPlace, zOrderOffset, pasteShiftPos, pageNumber );
380 newItems << layoutItem ;
384 for (
int i = 0; i < parentElement.elementsByTagName( QStringLiteral(
"ComposerPolygon" ) ).size(); i++ )
386 const QDomNode itemNode( parentElement.elementsByTagName( QStringLiteral(
"ComposerPolygon" ) ).at( i ) );
388 readPolyXml<QgsLayoutItemPolygon, QgsFillSymbol>( layoutItem, itemNode.toElement(), layout->
project() );
389 adjustPos( layout, layoutItem, position, pasteInPlace, zOrderOffset, pasteShiftPos, pageNumber );
390 newItems << layoutItem ;
394 for (
int i = 0; i < parentElement.elementsByTagName( QStringLiteral(
"ComposerPolyline" ) ).size(); i++ )
396 const QDomNode itemNode( parentElement.elementsByTagName( QStringLiteral(
"ComposerPolyline" ) ).at( i ) );
398 readPolyXml<QgsLayoutItemPolyline, QgsLineSymbol>( layoutItem, itemNode.toElement(), layout->
project() );
399 adjustPos( layout, layoutItem, position, pasteInPlace, zOrderOffset, pasteShiftPos, pageNumber );
400 newItems << layoutItem ;
404 for (
int i = 0; i < parentElement.elementsByTagName( QStringLiteral(
"ComposerArrow" ) ).size(); i++ )
406 const QDomNode itemNode( parentElement.elementsByTagName( QStringLiteral(
"ComposerArrow" ) ).at( i ) );
408 readArrowXml( layoutItem, itemNode.toElement(), layout->
project() );
409 adjustPos( layout, layoutItem, position, pasteInPlace, zOrderOffset, pasteShiftPos, pageNumber );
410 newItems << layoutItem ;
414 for (
int i = 0; i < parentElement.elementsByTagName( QStringLiteral(
"ComposerScaleBar" ) ).size(); i++ )
416 const QDomNode itemNode( parentElement.elementsByTagName( QStringLiteral(
"ComposerScaleBar" ) ).at( i ) );
418 readScaleBarXml( layoutItem, itemNode.toElement(), layout->
project(), mapIdUiidMap );
419 adjustPos( layout, layoutItem, position, pasteInPlace, zOrderOffset, pasteShiftPos, pageNumber );
420 newItems << layoutItem ;
424 for (
int i = 0; i < parentElement.elementsByTagName( QStringLiteral(
"ComposerLegend" ) ).size(); i++ )
426 const QDomNode itemNode( parentElement.elementsByTagName( QStringLiteral(
"ComposerLegend" ) ).at( i ) );
428 readLegendXml( layoutItem, itemNode.toElement(), layout->
project(), mapIdUiidMap );
429 adjustPos( layout, layoutItem, position, pasteInPlace, zOrderOffset, pasteShiftPos, pageNumber );
430 newItems << layoutItem ;
434 for (
int i = 0; i < parentElement.elementsByTagName( QStringLiteral(
"ComposerHtml" ) ).size(); i++ )
436 const QDomNode itemNode( parentElement.elementsByTagName( QStringLiteral(
"ComposerHtml" ) ).at( i ) );
438 readHtmlXml( layoutItem, itemNode.toElement(), layout->
project() );
440 const QList<QgsLayoutFrame *> framesList( layoutItem->
frames() );
441 for (
const auto &frame : framesList )
443 adjustPos( layout, frame, position, pasteInPlace, zOrderOffset, pasteShiftPos, pageNumber );
445 newItems << layoutItem ;
449 for (
int i = 0; i < parentElement.elementsByTagName( QStringLiteral(
"ComposerAttributeTableV2" ) ).size(); i++ )
451 const QDomNode itemNode( parentElement.elementsByTagName( QStringLiteral(
"ComposerAttributeTableV2" ) ).at( i ) );
453 readTableXml( layoutItem, itemNode.toElement(), layout->
project() );
455 const QList<QgsLayoutFrame *> framesList( layoutItem->
frames() );
456 for (
const auto &frame : framesList )
458 adjustPos( layout, frame, position, pasteInPlace, zOrderOffset, pasteShiftPos, pageNumber );
460 newItems << layoutItem ;
464 for (
int i = 0; i < parentElement.elementsByTagName( QStringLiteral(
"ComposerItemGroup" ) ).size(); i++ )
466 const QDomNode itemNode( parentElement.elementsByTagName( QStringLiteral(
"ComposerItemGroup" ) ).at( i ) );
468 readGroupXml( layoutItem, itemNode.toElement(), layout->
project(), newItems );
469 adjustPos( layout, layoutItem, position, pasteInPlace, zOrderOffset, pasteShiftPos, pageNumber );
470 newItems << layoutItem ;
478 return document.elementsByTagName( QStringLiteral(
"Composition" ) ).count() > 0;
487 if ( document.elementsByTagName( QStringLiteral(
"Composition" ) ).count( ) > 0 )
489 const QDomElement composerElem = document.elementsByTagName( QStringLiteral(
"Composition" ) ).at( 0 ).toElement( );
493 const QDomElement elem = layout->writeXml( doc, context );
494 doc.appendChild( elem );
502 if ( itemElem.isNull() )
507 restoreGeneralComposeItemProperties( layoutItem, itemElem );
510 layoutItem->
setText( itemElem.attribute( QStringLiteral(
"labelText" ) ) );
513 layoutItem->
setMode( itemElem.attribute( QStringLiteral(
"htmlState" ) ).toInt() == Qt::Checked ? QgsLayoutItemLabel::Mode::ModeHtml : QgsLayoutItemLabel::Mode::ModeFont );
516 bool marginXOk =
false;
517 bool marginYOk =
false;
518 double marginX = itemElem.attribute( QStringLiteral(
"marginX" ) ).toDouble( &marginXOk );
519 double marginY = itemElem.attribute( QStringLiteral(
"marginY" ) ).toDouble( &marginYOk );
520 if ( !marginXOk || !marginYOk )
523 const double margin = itemElem.attribute( QStringLiteral(
"margin" ), QStringLiteral(
"1.0" ) ).toDouble();
531 layoutItem->
setHAlign(
static_cast< Qt::AlignmentFlag
>( itemElem.attribute( QStringLiteral(
"halign" ) ).toInt() ) );
534 layoutItem->
setVAlign(
static_cast< Qt::AlignmentFlag
>( itemElem.attribute( QStringLiteral(
"valign" ) ).toInt() ) );
542 if ( font.pointSizeF() > 0 )
544 format.
setSize( font.pointSizeF() );
547 else if ( font.pixelSize() > 0 )
549 format.
setSize( font.pixelSize() );
554 const QDomNodeList fontColorList = itemElem.elementsByTagName( QStringLiteral(
"FontColor" ) );
555 if ( !fontColorList.isEmpty() )
557 const QDomElement fontColorElem = fontColorList.at( 0 ).toElement();
558 const int red = fontColorElem.attribute( QStringLiteral(
"red" ), QStringLiteral(
"0" ) ).toInt();
559 const int green = fontColorElem.attribute( QStringLiteral(
"green" ), QStringLiteral(
"0" ) ).toInt();
560 const int blue = fontColorElem.attribute( QStringLiteral(
"blue" ), QStringLiteral(
"0" ) ).toInt();
561 format.
setColor( QColor( red, green, blue ) );
565 format.
setColor( QColor( 0, 0, 0 ) );
578 restoreGeneralComposeItemProperties( layoutItem, itemElem );
584 if ( itemElem.elementsByTagName( QStringLiteral(
"symbol" ) ).size() )
586 const QDomElement symbolElement = itemElem.elementsByTagName( QStringLiteral(
"symbol" ) ).at( 0 ).toElement();
587 const std::unique_ptr< QgsFillSymbol > shapeStyleSymbol( QgsSymbolLayerUtils::loadSymbol<QgsFillSymbol>( symbolElement, context ) );
588 if ( shapeStyleSymbol )
589 layoutItem->
setSymbol( shapeStyleSymbol.get() );
594 QVariantMap properties;
598 properties.insert( QStringLiteral(
"style" ), QStringLiteral(
"solid" ) );
602 properties.insert( QStringLiteral(
"style" ), QStringLiteral(
"no" ) );
606 properties.insert( QStringLiteral(
"style_border" ), QStringLiteral(
"solid" ) );
610 properties.insert( QStringLiteral(
"style_border" ), QStringLiteral(
"no" ) );
613 properties.insert( QStringLiteral(
"width_border" ), QString::number( layoutItem->pen().widthF() ) );
616 const QDomNodeList outlineColorList = itemElem.elementsByTagName( QStringLiteral(
"OutlineColor" ) );
617 if ( !outlineColorList.isEmpty() )
619 const QDomElement frameColorElem = outlineColorList.at( 0 ).toElement();
620 bool redOk, greenOk, blueOk, alphaOk, widthOk;
621 int penRed, penGreen, penBlue, penAlpha;
624 penWidth = itemElem.attribute( QStringLiteral(
"outlineWidth" ) ).toDouble( &widthOk );
625 penRed = frameColorElem.attribute( QStringLiteral(
"red" ) ).toInt( &redOk );
626 penGreen = frameColorElem.attribute( QStringLiteral(
"green" ) ).toInt( &greenOk );
627 penBlue = frameColorElem.attribute( QStringLiteral(
"blue" ) ).toInt( &blueOk );
628 penAlpha = frameColorElem.attribute( QStringLiteral(
"alpha" ) ).toInt( &alphaOk );
630 if ( redOk && greenOk && blueOk && alphaOk && widthOk )
633 properties.insert( QStringLiteral(
"width_border" ), QString::number( penWidth ) );
636 const QDomNodeList fillColorList = itemElem.elementsByTagName( QStringLiteral(
"FillColor" ) );
637 if ( !fillColorList.isEmpty() )
639 const QDomElement fillColorElem = fillColorList.at( 0 ).toElement();
640 bool redOk, greenOk, blueOk, alphaOk;
641 int fillRed, fillGreen, fillBlue, fillAlpha;
643 fillRed = fillColorElem.attribute( QStringLiteral(
"red" ) ).toInt( &redOk );
644 fillGreen = fillColorElem.attribute( QStringLiteral(
"green" ) ).toInt( &greenOk );
645 fillBlue = fillColorElem.attribute( QStringLiteral(
"blue" ) ).toInt( &blueOk );
646 fillAlpha = fillColorElem.attribute( QStringLiteral(
"alpha" ) ).toInt( &alphaOk );
648 if ( redOk && greenOk && blueOk && alphaOk )
651 properties.insert( QStringLiteral(
"style" ), QStringLiteral(
"solid" ) );
654 if ( itemElem.hasAttribute( QStringLiteral(
"transparentFill" ) ) )
657 const bool hasOldTransparentFill = itemElem.attribute( QStringLiteral(
"transparentFill" ), QStringLiteral(
"0" ) ).toInt();
658 if ( hasOldTransparentFill )
660 properties.insert( QStringLiteral(
"style" ), QStringLiteral(
"no" ) );
665 layoutItem->
setSymbol( shapeStyleSymbol.get() );
676 restoreGeneralComposeItemProperties( layoutItem, itemElem );
680 bool positionModeOk =
false;
681 layoutItem->mReferencePoint =
static_cast< QgsLayoutItem::ReferencePoint >( itemElem.attribute( QStringLiteral(
"positionMode" ) ).toInt( &positionModeOk ) );
682 if ( !positionModeOk )
684 layoutItem->mReferencePoint = QgsLayoutItem::ReferencePoint::UpperLeft;
686 bool anchorPointOk =
false;
689 if ( !anchorPointOk )
691 layoutItem->mPictureAnchor = QgsLayoutItem::ReferencePoint::UpperLeft;
695 layoutItem->mSvgStrokeWidth = itemElem.attribute( QStringLiteral(
"svgBorderWidth" ), QStringLiteral(
"0.2" ) ).toDouble();
697 QString imagePath = itemElem.attribute( QStringLiteral(
"file" ) );
702 if ( imagePath.endsWith( QLatin1String(
".svg" ), Qt::CaseInsensitive ) )
705 imagePath = pathResolver.
readPath( imagePath );
708 layoutItem->mPictureHeight = itemElem.attribute( QStringLiteral(
"pictureHeight" ), QStringLiteral(
"10" ) ).toDouble();
709 layoutItem->mPictureWidth = itemElem.attribute( QStringLiteral(
"pictureWidth" ), QStringLiteral(
"10" ) ).toDouble();
712 if ( !
qgsDoubleNear( itemElem.attribute( QStringLiteral(
"pictureRotation" ), QStringLiteral(
"0" ) ).toDouble(), 0.0 ) )
714 layoutItem->mPictureRotation = itemElem.attribute( QStringLiteral(
"pictureRotation" ), QStringLiteral(
"0" ) ).toDouble();
719 layoutItem->mNorthArrowHandler->
setNorthOffset( itemElem.attribute( QStringLiteral(
"northOffset" ), QStringLiteral(
"0" ) ).toDouble() );
721 const QString rotationMapId = itemElem.attribute( QStringLiteral(
"mapId" ), QStringLiteral(
"-1" ) );
722 if ( rotationMapId != QLatin1String(
"-1" ) )
736 readPolyXml<QgsLayoutItemPolyline, QgsLineSymbol>( layoutItem, itemElem, project );
738 const QDomNodeList startPointList = itemElem.elementsByTagName( QStringLiteral(
"StartPoint" ) );
739 if ( ! startPointList.isEmpty() )
741 const QDomElement node = startPointList.at( 0 ).toElement();
742 polygon.append( QPointF( node.attribute( QStringLiteral(
"x" ) ).toDouble( ), node.attribute( QStringLiteral(
"y" ) ).toDouble() ) );
744 const QDomNodeList stopPointList = itemElem.elementsByTagName( QStringLiteral(
"StopPoint" ) );
745 if ( ! stopPointList.isEmpty() )
747 const QDomElement node = stopPointList.at( 0 ).toElement();
748 polygon.append( QPointF( node.attribute( QStringLiteral(
"x" ) ).toDouble( ), node.attribute( QStringLiteral(
"y" ) ).toDouble() ) );
753 if ( markerMode == QgsCompositionConverter::MarkerMode::DefaultMarker )
755 layoutItem->
setEndMarker( QgsLayoutItemPolyline::MarkerMode::ArrowHead );
756 layoutItem->
setStartMarker( QgsLayoutItemPolyline::MarkerMode::NoMarker );
759 layoutItem->
setArrowHeadStrokeWidth( itemElem.attribute( QStringLiteral(
"outlineWidth" ), QStringLiteral(
"1.0" ) ).toDouble( ) );
760 layoutItem->
setArrowHeadWidth( itemElem.attribute( QStringLiteral(
"arrowHeadWidth" ), QStringLiteral(
"1.0" ) ).toDouble( ) );
762 else if ( markerMode == QgsCompositionConverter::MarkerMode::SVGMarker )
764 QString endMarkerFile = itemElem.attribute( QStringLiteral(
"endMarkerFile" ) );
765 QString startMarkerFile = itemElem.attribute( QStringLiteral(
"endMarkerFile" ) );
772 if ( !endMarkerFile.isEmpty() )
774 if ( endMarkerFile.endsWith( QLatin1String(
".svg" ), Qt::CaseInsensitive ) )
777 endMarkerFile = pathResolver.
readPath( endMarkerFile );
779 if ( !startMarkerFile.isEmpty() )
781 if ( startMarkerFile.endsWith( QLatin1String(
".svg" ), Qt::CaseInsensitive ) )
784 startMarkerFile = pathResolver.
readPath( startMarkerFile );
787 if ( !endMarkerFile.isEmpty() )
789 layoutItem->
setEndMarker( QgsLayoutItemPolyline::MarkerMode::SvgMarker );
792 if ( !startMarkerFile.isEmpty() )
794 layoutItem->
setStartMarker( QgsLayoutItemPolyline::MarkerMode::SvgMarker );
800 layoutItem->
setEndMarker( QgsLayoutItemPolyline::MarkerMode::NoMarker );
801 layoutItem->
setStartMarker( QgsLayoutItemPolyline::MarkerMode::NoMarker );
804 const double margin = polygon.boundingRect().left() - layoutItem->pos().x();
805 polygon.translate( - polygon.boundingRect().left() + margin, - polygon.boundingRect().top() + margin );
813 restoreGeneralComposeItemProperties( layoutItem, itemElem );
815 mapId2Uuid[ itemElem.attribute( QStringLiteral(
"id" ) ) ] = layoutItem->
uuid();
818 const QDomDocument doc;
826 const QDomNodeList extentNodeList = itemElem.elementsByTagName( QStringLiteral(
"Extent" ) );
827 if ( !extentNodeList.isEmpty() )
829 const QDomElement extentElem = extentNodeList.at( 0 ).toElement();
830 double xmin, xmax, ymin, ymax;
831 xmin = extentElem.attribute( QStringLiteral(
"xmin" ) ).toDouble();
832 xmax = extentElem.attribute( QStringLiteral(
"xmax" ) ).toDouble();
833 ymin = extentElem.attribute( QStringLiteral(
"ymin" ) ).toDouble();
834 ymax = extentElem.attribute( QStringLiteral(
"ymax" ) ).toDouble();
838 const QDomNodeList crsNodeList = itemElem.elementsByTagName( QStringLiteral(
"crs" ) );
839 if ( !crsNodeList.isEmpty() )
841 const QDomElement crsElem = crsNodeList.at( 0 ).toElement();
850 if ( !
qgsDoubleNear( itemElem.attribute( QStringLiteral(
"mapRotation" ), QStringLiteral(
"0" ) ).toDouble(), 0.0 ) )
852 layoutItem->
setMapRotation( itemElem.attribute( QStringLiteral(
"mapRotation" ), QStringLiteral(
"0" ) ).toDouble() );
856 layoutItem->
setFollowVisibilityPreset( itemElem.attribute( QStringLiteral(
"followPreset" ) ).compare( QLatin1String(
"true" ) ) == 0 );
860 const QString keepLayerSetFlag = itemElem.attribute( QStringLiteral(
"keepLayerSet" ) );
861 if ( keepLayerSetFlag.compare( QLatin1String(
"true" ), Qt::CaseInsensitive ) == 0 )
870 const QString drawCanvasItemsFlag = itemElem.attribute( QStringLiteral(
"drawCanvasItems" ), QStringLiteral(
"true" ) );
871 if ( drawCanvasItemsFlag.compare( QLatin1String(
"true" ), Qt::CaseInsensitive ) == 0 )
880 layoutItem->mLayerStyleOverrides.clear();
883 layoutItem->mLayers.clear();
885 const QDomNodeList layerSetNodeList = itemElem.elementsByTagName( QStringLiteral(
"LayerSet" ) );
886 if ( !layerSetNodeList.isEmpty() )
888 const QDomElement layerSetElem = layerSetNodeList.at( 0 ).toElement();
889 const QDomNodeList layerIdNodeList = layerSetElem.elementsByTagName( QStringLiteral(
"Layer" ) );
890 layoutItem->mLayers.reserve( layerIdNodeList.size() );
891 for (
int i = 0; i < layerIdNodeList.size(); ++i )
893 const QDomElement layerElem = layerIdNodeList.at( i ).toElement();
894 const QString layerId = layerElem.text();
895 const QString layerName = layerElem.attribute( QStringLiteral(
"name" ) );
896 const QString layerSource = layerElem.attribute( QStringLiteral(
"source" ) );
897 const QString layerProvider = layerElem.attribute( QStringLiteral(
"provider" ) );
899 QgsMapLayerRef ref( layerId, layerName, layerSource, layerProvider );
900 ref.resolveWeakly( project );
901 layoutItem->mLayers << ref;
906 const QDomNodeList layerStylesNodeList = itemElem.elementsByTagName( QStringLiteral(
"LayerStyles" ) );
907 layoutItem->mKeepLayerStyles = !layerStylesNodeList.isEmpty();
908 if ( layoutItem->mKeepLayerStyles )
910 const QDomElement layerStylesElem = layerStylesNodeList.at( 0 ).toElement();
911 const QDomNodeList layerStyleNodeList = layerStylesElem.elementsByTagName( QStringLiteral(
"LayerStyle" ) );
912 for (
int i = 0; i < layerStyleNodeList.size(); ++i )
914 const QDomElement &layerStyleElement = layerStyleNodeList.at( i ).toElement();
915 const QString layerId = layerStyleElement.attribute( QStringLiteral(
"layerid" ) );
916 const QString layerName = layerStyleElement.attribute( QStringLiteral(
"name" ) );
917 const QString layerSource = layerStyleElement.attribute( QStringLiteral(
"source" ) );
918 const QString layerProvider = layerStyleElement.attribute( QStringLiteral(
"provider" ) );
919 QgsMapLayerRef ref( layerId, layerName, layerSource, layerProvider );
920 ref.resolveWeakly( project );
923 style.
readXml( layerStyleElement );
924 layoutItem->mLayerStyleOverrides.insert( ref.layerId, style.
xmlData() );
928 layoutItem->mDrawing =
false;
929 layoutItem->mNumCachedLayers = 0;
930 layoutItem->mCacheInvalidated =
true;
934 const QDomNodeList mapOverviewNodeList = itemElem.elementsByTagName( QStringLiteral(
"ComposerMapOverview" ) );
935 for (
int i = 0; i < mapOverviewNodeList.size(); ++i )
937 const QDomElement mapOverviewElem = mapOverviewNodeList.at( i ).toElement();
938 std::unique_ptr<QgsLayoutItemMapOverview> mapOverview(
new QgsLayoutItemMapOverview( mapOverviewElem.attribute( QStringLiteral(
"name" ) ), layoutItem ) );
939 mapOverview->readXml( mapOverviewElem, doc, context );
940 const QString frameMapId = mapOverviewElem.attribute( QStringLiteral(
"frameMap" ), QStringLiteral(
"-1" ) );
941 if ( frameMapId != QLatin1String(
"-1" ) && mapId2Uuid.contains( frameMapId ) )
946 mapOverview->setLinkedMap( mapInstance );
948 layoutItem->mOverviewStack->addOverview( mapOverview.release() );
953 layoutItem->mGridStack->readXml( itemElem, doc, context );
958 const QDomNodeList gridNodeList = itemElem.elementsByTagName( QStringLiteral(
"Grid" ) );
959 if ( layoutItem->mGridStack->size() == 0 && !gridNodeList.isEmpty() )
961 const QDomElement gridElem = gridNodeList.at( 0 ).toElement();
963 mapGrid->
setEnabled( gridElem.attribute( QStringLiteral(
"show" ), QStringLiteral(
"0" ) ) != QLatin1String(
"0" ) );
965 mapGrid->
setIntervalX( gridElem.attribute( QStringLiteral(
"intervalX" ), QStringLiteral(
"0" ) ).toDouble() );
966 mapGrid->
setIntervalY( gridElem.attribute( QStringLiteral(
"intervalY" ), QStringLiteral(
"0" ) ).toDouble() );
967 mapGrid->
setOffsetX( gridElem.attribute( QStringLiteral(
"offsetX" ), QStringLiteral(
"0" ) ).toDouble() );
968 mapGrid->
setOffsetY( gridElem.attribute( QStringLiteral(
"offsetY" ), QStringLiteral(
"0" ) ).toDouble() );
969 mapGrid->
setCrossLength( gridElem.attribute( QStringLiteral(
"crossLength" ), QStringLiteral(
"3" ) ).toDouble() );
971 mapGrid->
setFrameWidth( gridElem.attribute( QStringLiteral(
"gridFrameWidth" ), QStringLiteral(
"2.0" ) ).toDouble() );
972 mapGrid->
setFramePenSize( gridElem.attribute( QStringLiteral(
"gridFramePenThickness" ), QStringLiteral(
"0.5" ) ).toDouble() );
977 const QDomElement gridSymbolElem = gridElem.firstChildElement( QStringLiteral(
"symbol" ) );
979 if ( gridSymbolElem.isNull() )
983 lineSymbol->
setWidth( gridElem.attribute( QStringLiteral(
"penWidth" ), QStringLiteral(
"0" ) ).toDouble() );
984 lineSymbol->
setColor( QColor( gridElem.attribute( QStringLiteral(
"penColorRed" ), QStringLiteral(
"0" ) ).toInt(),
985 gridElem.attribute( QStringLiteral(
"penColorGreen" ), QStringLiteral(
"0" ) ).toInt(),
986 gridElem.attribute( QStringLiteral(
"penColorBlue" ), QStringLiteral(
"0" ) ).toInt() ) );
990 lineSymbol = QgsSymbolLayerUtils::loadSymbol<QgsLineSymbol>( gridSymbolElem, context );
995 const QDomNodeList annotationNodeList = gridElem.elementsByTagName( QStringLiteral(
"Annotation" ) );
996 if ( !annotationNodeList.isEmpty() )
998 const QDomElement annotationElem = annotationNodeList.at( 0 ).toElement();
999 mapGrid->
setAnnotationEnabled( annotationElem.attribute( QStringLiteral(
"show" ), QStringLiteral(
"0" ) ) != QLatin1String(
"0" ) );
1009 mapGrid->
setAnnotationFrameDistance( annotationElem.attribute( QStringLiteral(
"frameDistance" ), QStringLiteral(
"0" ) ).toDouble() );
1010 QFont annotationFont;
1011 annotationFont.fromString( annotationElem.attribute( QStringLiteral(
"font" ), QString() ) );
1014 annotationFormat.
setFont( annotationFont );
1015 if ( annotationFont.pointSizeF() > 0 )
1017 annotationFormat.
setSize( annotationFont.pointSizeF() );
1020 else if ( annotationFont.pixelSize() > 0 )
1022 annotationFormat.
setSize( annotationFont.pixelSize() );
1028 mapGrid->
setAnnotationPrecision( annotationElem.attribute( QStringLiteral(
"precision" ), QStringLiteral(
"3" ) ).toInt() );
1030 layoutItem->mGridStack->addGrid( mapGrid );
1034 const QDomNodeList atlasNodeList = itemElem.elementsByTagName( QStringLiteral(
"AtlasMap" ) );
1035 if ( !atlasNodeList.isEmpty() )
1037 const QDomElement atlasElem = atlasNodeList.at( 0 ).toElement();
1038 layoutItem->mAtlasDriven = ( atlasElem.attribute( QStringLiteral(
"atlasDriven" ), QStringLiteral(
"0" ) ) != QLatin1String(
"0" ) );
1039 if ( atlasElem.hasAttribute( QStringLiteral(
"fixedScale" ) ) )
1041 layoutItem->
setAtlasScalingMode( atlasElem.attribute( QStringLiteral(
"fixedScale" ), QStringLiteral(
"0" ) ) != QLatin1String(
"0" ) ? QgsLayoutItemMap::AtlasScalingMode::Fixed : QgsLayoutItemMap::AtlasScalingMode::Auto );
1043 else if ( atlasElem.hasAttribute( QStringLiteral(
"scalingMode" ) ) )
1047 layoutItem->
setAtlasMargin( atlasElem.attribute( QStringLiteral(
"margin" ), QStringLiteral(
"0.1" ) ).toDouble() );
1058 restoreGeneralComposeItemProperties( layoutItem, itemElem );
1060 layoutItem->
setHeight( itemElem.attribute( QStringLiteral(
"height" ), QStringLiteral(
"5.0" ) ).toDouble() );
1061 layoutItem->
setHeight( itemElem.attribute( QStringLiteral(
"height" ), QStringLiteral(
"5.0" ) ).toDouble() );
1062 layoutItem->
setLabelBarSpace( itemElem.attribute( QStringLiteral(
"labelBarSpace" ), QStringLiteral(
"3.0" ) ).toDouble() );
1063 layoutItem->
setBoxContentSpace( itemElem.attribute( QStringLiteral(
"boxContentSpace" ), QStringLiteral(
"1.0" ) ).toDouble() );
1064 layoutItem->
setNumberOfSegments( itemElem.attribute( QStringLiteral(
"numSegments" ), QStringLiteral(
"2" ) ).toInt() );
1065 layoutItem->
setNumberOfSegmentsLeft( itemElem.attribute( QStringLiteral(
"numSegmentsLeft" ), QStringLiteral(
"0" ) ).toInt() );
1066 layoutItem->
setUnitsPerSegment( itemElem.attribute( QStringLiteral(
"numUnitsPerSegment" ), QStringLiteral(
"1.0" ) ).toDouble() );
1068 layoutItem->
setMinimumBarWidth( itemElem.attribute( QStringLiteral(
"minBarWidth" ), QStringLiteral(
"50" ) ).toDouble() );
1069 layoutItem->
setMaximumBarWidth( itemElem.attribute( QStringLiteral(
"maxBarWidth" ), QStringLiteral(
"150" ) ).toDouble() );
1070 layoutItem->mSegmentMillimeters = itemElem.attribute( QStringLiteral(
"segmentMillimeters" ), QStringLiteral(
"0.0" ) ).toDouble();
1071 layoutItem->
setMapUnitsPerScaleBarUnit( itemElem.attribute( QStringLiteral(
"numMapUnitsPerScaleBarUnit" ), QStringLiteral(
"1.0" ) ).toDouble() );
1072 layoutItem->
setUnitLabel( itemElem.attribute( QStringLiteral(
"unitLabel" ) ) );
1077 f.fromString( itemElem.attribute( QStringLiteral(
"font" ), QString() ) );
1085 const QDomNodeList fillColorList = itemElem.elementsByTagName( QStringLiteral(
"fillColor" ) );
1086 if ( !fillColorList.isEmpty() )
1088 const QDomElement fillColorElem = fillColorList.at( 0 ).toElement();
1089 bool redOk, greenOk, blueOk, alphaOk;
1090 int fillRed, fillGreen, fillBlue, fillAlpha;
1092 fillRed = fillColorElem.attribute( QStringLiteral(
"red" ) ).toDouble( &redOk );
1093 fillGreen = fillColorElem.attribute( QStringLiteral(
"green" ) ).toDouble( &greenOk );
1094 fillBlue = fillColorElem.attribute( QStringLiteral(
"blue" ) ).toDouble( &blueOk );
1095 fillAlpha = fillColorElem.attribute( QStringLiteral(
"alpha" ) ).toDouble( &alphaOk );
1097 if ( redOk && greenOk && blueOk && alphaOk )
1099 layoutItem->
fillSymbol()->
setColor( QColor( fillRed, fillGreen, fillBlue, fillAlpha ) );
1104 layoutItem->
fillSymbol()->
setColor( QColor( itemElem.attribute( QStringLiteral(
"brushColor" ), QStringLiteral(
"#000000" ) ) ) );
1108 const QDomNodeList fillColor2List = itemElem.elementsByTagName( QStringLiteral(
"fillColor2" ) );
1109 if ( !fillColor2List.isEmpty() )
1111 const QDomElement fillColor2Elem = fillColor2List.at( 0 ).toElement();
1112 bool redOk, greenOk, blueOk, alphaOk;
1113 int fillRed, fillGreen, fillBlue, fillAlpha;
1115 fillRed = fillColor2Elem.attribute( QStringLiteral(
"red" ) ).toDouble( &redOk );
1116 fillGreen = fillColor2Elem.attribute( QStringLiteral(
"green" ) ).toDouble( &greenOk );
1117 fillBlue = fillColor2Elem.attribute( QStringLiteral(
"blue" ) ).toDouble( &blueOk );
1118 fillAlpha = fillColor2Elem.attribute( QStringLiteral(
"alpha" ) ).toDouble( &alphaOk );
1120 if ( redOk && greenOk && blueOk && alphaOk )
1127 layoutItem->
alternateFillSymbol()->
setColor( QColor( itemElem.attribute( QStringLiteral(
"brush2Color" ), QStringLiteral(
"#ffffff" ) ) ) );
1130 std::unique_ptr< QgsLineSymbol > lineSymbol = std::make_unique< QgsLineSymbol >();
1131 std::unique_ptr< QgsSimpleLineSymbolLayer > lineSymbolLayer = std::make_unique< QgsSimpleLineSymbolLayer >();
1132 lineSymbolLayer->setWidth( itemElem.attribute( QStringLiteral(
"outlineWidth" ), QStringLiteral(
"0.3" ) ).toDouble() );
1137 const QDomNodeList strokeColorList = itemElem.elementsByTagName( QStringLiteral(
"strokeColor" ) );
1138 if ( !strokeColorList.isEmpty() )
1140 const QDomElement strokeColorElem = strokeColorList.at( 0 ).toElement();
1141 bool redOk, greenOk, blueOk, alphaOk;
1142 int strokeRed, strokeGreen, strokeBlue, strokeAlpha;
1144 strokeRed = strokeColorElem.attribute( QStringLiteral(
"red" ) ).toDouble( &redOk );
1145 strokeGreen = strokeColorElem.attribute( QStringLiteral(
"green" ) ).toDouble( &greenOk );
1146 strokeBlue = strokeColorElem.attribute( QStringLiteral(
"blue" ) ).toDouble( &blueOk );
1147 strokeAlpha = strokeColorElem.attribute( QStringLiteral(
"alpha" ) ).toDouble( &alphaOk );
1149 if ( redOk && greenOk && blueOk && alphaOk )
1151 lineSymbolLayer->setColor( QColor( strokeRed, strokeGreen, strokeBlue, strokeAlpha ) );
1156 lineSymbolLayer->setColor( QColor( itemElem.attribute( QStringLiteral(
"penColor" ), QStringLiteral(
"#000000" ) ) ) );
1158 lineSymbol->changeSymbolLayer( 0, lineSymbolLayer.release() );
1164 const QDomNodeList textColorList = itemElem.elementsByTagName( QStringLiteral(
"textColor" ) );
1165 if ( !textColorList.isEmpty() )
1167 const QDomElement textColorElem = textColorList.at( 0 ).toElement();
1168 bool redOk, greenOk, blueOk, alphaOk;
1169 int textRed, textGreen, textBlue, textAlpha;
1171 textRed = textColorElem.attribute( QStringLiteral(
"red" ) ).toDouble( &redOk );
1172 textGreen = textColorElem.attribute( QStringLiteral(
"green" ) ).toDouble( &greenOk );
1173 textBlue = textColorElem.attribute( QStringLiteral(
"blue" ) ).toDouble( &blueOk );
1174 textAlpha = textColorElem.attribute( QStringLiteral(
"alpha" ) ).toDouble( &alphaOk );
1176 if ( redOk && greenOk && blueOk && alphaOk )
1179 layoutItem->
setFontColor( QColor( textRed, textGreen, textBlue, textAlpha ) );
1186 c.setNamedColor( itemElem.attribute( QStringLiteral(
"fontColor" ), QStringLiteral(
"#000000" ) ) );
1193 const QString styleString = itemElem.attribute( QStringLiteral(
"style" ), QString() );
1194 layoutItem->
setStyle( QObject::tr( styleString.toLocal8Bit().data() ) );
1196 if ( itemElem.attribute( QStringLiteral(
"unitType" ) ).isEmpty() )
1199 switch ( itemElem.attribute( QStringLiteral(
"units" ) ).toInt() )
1223 const QString mapId = itemElem.attribute( QStringLiteral(
"mapId" ), QStringLiteral(
"-1" ) );
1224 if ( mapId != QLatin1String(
"-1" ) && mapId2Uuid.contains( mapId ) )
1238 restoreGeneralComposeItemProperties( layoutItem, itemElem );
1248 const QString mapId = itemElem.attribute( QStringLiteral(
"map" ), QStringLiteral(
"-1" ) );
1249 if ( mapId != QLatin1String(
"-1" ) && mapId2Uuid.contains( mapId ) )
1259 layoutItem->
setTitle( itemElem.attribute( QStringLiteral(
"title" ) ) );
1260 if ( !itemElem.attribute( QStringLiteral(
"titleAlignment" ) ).isEmpty() )
1262 layoutItem->
setTitleAlignment(
static_cast< Qt::AlignmentFlag
>( itemElem.attribute( QStringLiteral(
"titleAlignment" ) ).toInt() ) );
1264 int colCount = itemElem.attribute( QStringLiteral(
"columnCount" ), QStringLiteral(
"1" ) ).toInt();
1265 if ( colCount < 1 ) colCount = 1;
1267 layoutItem->
setSplitLayer( itemElem.attribute( QStringLiteral(
"splitLayer" ), QStringLiteral(
"0" ) ).toInt() == 1 );
1268 layoutItem->
setEqualColumnWidth( itemElem.attribute( QStringLiteral(
"equalColumnWidth" ), QStringLiteral(
"0" ) ).toInt() == 1 );
1270 const QDomNodeList stylesNodeList = itemElem.elementsByTagName( QStringLiteral(
"styles" ) );
1271 if ( !stylesNodeList.isEmpty() )
1273 const QDomNode stylesNode = stylesNodeList.at( 0 );
1274 for (
int i = 0; i < stylesNode.childNodes().size(); i++ )
1276 const QDomElement styleElem = stylesNode.childNodes().at( i ).toElement();
1278 style.
readXml( styleElem, QDomDocument() );
1279 const QString name = styleElem.attribute( QStringLiteral(
"name" ) );
1293 fontClr.setNamedColor( itemElem.attribute( QStringLiteral(
"fontColor" ), QStringLiteral(
"#000000" ) ) );
1300 layoutItem->
setBoxSpace( itemElem.attribute( QStringLiteral(
"boxSpace" ), QStringLiteral(
"2.0" ) ).toDouble() );
1301 layoutItem->
setColumnSpace( itemElem.attribute( QStringLiteral(
"columnSpace" ), QStringLiteral(
"2.0" ) ).toDouble() );
1303 layoutItem->
setSymbolWidth( itemElem.attribute( QStringLiteral(
"symbolWidth" ), QStringLiteral(
"7.0" ) ).toDouble() );
1304 layoutItem->
setSymbolHeight( itemElem.attribute( QStringLiteral(
"symbolHeight" ), QStringLiteral(
"14.0" ) ).toDouble() );
1305 layoutItem->
setWmsLegendWidth( itemElem.attribute( QStringLiteral(
"wmsLegendWidth" ), QStringLiteral(
"50" ) ).toDouble() );
1306 layoutItem->
setWmsLegendHeight( itemElem.attribute( QStringLiteral(
"wmsLegendHeight" ), QStringLiteral(
"25" ) ).toDouble() );
1308 layoutItem->
setLineSpacing( itemElem.attribute( QStringLiteral(
"lineSpacing" ), QStringLiteral(
"1.0" ) ).toDouble() );
1311 layoutItem->
setDrawRasterStroke( itemElem.attribute( QStringLiteral(
"rasterBorder" ), QStringLiteral(
"1" ) ) != QLatin1String(
"0" ) );
1313 layoutItem->
setRasterStrokeWidth( itemElem.attribute( QStringLiteral(
"rasterBorderWidth" ), QStringLiteral(
"0" ) ).toDouble() );
1315 layoutItem->
setWrapString( itemElem.attribute( QStringLiteral(
"wrapChar" ) ) );
1317 layoutItem->mSizeToContents = itemElem.attribute( QStringLiteral(
"resizeToContents" ), QStringLiteral(
"1" ) ) != QLatin1String(
"0" );
1318 layoutItem->mLegendFilterByMap = itemElem.attribute( QStringLiteral(
"legendFilterByMap" ), QStringLiteral(
"0" ) ).toInt();
1319 layoutItem->mFilterOutAtlas = itemElem.attribute( QStringLiteral(
"legendFilterByAtlas" ), QStringLiteral(
"0" ) ).toInt();
1322 QDomElement layerTreeElem = itemElem.firstChildElement( QStringLiteral(
"layer-tree" ) );
1323 if ( layerTreeElem.isNull() )
1324 layerTreeElem = itemElem.firstChildElement( QStringLiteral(
"layer-tree-group" ) );
1326 if ( !layerTreeElem.isNull() )
1330 tree->resolveReferences( project,
true );
1331 layoutItem->setCustomLayerTree( tree );
1335 layoutItem->setCustomLayerTree(
nullptr );
1341bool QgsCompositionConverter::readAtlasXml(
QgsLayoutAtlas *atlasItem,
const QDomElement &itemElem,
const QgsProject *project )
1343 atlasItem->
setEnabled( itemElem.attribute( QStringLiteral(
"enabled" ), QStringLiteral(
"false" ) ) == QLatin1String(
"true" ) );
1346 const QString layerId = itemElem.attribute( QStringLiteral(
"coverageLayer" ) );
1347 const QString layerName = itemElem.attribute( QStringLiteral(
"coverageLayerName" ) );
1348 const QString layerSource = itemElem.attribute( QStringLiteral(
"coverageLayerSource" ) );
1349 const QString layerProvider = itemElem.attribute( QStringLiteral(
"coverageLayerProvider" ) );
1354 atlasItem->
setPageNameExpression( itemElem.attribute( QStringLiteral(
"pageNameExpression" ), QString() ) );
1355 QString errorString;
1356 atlasItem->
setFilenameExpression( itemElem.attribute( QStringLiteral(
"filenamePattern" ), QString() ), errorString );
1358 atlasItem->
setSortFeatures( itemElem.attribute( QStringLiteral(
"sortFeatures" ), QStringLiteral(
"false" ) ) == QLatin1String(
"true" ) );
1361 atlasItem->
setSortExpression( itemElem.attribute( QStringLiteral(
"sortKey" ), QString() ) );
1362 atlasItem->
setSortAscending( itemElem.attribute( QStringLiteral(
"sortAscending" ), QStringLiteral(
"true" ) ) == QLatin1String(
"true" ) );
1364 atlasItem->
setFilterFeatures( itemElem.attribute( QStringLiteral(
"filterFeatures" ), QStringLiteral(
"false" ) ) == QLatin1String(
"true" ) );
1367 QString expErrorString;
1368 atlasItem->
setFilterExpression( itemElem.attribute( QStringLiteral(
"featureFilter" ), QString() ), expErrorString );
1372 atlasItem->
setHideCoverage( itemElem.attribute( QStringLiteral(
"hideCoverage" ), QStringLiteral(
"false" ) ) == QLatin1String(
"true" ) );
1381 readOldComposerObjectXml( layoutItem, itemElem );
1385 const QDomNodeList frameList = itemElem.elementsByTagName( QStringLiteral(
"ComposerFrame" ) );
1386 for (
int i = 0; i < frameList.size(); ++i )
1388 const QDomElement frameElem = frameList.at( i ).toElement();
1390 restoreGeneralComposeItemProperties( newFrame, frameElem );
1392 const double x = itemElem.attribute( QStringLiteral(
"sectionX" ) ).toDouble();
1393 const double y = itemElem.attribute( QStringLiteral(
"sectionY" ) ).toDouble();
1394 const double width = itemElem.attribute( QStringLiteral(
"sectionWidth" ) ).toDouble();
1395 const double height = itemElem.attribute( QStringLiteral(
"sectionHeight" ) ).toDouble();
1397 newFrame->
setHidePageIfEmpty( itemElem.attribute( QStringLiteral(
"hidePageIfEmpty" ), QStringLiteral(
"0" ) ).toInt() );
1398 newFrame->
setHideBackgroundIfEmpty( itemElem.attribute( QStringLiteral(
"hideBackgroundIfEmpty" ), QStringLiteral(
"0" ) ).toInt() );
1399 layoutItem->
addFrame( newFrame,
false );
1404 if ( !contentModeOK )
1406 layoutItem->
setContentMode( QgsLayoutItemHtml::ContentMode::Url );
1408 layoutItem->
setEvaluateExpressions( itemElem.attribute( QStringLiteral(
"evaluateExpressions" ), QStringLiteral(
"true" ) ) == QLatin1String(
"true" ) );
1409 layoutItem->
setUseSmartBreaks( itemElem.attribute( QStringLiteral(
"useSmartBreaks" ), QStringLiteral(
"true" ) ) == QLatin1String(
"true" ) );
1410 layoutItem->
setMaxBreakDistance( itemElem.attribute( QStringLiteral(
"maxBreakDistance" ), QStringLiteral(
"10" ) ).toDouble() );
1411 layoutItem->
setHtml( itemElem.attribute( QStringLiteral(
"html" ) ) );
1412 layoutItem->
setUserStylesheet( itemElem.attribute( QStringLiteral(
"stylesheet" ) ) );
1413 layoutItem->
setUserStylesheetEnabled( itemElem.attribute( QStringLiteral(
"stylesheetEnabled" ), QStringLiteral(
"false" ) ) == QLatin1String(
"true" ) );
1416 const QString urlString = itemElem.attribute( QStringLiteral(
"url" ) );
1417 if ( !urlString.isEmpty() )
1419 layoutItem->
setUrl( urlString );
1430 readOldComposerObjectXml( layoutItem, itemElem );
1434 const QDomNodeList frameList = itemElem.elementsByTagName( QStringLiteral(
"ComposerFrame" ) );
1435 for (
int i = 0; i < frameList.size(); ++i )
1437 const QDomElement frameElem = frameList.at( i ).toElement();
1439 restoreGeneralComposeItemProperties( newFrame, frameElem );
1441 const double x = itemElem.attribute( QStringLiteral(
"sectionX" ) ).toDouble();
1442 const double y = itemElem.attribute( QStringLiteral(
"sectionY" ) ).toDouble();
1443 const double width = itemElem.attribute( QStringLiteral(
"sectionWidth" ) ).toDouble();
1444 const double height = itemElem.attribute( QStringLiteral(
"sectionHeight" ) ).toDouble();
1446 newFrame->
setHidePageIfEmpty( itemElem.attribute( QStringLiteral(
"hidePageIfEmpty" ), QStringLiteral(
"0" ) ).toInt() );
1447 newFrame->
setHideBackgroundIfEmpty( itemElem.attribute( QStringLiteral(
"hideBackgroundIfEmpty" ), QStringLiteral(
"0" ) ).toInt() );
1448 layoutItem->
addFrame( newFrame,
false );
1452 layoutItem->
setEmptyTableMessage( itemElem.attribute( QStringLiteral(
"emptyTableMessage" ), QObject::tr(
"No matching records" ) ) );
1453 layoutItem->
setShowEmptyRows( itemElem.attribute( QStringLiteral(
"showEmptyRows" ), QStringLiteral(
"0" ) ).toInt() );
1457 headerFont.fromString( itemElem.attribute( QStringLiteral(
"headerFont" ), QString() ) );
1460 headerFormat.
setFont( headerFont );
1461 if ( headerFont.pointSizeF() > 0 )
1463 headerFormat.
setSize( headerFont.pointSizeF() );
1466 else if ( headerFont.pixelSize() > 0 )
1468 headerFormat.
setSize( headerFont.pixelSize() );
1479 contentFont.fromString( itemElem.attribute( QStringLiteral(
"contentFont" ), QString() ) );
1482 contentFormat.
setFont( contentFont );
1483 if ( contentFont.pointSizeF() > 0 )
1485 contentFormat.
setSize( contentFont.pointSizeF() );
1488 else if ( contentFont.pixelSize() > 0 )
1490 contentFormat.
setSize( contentFont.pixelSize() );
1496 layoutItem->
setCellMargin( itemElem.attribute( QStringLiteral(
"cellMargin" ), QStringLiteral(
"1.0" ) ).toDouble() );
1497 layoutItem->
setGridStrokeWidth( itemElem.attribute( QStringLiteral(
"gridStrokeWidth" ), QStringLiteral(
"0.5" ) ).toDouble() );
1498 layoutItem->
setHorizontalGrid( itemElem.attribute( QStringLiteral(
"horizontalGrid" ), QStringLiteral(
"1" ) ).toInt() );
1499 layoutItem->
setVerticalGrid( itemElem.attribute( QStringLiteral(
"verticalGrid" ), QStringLiteral(
"1" ) ).toInt() );
1500 layoutItem->
setShowGrid( itemElem.attribute( QStringLiteral(
"showGrid" ), QStringLiteral(
"1" ) ).toInt() );
1509 const QDomNodeList columnsList = itemElem.elementsByTagName( QStringLiteral(
"displayColumns" ) );
1510 if ( !columnsList.isEmpty() )
1512 const QDomElement columnsElem = columnsList.at( 0 ).toElement();
1513 const QDomNodeList columnEntryList = columnsElem.elementsByTagName( QStringLiteral(
"column" ) );
1514 for (
int i = 0; i < columnEntryList.size(); ++i )
1516 const QDomElement columnElem = columnEntryList.at( i ).toElement();
1518 column.mHAlignment =
static_cast< Qt::AlignmentFlag
>( columnElem.attribute( QStringLiteral(
"hAlignment" ), QString::number( Qt::AlignLeft ) ).toInt() );
1519 column.mVAlignment =
static_cast< Qt::AlignmentFlag
>( columnElem.attribute( QStringLiteral(
"vAlignment" ), QString::number( Qt::AlignVCenter ) ).toInt() );
1520 column.mHeading = columnElem.attribute( QStringLiteral(
"heading" ), QString() );
1521 column.mAttribute = columnElem.attribute( QStringLiteral(
"attribute" ), QString() );
1522 column.mSortByRank = columnElem.attribute( QStringLiteral(
"sortByRank" ), QStringLiteral(
"0" ) ).toInt();
1523 column.mSortOrder =
static_cast< Qt::SortOrder
>( columnElem.attribute( QStringLiteral(
"sortOrder" ), QString::number( Qt::AscendingOrder ) ).toInt() );
1524 column.mWidth = columnElem.attribute( QStringLiteral(
"width" ), QStringLiteral(
"0.0" ) ).toDouble();
1526 const QDomNodeList bgColorList = columnElem.elementsByTagName( QStringLiteral(
"backgroundColor" ) );
1527 if ( !bgColorList.isEmpty() )
1529 const QDomElement bgColorElem = bgColorList.at( 0 ).toElement();
1530 bool redOk, greenOk, blueOk, alphaOk;
1531 int bgRed, bgGreen, bgBlue, bgAlpha;
1532 bgRed = bgColorElem.attribute( QStringLiteral(
"red" ) ).toDouble( &redOk );
1533 bgGreen = bgColorElem.attribute( QStringLiteral(
"green" ) ).toDouble( &greenOk );
1534 bgBlue = bgColorElem.attribute( QStringLiteral(
"blue" ) ).toDouble( &blueOk );
1535 bgAlpha = bgColorElem.attribute( QStringLiteral(
"alpha" ) ).toDouble( &alphaOk );
1536 if ( redOk && greenOk && blueOk && alphaOk )
1538 column.mBackgroundColor = QColor( bgRed, bgGreen, bgBlue, bgAlpha );
1541 layoutItem->
mColumns.append( column );
1553 const QDomNodeList stylesList = itemElem.elementsByTagName( QStringLiteral(
"cellStyles" ) );
1554 if ( !stylesList.isEmpty() )
1556 const QDomElement stylesElem = stylesList.at( 0 ).toElement();
1558 QMap< QgsLayoutTable::CellStyleGroup, QString >::const_iterator it = layoutItem->mCellStyleNames.constBegin();
1559 for ( ; it != layoutItem->mCellStyleNames.constEnd(); ++it )
1561 const QString styleName = it.value();
1562 const QDomNodeList styleList = stylesElem.elementsByTagName( styleName );
1563 if ( !styleList.isEmpty() )
1565 const QDomElement styleElem = styleList.at( 0 ).toElement();
1574 const QString layerId = itemElem.attribute( QStringLiteral(
"vectorLayer" ) );
1575 const QString layerName = itemElem.attribute( QStringLiteral(
"vectorLayerName" ) );
1576 const QString layerSource = itemElem.attribute( QStringLiteral(
"vectorLayerSource" ) );
1577 const QString layerProvider = itemElem.attribute( QStringLiteral(
"vectorLayerProvider" ) );
1585bool QgsCompositionConverter::readGroupXml(
QgsLayoutItemGroup *layoutItem,
const QDomElement &itemElem,
const QgsProject *project,
const QList< QgsLayoutObject * > &items )
1589 restoreGeneralComposeItemProperties( layoutItem, itemElem );
1591 const QDomNodeList nodes = itemElem.elementsByTagName(
"ComposerItemGroupElement" );
1592 for (
int i = 0, n = nodes.size(); i < n; ++i )
1594 const QDomElement groupElement = nodes.at( i ).toElement();
1595 const QString elementUuid = groupElement.attribute(
"uuid" );
1610template <
class T,
class T2>
1611bool QgsCompositionConverter::readPolyXml( T *layoutItem,
const QDomElement &itemElem,
const QgsProject *project )
1613 restoreGeneralComposeItemProperties( layoutItem, itemElem );
1614 const QDomNodeList nodeList = itemElem.elementsByTagName( QStringLiteral(
"node" ) );
1615 if ( !nodeList.isEmpty() )
1618 for (
int i = 0; i < nodeList.length(); i++ )
1620 const QDomElement node = nodeList.at( i ).toElement();
1621 polygon.append( QPointF( node.attribute( QStringLiteral(
"x" ) ).toDouble( ), node.attribute( QStringLiteral(
"y" ) ).toDouble() ) );
1623 layoutItem->setNodes( polygon );
1625 if ( itemElem.elementsByTagName( QStringLiteral(
"symbol" ) ).size() )
1627 const QDomElement symbolElement = itemElem.elementsByTagName( QStringLiteral(
"symbol" ) ).at( 0 ).toElement();
1631 T2 *styleSymbol = QgsSymbolLayerUtils::loadSymbol<T2>( symbolElement, context );
1633 layoutItem->setSymbol( styleSymbol );
1636 layoutItem->setFrameEnabled(
false );
1637 layoutItem->setBackgroundEnabled(
false );
1642bool QgsCompositionConverter::readXml(
QgsLayoutItem *layoutItem,
const QDomElement &itemElem )
1644 if ( itemElem.isNull() )
1649 readOldComposerObjectXml( layoutItem, itemElem );
1652 layoutItem->mUuid = itemElem.attribute( QStringLiteral(
"uuid" ), QUuid::createUuid().toString() );
1655 layoutItem->mTemplateUuid = itemElem.attribute( QStringLiteral(
"templateUuid" ) );
1658 const QString
id = itemElem.attribute( QStringLiteral(
"id" ), QString() );
1659 layoutItem->
setId(
id );
1662 const QString frame = itemElem.attribute( QStringLiteral(
"frame" ) );
1663 layoutItem->
setFrameEnabled( frame.compare( QLatin1String(
"true" ), Qt::CaseInsensitive ) == 0 ) ;
1666 const QString background = itemElem.attribute( QStringLiteral(
"background" ) );
1667 layoutItem->
setBackgroundEnabled( background.compare( QLatin1String(
"true" ), Qt::CaseInsensitive ) == 0 );
1670 const QString positionLock = itemElem.attribute( QStringLiteral(
"positionLock" ) );
1671 layoutItem->
setLocked( positionLock.compare( QLatin1String(
"true" ), Qt::CaseInsensitive ) == 0 );
1674 layoutItem->
setVisibility( itemElem.attribute( QStringLiteral(
"visibility" ), QStringLiteral(
"1" ) ) != QLatin1String(
"0" ) );
1676 layoutItem->mParentGroupUuid = itemElem.attribute( QStringLiteral(
"groupUuid" ) );
1677 if ( !layoutItem->mParentGroupUuid.isEmpty() )
1681 group->addItem( layoutItem );
1684 layoutItem->mTemplateUuid = itemElem.attribute( QStringLiteral(
"templateUuid" ) );
1687 const QRectF position = itemPosition( layoutItem, itemElem );
1692 layoutItem->setZValue( itemElem.attribute( QStringLiteral(
"zValue" ) ).toDouble() );
1695 const QDomNodeList frameColorList = itemElem.elementsByTagName( QStringLiteral(
"FrameColor" ) );
1696 if ( !frameColorList.isEmpty() )
1698 const QDomElement frameColorElem = frameColorList.at( 0 ).toElement();
1699 bool redOk, greenOk, blueOk, alphaOk, widthOk;
1700 int penRed, penGreen, penBlue, penAlpha;
1703 penWidth = itemElem.attribute( QStringLiteral(
"outlineWidth" ) ).toDouble( &widthOk );
1704 penRed = frameColorElem.attribute( QStringLiteral(
"red" ) ).toDouble( &redOk );
1705 penGreen = frameColorElem.attribute( QStringLiteral(
"green" ) ).toDouble( &greenOk );
1706 penBlue = frameColorElem.attribute( QStringLiteral(
"blue" ) ).toDouble( &blueOk );
1707 penAlpha = frameColorElem.attribute( QStringLiteral(
"alpha" ) ).toDouble( &alphaOk );
1710 if ( redOk && greenOk && blueOk && alphaOk && widthOk )
1717 layoutItem->setPen( framePen );
1724 const QDomNodeList bgColorList = itemElem.elementsByTagName( QStringLiteral(
"BackgroundColor" ) );
1725 if ( !bgColorList.isEmpty() )
1727 const QDomElement bgColorElem = bgColorList.at( 0 ).toElement();
1728 bool redOk, greenOk, blueOk, alphaOk;
1729 int bgRed, bgGreen, bgBlue, bgAlpha;
1730 bgRed = bgColorElem.attribute( QStringLiteral(
"red" ) ).toDouble( &redOk );
1731 bgGreen = bgColorElem.attribute( QStringLiteral(
"green" ) ).toDouble( &greenOk );
1732 bgBlue = bgColorElem.attribute( QStringLiteral(
"blue" ) ).toDouble( &blueOk );
1733 bgAlpha = bgColorElem.attribute( QStringLiteral(
"alpha" ) ).toDouble( &alphaOk );
1734 if ( redOk && greenOk && blueOk && alphaOk )
1736 layoutItem->mBackgroundColor = QColor( bgRed, bgGreen, bgBlue, bgAlpha );
1737 layoutItem->setBrush( QBrush( layoutItem->mBackgroundColor, Qt::SolidPattern ) );
1747 if ( itemElem.hasAttribute( QStringLiteral(
"opacity" ) ) )
1749 layoutItem->
setItemOpacity( itemElem.attribute( QStringLiteral(
"opacity" ), QStringLiteral(
"1" ) ).toDouble() );
1753 layoutItem->
setItemOpacity( 1.0 - itemElem.attribute( QStringLiteral(
"transparency" ), QStringLiteral(
"0" ) ).toInt() / 100.0 );
1756 layoutItem->mExcludeFromExports = itemElem.attribute( QStringLiteral(
"excludeFromExports" ), QStringLiteral(
"0" ) ).toInt();
1757 layoutItem->mEvaluatedExcludeFromExports = layoutItem->mExcludeFromExports;
1762 layoutItem->
setItemRotation( itemElem.attribute( QStringLiteral(
"itemRotation" ), QStringLiteral(
"0" ) ).toDouble(),
false );
1764 layoutItem->mBlockUndoCommands =
false;
1771bool QgsCompositionConverter::readOldComposerObjectXml(
QgsLayoutObject *layoutItem,
1772 const QDomElement &itemElem )
1774 if ( itemElem.isNull() )
1782 const QDomNode propsNode = itemElem.namedItem( QStringLiteral(
"dataDefinedProperties" ) );
1783 if ( !propsNode.isNull() )
1791 exp = QStringLiteral(
"100.0 - (%1)" ).arg( exp );
1803void QgsCompositionConverter::readOldDataDefinedPropertyMap(
const QDomElement &itemElem,
QgsPropertyCollection &dataDefinedProperties )
1806 QgsPropertiesDefinition::const_iterator i = defs.constBegin();
1807 for ( ; i != defs.constEnd(); ++i )
1809 const QString elemName = i.value().name();
1810 const QDomNodeList ddNodeList = itemElem.elementsByTagName( elemName );
1811 if ( !ddNodeList.isEmpty() )
1813 const QDomElement ddElem = ddNodeList.at( 0 ).toElement();
1816 dataDefinedProperties.
setProperty( i.key(), prop );
1829 const QString active = ddElem.attribute( QStringLiteral(
"active" ) );
1830 bool isActive =
false;
1831 if ( active.compare( QLatin1String(
"true" ), Qt::CaseInsensitive ) == 0 )
1835 const QString
field = ddElem.attribute( QStringLiteral(
"field" ) );
1836 const QString expr = ddElem.attribute( QStringLiteral(
"expr" ) );
1838 const QString useExpr = ddElem.attribute( QStringLiteral(
"useExpr" ) );
1839 bool isExpression =
false;
1840 if ( useExpr.compare( QLatin1String(
"true" ), Qt::CaseInsensitive ) == 0 )
1842 isExpression =
true;
BlendMode
Blending modes defining the available composition modes that can be used when painting.
virtual bool readXml(const QDomElement &collectionElem, const QgsPropertiesDefinition &definitions)
Reads property collection state from an XML element.
DataDefinedProperty
Composition data defined properties for different item types.
@ LegendTitle
Legend title.
@ PaperOrientation
Paper orientation.
@ MapYMax
Map extent y maximum.
@ MapStylePreset
Layer and style map theme.
@ MapAtlasMargin
Map atlas margin.
@ FrameColor
Item frame color.
@ ItemWidth
Width of item.
@ MapYMin
Map extent y minimum.
@ ItemHeight
Height of item.
@ MapXMin
Map extent x minimum.
@ BlendMode
Item blend mode.
@ ScalebarFillColor2
Scalebar secondary fill color.
@ ExcludeFromExports
Exclude item from exports.
@ NumPages
Number of pages in composition.
@ PictureSvgBackgroundColor
SVG background color.
@ ItemRotation
Rotation of item.
@ MapRotation
Map rotation.
@ SourceUrl
Html source url.
@ LegendColumnCount
Legend column count.
@ PictureSvgStrokeWidth
SVG stroke width.
@ ScalebarFillColor
Scalebar fill color.
@ MapLayers
Map layer set.
@ PictureSvgStrokeColor
SVG stroke color.
@ PageNumber
Page number for item placement.
@ ScalebarLineColor
Scalebar line color.
@ Transparency
Item transparency (deprecated)
@ MapXMax
Map extent x maximum.
@ TestProperty
Dummy property with no effect on item.
@ AllProperties
All properties for item.
@ PresetPaperSize
Preset paper size for composition.
@ BackgroundColor
Item background color.
@ PositionY
Y position on page.
@ PaperHeight
Paper height.
@ PositionX
X position on page.
@ ScalebarLineWidth
Scalebar line width.
@ PictureSource
Picture source url.
MarkerMode
The MarkerMode enum is the old QGIS 2.x arrow marker mode.
static bool isCompositionTemplate(const QDomDocument &document)
Check if the given document is a composition template.
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.
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....
This class represents a coordinate reference system (CRS).
bool readXml(const QDomNode &node)
Restores state from the given DOM node.
static QgsFillSymbol * createSimple(const QVariantMap &properties)
Create a fill symbol with one symbol layer: SimpleFill with specified properties.
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.
Namespace with helper functions for layer tree operations.
static QgsLayerTree * readXml(QDomElement &element, const QgsReadWriteContext &context)
Load the layer tree from an XML element.
Class used to render QgsLayout as an atlas, by iterating over the features from an associated vector ...
bool filterFeatures() const
Returns true if features should be filtered in the coverage layer.
void setCoverageLayer(QgsVectorLayer *layer)
Sets the coverage layer to use for the atlas features.
bool setFilterExpression(const QString &expression, QString &errorString)
Sets the expression used for filtering features in the coverage layer.
void setSortAscending(bool ascending)
Sets whether features should be sorted in an ascending order.
void setEnabled(bool enabled)
Sets whether the atlas is enabled.
void setPageNameExpression(const QString &expression)
Sets the expression (or field name) used for calculating the page name.
bool setFilenameExpression(const QString &expression, QString &errorString)
Sets the filename expression used for generating output filenames for each atlas page.
void setSortFeatures(bool enabled)
Sets whether features should be sorted in the atlas.
void setSortExpression(const QString &expression)
Sets the expression (or field name) to use for sorting features.
void setFilterFeatures(bool filtered)
Sets whether features should be filtered in the coverage layer.
bool sortFeatures() const
Returns true if features should be sorted in the atlas.
void setHideCoverage(bool hide)
Sets whether the coverage layer should be hidden in map items in the layouts.
Base class for frame items, which form a layout multiframe item.
void setContentSection(const QRectF §ion)
Sets the visible part of the multiframe's content which is visible within this frame (relative to the...
void setHideBackgroundIfEmpty(bool hideBackgroundIfEmpty)
Sets whether the background and frame stroke should be hidden if this frame is empty.
void setHidePageIfEmpty(bool hidePageIfEmpty)
Sets whether the page should be hidden (ie, not included in layout exports) if this frame is empty.
A layout table subclass that displays attributes from a vector layer.
void setVectorLayer(QgsVectorLayer *layer)
Sets the vector layer from which to display feature attributes.
A container for grouping several QgsLayoutItems.
void addItem(QgsLayoutItem *item)
Adds an item to the group.
A layout multiframe subclass for HTML content.
void setUrl(const QUrl &url)
Sets the url for content to display in the item when the item is using the QgsLayoutItemHtml::Url mod...
ContentMode
Source modes for the HTML content to render in the item.
void setEvaluateExpressions(bool evaluateExpressions)
Sets whether the html item will evaluate QGIS expressions prior to rendering the HTML content.
void setMaxBreakDistance(double distance)
Sets the maximum distance allowed when calculating where to place page breaks in the html.
void setUserStylesheetEnabled(bool enabled)
Sets whether user stylesheets are enabled for the HTML content.
void setHtml(const QString &html)
Sets the html to display in the item when the item is using the QgsLayoutItemHtml::ManualHtml mode.
void setUseSmartBreaks(bool useSmartBreaks)
Sets whether the html item should use smart breaks.
void setUserStylesheet(const QString &stylesheet)
Sets the user stylesheet CSS rules to use while rendering the HTML content.
void setContentMode(ContentMode mode)
Sets the source mode for item's HTML content.
void loadHtml(bool useCache=false, const QgsExpressionContext *context=nullptr)
Reloads the html source from the url and redraws the item.
A layout item subclass for text labels.
void setHAlign(Qt::AlignmentFlag alignment)
Sets the horizontal alignment of the label.
void setMarginX(double margin)
Sets the horizontal margin between the edge of the frame and the label contents, in layout units.
void setText(const QString &text)
Sets the label's preset text.
void setMarginY(double margin)
Sets the vertical margin between the edge of the frame and the label contents, in layout units.
void setMode(Mode mode)
Sets the label's current mode, allowing the label to switch between font based and HTML based renderi...
void setTextFormat(const QgsTextFormat &format)
Sets the text format used for drawing text in the label.
void setVAlign(Qt::AlignmentFlag alignment)
Sets for the vertical alignment of the label.
A layout item subclass for map legends.
void setSplitLayer(bool enabled)
Sets whether the legend items from a single layer can be split over multiple columns.
void setColumnSpace(double spacing)
Sets the legend column spacing.
void setBoxSpace(double space)
Sets the legend box space.
void setEqualColumnWidth(bool equalize)
Sets whether column widths should be equalized.
void setDrawRasterStroke(bool enabled)
Sets whether a stroke will be drawn around raster symbol items.
void setSymbolWidth(double width)
Sets the legend symbol width.
void setLinkedMap(QgsLayoutItemMap *map)
Sets the map to associate with the legend.
QgsLegendStyle & rstyle(QgsLegendStyle::Style s)
Returns reference to modifiable legend style.
void setWmsLegendWidth(double width)
Sets the WMS legend width.
void setTitle(const QString &title)
Sets the legend title.
void setRasterStrokeColor(const QColor &color)
Sets the stroke color for the stroke drawn around raster symbol items.
void setStyle(QgsLegendStyle::Style component, const QgsLegendStyle &style)
Sets the style of component to style for the legend.
Q_DECL_DEPRECATED void setLineSpacing(double spacing)
Sets the spacing in-between multiple lines.
void setSymbolHeight(double height)
Sets the legend symbol height.
void setWmsLegendHeight(double height)
Sets the WMS legend height.
void setRasterStrokeWidth(double width)
Sets the stroke width for the stroke drawn around raster symbol items.
void setTitleAlignment(Qt::AlignmentFlag alignment)
Sets the alignment of the legend title.
void setWrapString(const QString &string)
Sets the legend text wrapping string.
void setColumnCount(int count)
Sets the legend column count.
An individual grid which is drawn above the map content in a QgsLayoutItemMap.
GridStyle
Grid drawing style.
void setFrameFillColor2(const QColor &color)
Sets the second fill color used for the grid frame.
void setAnnotationFormat(const AnnotationFormat format)
Sets the format for drawing grid annotations.
void setIntervalY(double interval)
Sets the interval between grid lines in the y-direction.
void setAnnotationEnabled(const bool enabled)
Sets whether annotations should be shown for the grid.
QgsTextFormat annotationTextFormat() const
Returns the text format used when rendering grid annotations.
void setFramePenColor(const QColor &color)
Sets the color of the stroke drawn in the grid frame.
void setFramePenSize(const double width)
Sets the width of the stroke drawn in the grid frame.
AnnotationPosition
Position for grid annotations.
void setAnnotationPosition(AnnotationPosition position, BorderSide side)
Sets the position for the grid annotations on a specified side of the map frame.
void setIntervalX(double interval)
Sets the interval between grid lines in the x-direction.
void setCrossLength(const double length)
Sets the length (in layout units) of the cross segments drawn for the grid.
void setEnabled(bool enabled) override
Controls whether the item will be drawn.
void setAnnotationFrameDistance(const double distance)
Sets the distance between the map frame and annotations.
void setAnnotationTextFormat(const QgsTextFormat &format)
Sets the text format to use when rendering grid annotations.
void setBlendMode(const QPainter::CompositionMode mode)
Sets the blending mode used for drawing the grid.
void setFrameStyle(const FrameStyle style)
Sets the grid frame style.
void setAnnotationPrecision(const int precision)
Sets the coordinate precision for grid annotations.
void setLineSymbol(QgsLineSymbol *symbol)
Sets the line symbol used for drawing grid lines.
AnnotationFormat
Format for displaying grid annotations.
AnnotationDirection
Direction of grid annotations.
void setOffsetY(double offset)
Sets the offset for grid lines in the y-direction.
FrameStyle
Style for grid frame.
void setFrameWidth(const double width)
Sets the grid frame width (in layout units).
void setFrameFillColor1(const QColor &color)
Sets the first fill color used for the grid frame.
void setOffsetX(double offset)
Sets the offset for grid lines in the x-direction.
void setAnnotationDirection(AnnotationDirection direction, BorderSide side)
Sets the direction for drawing frame annotations for the specified map side.
void setStyle(GridStyle style)
Sets the grid style, which controls how the grid is drawn over the map's contents.
An individual overview which is drawn above the map content in a QgsLayoutItemMap,...
Layout graphical items for displaying a map.
void setFollowVisibilityPreset(bool follow)
Sets whether the map should follow a map theme.
void setFollowVisibilityPresetName(const QString &name)
Sets preset name for map rendering.
void setKeepLayerSet(bool enabled)
Sets whether the stored layer set should be used or the current layer set of the associated project.
AtlasScalingMode
Scaling modes used for the serial rendering (atlas)
void updateBoundingRect()
Updates the bounding rect of this item. Call this function before doing any changes related to annota...
void setDrawAnnotations(bool draw)
Sets whether annotations are drawn within the map.
void setExtent(const QgsRectangle &extent)
Sets a new extent for the map.
void setAtlasScalingMode(AtlasScalingMode mode)
Sets the current atlas scaling mode.
void setCrs(const QgsCoordinateReferenceSystem &crs)
Sets the map's preset crs (coordinate reference system).
void setAtlasMargin(double margin)
Sets the margin size (percentage) used when the map is in atlas mode.
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...
QgsCoordinateReferenceSystem crs() const
Returns coordinate reference system used for rendering the map.
Item representing the paper in a layout.
void setPageSize(const QgsLayoutSize &size)
Sets the size of the page.
static QgsLayoutItemPage * create(QgsLayout *layout)
Returns a new page item for the specified layout.
A layout item subclass that displays SVG files or raster format images (jpg, png, ....
void setPictureAnchor(QgsLayoutItem::ReferencePoint anchor)
Sets the picture's anchor point, which controls how it is placed within the picture item's frame.
void setLinkedMap(QgsLayoutItemMap *map)
Sets the map object for rotation.
void setPicturePath(const QString &path, Format format=FormatUnknown)
Sets the source path of the image (may be svg or a raster format).
ResizeMode
Controls how pictures are scaled within the item's frame.
Layout item for node based polygon shapes.
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 setArrowHeadStrokeWidth(double width)
Sets the pen width in millimeters for the stroke of the arrow head.
void setArrowHeadFillColor(const QColor &color)
Sets the color used to fill the arrow head.
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.
void setStartSvgMarkerPath(const QString &path)
Sets the path to a SVG marker to draw at the start of the line.
A layout item subclass for scale bars.
void setNumberOfSegments(int segments)
Sets the number of segments included in the scalebar.
QgsFillSymbol * alternateFillSymbol() const
Returns the secondary fill symbol used to render the scalebar (only used for some scalebar types).
void setMinimumBarWidth(double minWidth)
Sets the minimum width (in millimeters) for scale bar segments.
QgsFillSymbol * fillSymbol() const
Returns the primary fill symbol used to render the scalebar (only used for some scalebar types).
void setMaximumBarWidth(double maxWidth)
Sets the maximum width (in millimeters) for scale bar segments.
void setSegmentSizeMode(QgsScaleBarSettings::SegmentSizeMode mode)
Sets the size mode for scale bar segments.
void setDivisionLineSymbol(QgsLineSymbol *symbol)
Sets the line symbol used to render the scalebar divisions (only used for some scalebar types).
void setLabelBarSpace(double space)
Sets the spacing (in millimeters) between labels and the scalebar.
void setUnits(QgsUnitTypes::DistanceUnit units)
Sets the distance units used by the scalebar.
void setAlignment(QgsScaleBarSettings::Alignment alignment)
Sets the scalebar alignment.
void setLineSymbol(QgsLineSymbol *symbol)
Sets the line symbol used to render the scalebar (only used for some scalebar types).
void setStyle(const QString &name)
Sets the scale bar style by name.
void setMapUnitsPerScaleBarUnit(double units)
Sets the number of map units per scale bar unit used by the scalebar.
void setHeight(double height)
Sets the scalebar height (in millimeters).
void setNumberOfSegmentsLeft(int segments)
Sets the number of segments included in the left part of the scalebar.
void setLinkedMap(QgsLayoutItemMap *map)
Sets the map item linked to the scalebar.
Q_DECL_DEPRECATED void setFontColor(const QColor &color)
Sets the color used for drawing text in the scalebar.
void setBoxContentSpace(double space)
Sets the space (margin) between the scalebar box and content in millimeters.
void setUnitLabel(const QString &label)
Sets the label for units.
void setUnitsPerSegment(double units)
Sets the number of scalebar units per segment.
Q_DECL_DEPRECATED void setFont(const QFont &font)
Sets the font used for drawing text in the scalebar.
void setSubdivisionLineSymbol(QgsLineSymbol *symbol)
Sets the line symbol used to render the scalebar subdivisions (only used for some scalebar types).
Layout item for basic filled shapes (e.g.
void setShapeType(QgsLayoutItemShape::Shape type)
Sets the type of shape (e.g.
void setSymbol(QgsFillSymbol *symbol)
Sets the fill symbol used to draw the shape.
void setCornerRadius(QgsLayoutMeasurement radius)
Sets the corner radius for rounded rectangle corners.
Base class for graphical items within a QgsLayout.
virtual void setFrameStrokeWidth(QgsLayoutMeasurement width)
Sets the frame stroke width.
QgsLayoutSize sizeWithUnits() const
Returns the item's current size, including units.
QgsLayoutItemGroup * parentGroup() const
Returns the item's parent group, if the item is part of a QgsLayoutItemGroup group.
virtual void setItemRotation(double rotation, bool adjustPosition=true)
Sets the layout item's rotation, in degrees clockwise.
QgsLayoutMeasurement frameStrokeWidth() const
Returns the frame's stroke width.
void setItemOpacity(double opacity)
Sets the item's opacity.
virtual void setVisibility(bool visible)
Sets whether the item is visible.
ReferencePoint
Fixed position reference point.
virtual void setId(const QString &id)
Set the item's id name.
void setFrameStrokeColor(const QColor &color)
Sets the frame stroke color.
void setFrameJoinStyle(Qt::PenJoinStyle style)
Sets the join style used when drawing the item's frame.
void refreshBackgroundColor(bool updateItem=true)
Refresh item's background color, considering data defined colors.
virtual void setFrameEnabled(bool drawFrame)
Sets whether this item has a frame drawn around it or not.
void setLocked(bool locked)
Sets whether the item is locked, preventing mouse interactions with the item.
void refreshFrame(bool updateItem=true)
Refresh item's frame, considering data defined colors and frame size.
virtual QString uuid() const
Returns the item identification string.
virtual void attemptMove(const QgsLayoutPoint &point, bool useReferencePoint=true, bool includesFrame=false, int page=-1)
Attempts to move the item to a specified point.
void setBlendMode(QPainter::CompositionMode mode)
Sets the item's composition blending mode.
bool frameEnabled() const
Returns true if the item includes a frame.
void attemptMoveBy(double deltaX, double deltaY)
Attempts to shift the item's position by a specified deltaX and deltaY, in layout units.
void setReferencePoint(ReferencePoint point)
Sets the reference point for positioning of the layout item.
bool hasBackground() const
Returns true if the item has a background.
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.
QColor frameStrokeColor() const
Returns the frame's stroke color.
void setBackgroundEnabled(bool drawBackground)
Sets whether this item has a background drawn under it or not.
Qt::PenJoinStyle frameJoinStyle() const
Returns the join style used for drawing the item's frame.
This class provides a method of storing measurements for use in QGIS layouts using a variety of diffe...
double length() const
Returns the length of the measurement.
void setResizeMode(ResizeMode mode)
Sets the resize mode for the multiframe, and recalculates frame sizes to match.
virtual void addFrame(QgsLayoutFrame *frame, bool recalcFrameSizes=true)
Adds a frame to the multiframe.
ResizeMode
Specifies the behavior for creating new frames to fit the multiframe's content.
QList< QgsLayoutFrame * > frames() const
Returns a list of all child frames for this multiframe.
void setNodes(const QPolygonF &nodes)
Sets the nodes the shape consists of.
void setNorthOffset(double offset)
Sets the offset added to the arrows's rotation from a map's North.
NorthMode
Method for syncing rotation to a map's North direction.
void setNorthMode(NorthMode mode)
Sets the mode used to calculate the arrow rotation.
A base class for objects which belong to a layout.
QgsObjectCustomProperties mCustomProperties
Custom properties for object.
QgsPropertyCollection mDataDefinedProperties
const QgsLayout * layout() const
Returns the layout the object is attached to.
double spaceBetweenPages() const
Returns the space between pages, in layout units.
QList< QgsLayoutItemPage * > pages()
Returns a list of pages in the collection.
int pageCount() const
Returns the number of pages in the collection.
This class provides a method of storing points, consisting of an x and y coordinate,...
This class provides a method of storing sizes, consisting of a width and height, for use in QGIS layo...
double height() const
Returns the height of the size.
Stores properties of a column for a QgsLayoutTable.
Styling option for a layout table cell.
bool readXml(const QDomElement &styleElem)
Reads the style's properties from XML.
void setHeaderHAlignment(HeaderHAlignment alignment)
Sets the horizontal alignment for table headers.
void setShowEmptyRows(bool showEmpty)
Sets whether empty rows should be drawn.
void setVerticalGrid(bool verticalGrid)
Sets whether the grid's vertical lines should be drawn in the table.
void setGridColor(const QColor &color)
Sets the color used for grid lines in the table.
void setCellMargin(double margin)
Sets the margin distance in mm between cell borders and their contents.
void setBackgroundColor(const QColor &color)
Sets the color used for background of table.
void setContentTextFormat(const QgsTextFormat &format)
Sets the format used to draw content text in the table.
QgsTextFormat contentTextFormat() const
Returns the format used to draw content text in the table.
void setWrapBehavior(WrapBehavior behavior)
Sets the wrap behavior for the table, which controls how text within cells is automatically wrapped.
void setEmptyTableBehavior(EmptyTableMode mode)
Sets the behavior mode for empty tables with no content rows.
void setHeaderMode(HeaderMode mode)
Sets the display mode for headers in the table.
void setHorizontalGrid(bool horizontalGrid)
Sets whether the grid's horizontal lines should be drawn in the table.
HeaderMode
Controls where headers are shown in the table.
QgsLayoutTableColumns mColumns
Columns to show in table.
void setShowGrid(bool showGrid)
Sets whether grid lines should be drawn in the table.
QgsTextFormat headerTextFormat() const
Returns the format used to draw header text in the table.
void setEmptyTableMessage(const QString &message)
Sets the message for empty tables with no content rows.
void setHeaderTextFormat(const QgsTextFormat &format)
Sets the format used to draw header text in the table.
QgsLayoutTableSortColumns mSortColumns
Columns to sort the table.
void setGridStrokeWidth(double width)
Sets the width in mm for grid lines in the table.
WrapBehavior
Controls how long strings in the table are handled.
HeaderHAlignment
Controls how headers are horizontally aligned in a table.
EmptyTableMode
Controls how empty tables are displayed.
QMap< CellStyleGroup, QgsLayoutTableStyle * > mCellStyles
QgsLayoutPageCollection * pageCollection()
Returns a pointer to the layout's page collection, which stores and manages page items in the layout.
QgsLayoutItem * itemByUuid(const QString &uuid, bool includeTemplateUuids=false) const
Returns the layout item with matching uuid unique identifier, or nullptr if a matching item could not...
void addLayoutItem(QgsLayoutItem *item)
Adds an item to the layout.
QgsProject * project() const
The project associated with the layout.
Contains detailed styling information relating to how a layout legend should be rendered.
QgsTextFormat & textFormat()
Returns the text format used for rendering this legend component.
void readXml(const QDomElement &elem, const QDomDocument &doc, const QgsReadWriteContext &context=QgsReadWriteContext())
Reads the component's style definition from an XML element.
Style
Component of legends which can be styled.
@ Group
Legend group title.
@ Symbol
Symbol icon (excluding label)
@ Subgroup
Legend subgroup title.
@ SymbolLabel
Symbol label (excluding icon)
A line symbol type, for rendering LineString and MultiLineString geometries.
void setWidth(double width) const
Sets the width for the whole line symbol.
static QgsLineSymbol * createSimple(const QVariantMap &properties)
Create a line symbol with one symbol layer: SimpleLine with specified properties.
Stores style information (renderer, opacity, labeling, diagrams etc.) applicable to a map layer.
void readXml(const QDomElement &styleElement)
Read style configuration (for project file reading)
QString xmlData() const
Returns XML content of the style.
void readXml(const QDomNode &parentNode, const QString &keyStartsWith=QString())
Read store contents from an XML node.
static QPainter::CompositionMode getCompositionMode(Qgis::BlendMode blendMode)
Returns a QPainter::CompositionMode corresponding to a BlendMode.
Resolves relative paths into absolute paths and vice versa.
QString readPath(const QString &filename) const
Turn filename read from the project file to an absolute path.
Print layout, a QgsLayout subclass for static or atlas-based layouts.
Encapsulates a QGIS project, including sets of map layers and their styles, layouts,...
QgsPathResolver pathResolver() const
Returns path resolver object with considering whether the project uses absolute or relative paths and...
A grouped map of multiple QgsProperty objects, each referenced by a integer key value.
QgsProperty property(int key) const override
Returns a matching property from the collection, if one exists.
void setProperty(int key, const QgsProperty &property)
Adds a property to the collection and takes ownership of it.
bool isActive(int key) const override
Returns true if the collection contains an active property with the specified key.
Definition for a property.
@ Double
Double value (including negative values)
@ StrokeWidth
Line stroke width.
@ String
Any string value.
@ IntegerPositiveGreaterZero
Non-zero positive integer values.
@ IntegerPositive
Positive integer values (including 0)
@ Rotation
Rotation (value between 0-360 degrees)
@ ColorWithAlpha
Color with alpha channel.
@ DoublePositive
Positive double value (including 0)
@ DataTypeString
Property requires a string value.
A store for object properties.
QString asExpression() const
Returns an expression string representing the state of the property, or an empty string if the proper...
static QgsProperty fromExpression(const QString &expression, bool isActive=true)
Returns a new ExpressionBasedProperty created from the specified expression.
static QgsProperty fromField(const QString &fieldName, bool isActive=true)
Returns a new FieldBasedProperty created from the specified field name.
The class is used as a container of context for various read/write operations on other objects.
void setProjectTranslator(QgsProjectTranslator *projectTranslator)
Sets the project translator.
void setPathResolver(const QgsPathResolver &resolver)
Sets up path resolver for conversion between relative and absolute paths.
A rectangle specified with double values.
Alignment
Scalebar alignment.
SegmentSizeMode
Modes for setting size for scale bar segments.
static Qt::PenJoinStyle decodePenJoinStyle(const QString &str)
static QColor decodeColor(const QString &str)
static Qt::PenCapStyle decodePenCapStyle(const QString &str)
static QString svgSymbolNameToPath(const QString &name, const QgsPathResolver &pathResolver)
Determines an SVG symbol's path from its name.
static QString encodeColor(const QColor &color)
void setColor(const QColor &color) const
Sets the color for the symbol.
Container for all settings relating to text rendering.
void setColor(const QColor &color)
Sets the color that text will be rendered in.
void setSize(double size)
Sets the size for rendered text.
void setFont(const QFont &font)
Sets the font used for rendering text.
void setSizeUnit(QgsUnitTypes::RenderUnit unit)
Sets the units for the size of rendered text.
DistanceUnit
Units of distance.
@ DistanceUnknownUnit
Unknown distance unit.
@ DistanceFeet
Imperial feet.
@ DistanceNauticalMiles
Nautical miles.
static Q_INVOKABLE QgsUnitTypes::DistanceUnit decodeDistanceUnit(const QString &string, bool *ok=nullptr)
Decodes a distance unit from a string.
@ RenderPoints
Points (e.g., for font sizes)
@ RenderMillimeters
Millimeters.
As part of the API refactoring and improvements which landed in the Processing API was substantially reworked from the x version This was done in order to allow much of the underlying Processing framework to be ported into c
#define Q_NOWARN_DEPRECATED_POP
#define Q_NOWARN_DEPRECATED_PUSH
bool qgsDoubleNear(double a, double b, double epsilon=4 *std::numeric_limits< double >::epsilon())
Compare two doubles (but allow some difference)
QMap< QString, QString > QgsStringMap
QMap< int, QgsPropertyDefinition > QgsPropertiesDefinition
Definition of available properties.