35#include <QStyleOptionGraphicsItem>
38#define CACHE_SIZE_LIMIT 5000
41 : mRenderContext( context )
42 , mViewScaleFactor( viewScaleFactor )
50 , QGraphicsRectItem( nullptr )
51 , mUuid( QUuid::createUuid().toString() )
56 setFlags( flags() | QGraphicsItem::ItemUsesExtendedStyleOption | QGraphicsItem::ItemIsSelectable );
58 setCacheMode( QGraphicsItem::DeviceCoordinateCache );
62 mItemPosition =
QgsLayoutPoint( scenePos().x(), scenePos().y(), initialUnits );
63 mItemSize =
QgsLayoutSize( rect().width(), rect().height(), initialUnits );
69 initConnectionsToLayout();
74 mLayoutManagesZValue =
true;
75 mLayout->itemsModel()->addItemAtTop(
this );
79 mLayoutManagesZValue =
false;
90 if (
mLayout && mLayoutManagesZValue )
92 mLayout->itemsModel()->removeItem(
this );
99 if ( !
id().isEmpty() )
107 return tr(
"<%1>" ).arg( metadata->visibleName() );
110 return tr(
"<item>" );
135 if ( !shouldBlockUndoCommands() )
136 mLayout->undoStack()->beginCommand(
this, tr(
"Change Item ID" ) );
140 if ( !shouldBlockUndoCommands() )
141 mLayout->undoStack()->endCommand();
148 mLayout->itemsModel()->updateItemDisplayName(
this );
156 QGraphicsRectItem::setSelected( selected );
160 mLayout->itemsModel()->updateItemSelectStatus(
this );
166 if ( visible == isVisible() )
172 std::unique_ptr< QgsAbstractLayoutUndoCommand > command;
173 if ( !shouldBlockUndoCommands() )
175 command.reset(
createCommand( visible ? tr(
"Show Item" ) : tr(
"Hide Item" ), 0 ) );
176 command->saveBeforeState();
179 QGraphicsItem::setVisible( visible );
183 command->saveAfterState();
184 mLayout->undoStack()->push( command.release() );
190 mLayout->itemsModel()->updateItemVisibility(
this );
196 if (
locked == mIsLocked )
201 if ( !shouldBlockUndoCommands() )
202 mLayout->undoStack()->beginCommand(
this,
locked ? tr(
"Lock Item" ) : tr(
"Unlock Item" ) );
206 if ( !shouldBlockUndoCommands() )
207 mLayout->undoStack()->endCommand();
212 mLayout->itemsModel()->updateItemLockStatus(
this );
221 return !mParentGroupUuid.isEmpty() &&
mLayout &&
static_cast< bool >(
mLayout->itemByUuid( mParentGroupUuid ) );
226 if ( !
mLayout || mParentGroupUuid.isEmpty() )
229 return qobject_cast< QgsLayoutItemGroup * >(
mLayout->itemByUuid( mParentGroupUuid ) );
235 mParentGroupUuid.clear();
237 mParentGroupUuid = group->
uuid();
238 setFlag( QGraphicsItem::ItemIsSelectable, !
static_cast< bool>( group ) );
264 if ( !
mLayout ||
mLayout->renderContext().currentExportLayer() == -1 )
270 return mLayout->renderContext().currentExportLayer() < layers;
286 if ( shouldDrawDebugRect() )
292 const bool previewRender = !
mLayout ||
mLayout->renderContext().isPreviewRender();
294 const bool useImageCache =
false;
296 QPainter::CompositionMode
blendMode = blendModeForRender();
301 forceRasterOutput =
false;
303 else if (
blendMode != QPainter::CompositionMode_SourceOver )
306 forceRasterOutput =
true;
309 if ( useImageCache || forceRasterOutput )
311 double widthInPixels = 0;
312 double heightInPixels = 0;
322 widthInPixels = boundingRect().width() * layoutUnitsToPixels;
323 heightInPixels = boundingRect().height() * layoutUnitsToPixels;
330 if ( widthInPixels > heightInPixels )
334 heightInPixels /= scale;
340 widthInPixels /= scale;
342 destinationDpi = destinationDpi / scale;
345 if ( previewRender && !mItemCachedImage.isNull() &&
qgsDoubleNear( mItemCacheDpi, destinationDpi ) )
350 preparePainter( painter );
351 const double cacheScale = destinationDpi / mItemCacheDpi;
353 painter->setCompositionMode(
blendMode );
354 painter->drawImage( boundingRect().x() * context.
scaleFactor() / cacheScale,
355 boundingRect().y() * context.
scaleFactor() / cacheScale, mItemCachedImage );
360 QImage image = QImage( widthInPixels, heightInPixels, QImage::Format_ARGB32 );
361 image.fill( Qt::transparent );
362 image.setDotsPerMeterX( 1000 * destinationDpi * 25.4 );
363 image.setDotsPerMeterY( 1000 * destinationDpi * 25.4 );
364 QPainter p( &image );
366 preparePainter( &p );
378 draw( itemRenderContext );
389 painter->setCompositionMode(
blendMode );
390 painter->drawImage( boundingRect().x() * context.
scaleFactor(),
391 boundingRect().y() * context.
scaleFactor(), image );
395 mItemCacheDpi = destinationDpi;
396 mItemCachedImage = image;
404 preparePainter( painter );
414 draw( itemRenderContext );
428 if ( point == mReferencePoint )
433 mReferencePoint = point;
436 updateStoredItemPosition();
460 const QSizeF targetSizeLayoutUnits =
mLayout->convertToLayoutUnits( evaluatedSize );
461 QSizeF actualSizeLayoutUnits = applyMinimumSize( targetSizeLayoutUnits );
462 actualSizeLayoutUnits = applyFixedSize( actualSizeLayoutUnits );
465 if ( actualSizeLayoutUnits == rect().size() )
471 mItemSize = actualSizeTargetUnits;
473 setRect( 0, 0, actualSizeLayoutUnits.width(), actualSizeLayoutUnits.height() );
490 point =
mLayout->pageCollection()->pagePositionToAbsolute(
page, p );
497 point.
setX( point.
x() + bleed );
498 point.
setY( point.
y() + bleed );
502 if ( !useReferencePoint )
507 evaluatedPoint = applyDataDefinedPosition( evaluatedPoint );
508 const QPointF evaluatedPointLayoutUnits =
mLayout->convertToLayoutUnits( evaluatedPoint );
510 if ( topLeftPointLayoutUnits == scenePos() && point.
units() == mItemPosition.
units() )
517 mItemPosition = referencePointTargetUnits;
518 setScenePos( topLeftPointLayoutUnits );
524 const QPointF newPos = rect.topLeft();
526 blockSignals(
true );
534 blockSignals(
false );
542 moveBy( deltaX, deltaY );
548 itemPos.
setX( itemPos.
x() + deltaPos.
x() );
549 itemPos.
setY( itemPos.
y() + deltaPos.
y() );
558 return mLayout->pageCollection()->pageNumberForPoint( pos() );
573 p.ry() -= pageItem->pos().y();
583 return mLayout->convertFromLayoutUnits( p, mItemPosition.
units() );
586void QgsLayoutItem::setScenePos(
const QPointF destinationPos )
591 if (
auto *lParentItem = parentItem() )
592 setPos( pos() + ( destinationPos - scenePos() ) + lParentItem->scenePos() );
594 setPos( pos() + ( destinationPos - scenePos() ) );
597bool QgsLayoutItem::shouldBlockUndoCommands()
const
614 return !mEvaluatedExcludeFromExports;
619 return mItemRotation;
624 QDomElement element = doc.createElement( QStringLiteral(
"LayoutItem" ) );
625 element.setAttribute( QStringLiteral(
"type" ), QString::number(
type() ) );
627 element.setAttribute( QStringLiteral(
"uuid" ), mUuid );
628 element.setAttribute( QStringLiteral(
"templateUuid" ), mUuid );
629 element.setAttribute( QStringLiteral(
"id" ), mId );
630 element.setAttribute( QStringLiteral(
"referencePoint" ), QString::number(
static_cast< int >( mReferencePoint ) ) );
631 element.setAttribute( QStringLiteral(
"position" ), mItemPosition.
encodePoint() );
633 element.setAttribute( QStringLiteral(
"size" ), mItemSize.
encodeSize() );
634 element.setAttribute( QStringLiteral(
"itemRotation" ), QString::number( mItemRotation ) );
635 element.setAttribute( QStringLiteral(
"groupUuid" ), mParentGroupUuid );
637 element.setAttribute( QStringLiteral(
"zValue" ), QString::number( zValue() ) );
638 element.setAttribute( QStringLiteral(
"visibility" ), isVisible() );
642 element.setAttribute( QStringLiteral(
"positionLock" ), QStringLiteral(
"true" ) );
646 element.setAttribute( QStringLiteral(
"positionLock" ), QStringLiteral(
"false" ) );
652 element.setAttribute( QStringLiteral(
"frame" ), QStringLiteral(
"true" ) );
656 element.setAttribute( QStringLiteral(
"frame" ), QStringLiteral(
"false" ) );
662 element.setAttribute( QStringLiteral(
"background" ), QStringLiteral(
"true" ) );
666 element.setAttribute( QStringLiteral(
"background" ), QStringLiteral(
"false" ) );
670 QDomElement frameColorElem = doc.createElement( QStringLiteral(
"FrameColor" ) );
671 frameColorElem.setAttribute( QStringLiteral(
"red" ), QString::number( mFrameColor.red() ) );
672 frameColorElem.setAttribute( QStringLiteral(
"green" ), QString::number( mFrameColor.green() ) );
673 frameColorElem.setAttribute( QStringLiteral(
"blue" ), QString::number( mFrameColor.blue() ) );
674 frameColorElem.setAttribute( QStringLiteral(
"alpha" ), QString::number( mFrameColor.alpha() ) );
675 element.appendChild( frameColorElem );
676 element.setAttribute( QStringLiteral(
"outlineWidthM" ), mFrameWidth.
encodeMeasurement() );
680 QDomElement bgColorElem = doc.createElement( QStringLiteral(
"BackgroundColor" ) );
681 bgColorElem.setAttribute( QStringLiteral(
"red" ), QString::number( mBackgroundColor.red() ) );
682 bgColorElem.setAttribute( QStringLiteral(
"green" ), QString::number( mBackgroundColor.green() ) );
683 bgColorElem.setAttribute( QStringLiteral(
"blue" ), QString::number( mBackgroundColor.blue() ) );
684 bgColorElem.setAttribute( QStringLiteral(
"alpha" ), QString::number( mBackgroundColor.alpha() ) );
685 element.appendChild( bgColorElem );
691 element.setAttribute( QStringLiteral(
"opacity" ), QString::number( mOpacity ) );
693 element.setAttribute( QStringLiteral(
"excludeFromExports" ), mExcludeFromExports );
698 parentElement.appendChild( element );
705 if ( element.nodeName() != QLatin1String(
"LayoutItem" ) )
712 mBlockUndoCommands =
true;
713 mUuid = element.attribute( QStringLiteral(
"uuid" ), QUuid::createUuid().toString() );
714 setId( element.attribute( QStringLiteral(
"id" ) ) );
715 mReferencePoint =
static_cast< ReferencePoint >( element.attribute( QStringLiteral(
"referencePoint" ) ).toInt() );
716 setItemRotation( element.attribute( QStringLiteral(
"itemRotation" ), QStringLiteral(
"0" ) ).toDouble() );
720 mParentGroupUuid = element.attribute( QStringLiteral(
"groupUuid" ) );
721 if ( !mParentGroupUuid.isEmpty() )
725 group->addItem(
this );
728 mTemplateUuid = element.attribute( QStringLiteral(
"templateUuid" ) );
731 const QString positionLock = element.attribute( QStringLiteral(
"positionLock" ) );
732 if ( positionLock.compare( QLatin1String(
"true" ), Qt::CaseInsensitive ) == 0 )
741 setVisibility( element.attribute( QStringLiteral(
"visibility" ), QStringLiteral(
"1" ) ) != QLatin1String(
"0" ) );
742 setZValue( element.attribute( QStringLiteral(
"zValue" ) ).toDouble() );
745 const QString frame = element.attribute( QStringLiteral(
"frame" ) );
746 if ( frame.compare( QLatin1String(
"true" ), Qt::CaseInsensitive ) == 0 )
756 const QString background = element.attribute( QStringLiteral(
"background" ) );
757 if ( background.compare( QLatin1String(
"true" ), Qt::CaseInsensitive ) == 0 )
769 const QDomNodeList frameColorList = element.elementsByTagName( QStringLiteral(
"FrameColor" ) );
770 if ( !frameColorList.isEmpty() )
772 const QDomElement frameColorElem = frameColorList.at( 0 ).toElement();
774 bool greenOk =
false;
776 bool alphaOk =
false;
777 int penRed, penGreen, penBlue, penAlpha;
779 penRed = frameColorElem.attribute( QStringLiteral(
"red" ) ).toDouble( &redOk );
780 penGreen = frameColorElem.attribute( QStringLiteral(
"green" ) ).toDouble( &greenOk );
781 penBlue = frameColorElem.attribute( QStringLiteral(
"blue" ) ).toDouble( &blueOk );
782 penAlpha = frameColorElem.attribute( QStringLiteral(
"alpha" ) ).toDouble( &alphaOk );
784 if ( redOk && greenOk && blueOk && alphaOk )
786 mFrameColor = QColor( penRed, penGreen, penBlue, penAlpha );
792 const QDomNodeList bgColorList = element.elementsByTagName( QStringLiteral(
"BackgroundColor" ) );
793 if ( !bgColorList.isEmpty() )
795 const QDomElement bgColorElem = bgColorList.at( 0 ).toElement();
796 bool redOk, greenOk, blueOk, alphaOk;
797 int bgRed, bgGreen, bgBlue, bgAlpha;
798 bgRed = bgColorElem.attribute( QStringLiteral(
"red" ) ).toDouble( &redOk );
799 bgGreen = bgColorElem.attribute( QStringLiteral(
"green" ) ).toDouble( &greenOk );
800 bgBlue = bgColorElem.attribute( QStringLiteral(
"blue" ) ).toDouble( &blueOk );
801 bgAlpha = bgColorElem.attribute( QStringLiteral(
"alpha" ) ).toDouble( &alphaOk );
802 if ( redOk && greenOk && blueOk && alphaOk )
804 mBackgroundColor = QColor( bgRed, bgGreen, bgBlue, bgAlpha );
805 setBrush( QBrush( mBackgroundColor, Qt::SolidPattern ) );
815 if ( element.hasAttribute( QStringLiteral(
"opacity" ) ) )
817 setItemOpacity( element.attribute( QStringLiteral(
"opacity" ), QStringLiteral(
"1" ) ).toDouble() );
821 setItemOpacity( 1.0 - element.attribute( QStringLiteral(
"transparency" ), QStringLiteral(
"0" ) ).toInt() / 100.0 );
824 mExcludeFromExports = element.attribute( QStringLiteral(
"excludeFromExports" ), QStringLiteral(
"0" ) ).toInt();
825 mEvaluatedExcludeFromExports = mExcludeFromExports;
829 mBlockUndoCommands =
false;
842 return new QgsLayoutItemUndoCommand(
this, text,
id, parent );
860 if ( mFrameColor == color )
873 if ( mFrameWidth == width )
885 if ( mFrameJoinStyle == style )
890 mFrameJoinStyle = style;
892 QPen itemPen = pen();
893 itemPen.setJoinStyle( mFrameJoinStyle );
906 mBackgroundColor = color;
923 if ( !mItemCachedImage.isNull() )
929 return mExcludeFromExports;
934 mExcludeFromExports = exclude;
946 blendMode() != QPainter::CompositionMode_SourceOver;
956 return pen().widthF() / 2.0;
962 return rect().adjusted( -frameBleed, -frameBleed, frameBleed, frameBleed );
985 mLayout->undoStack()->beginCommand(
this, commandText, command );
991 mLayout->undoStack()->endCommand();
997 mLayout->undoStack()->cancelCommand();
1013void QgsLayoutItem::applyDataDefinedOrientation(
double &width,
double &height,
const QgsExpressionContext &context )
1017 if ( ok && !orientationString.isEmpty() )
1022 double heightD = 0.0, widthD = 0.0;
1023 switch ( orientation )
1027 heightD = std::max( height, width );
1028 widthD = std::min( height, width );
1033 heightD = std::min( height, width );
1034 widthD = std::max( height, width );
1063 double evaluatedWidth = size.
width();
1064 double evaluatedHeight = size.
height();
1068 evaluatedWidth = convertedSize.
width();
1069 evaluatedHeight = convertedSize.
height();
1077 applyDataDefinedOrientation( evaluatedWidth, evaluatedHeight, context );
1082QPainter::CompositionMode QgsLayoutItem::blendModeForRender()
const
1084 QPainter::CompositionMode mode = mEvaluatedBlendMode;
1088 mode = QPainter::CompositionMode_SourceOver;
1095 mode = QPainter::CompositionMode_SourceOver;
1100double QgsLayoutItem::applyDataDefinedRotation(
const double rotation )
1109 return evaluatedRotation;
1149 const bool exclude = mExcludeFromExports;
1159 if ( angle >= 360.0 || angle <= -360.0 )
1161 angle = std::fmod( angle, 360.0 );
1166 const double rotationRequired = angle - rotation();
1169 mItemRotation = angle;
1172void QgsLayoutItem::updateStoredItemPosition()
1175 mItemPosition =
mLayout->convertFromLayoutUnits( layoutPosReferencePoint, mItemPosition.
units() );
1180 double evaluatedAngle = angle + rotation();
1182 mItemRotation = evaluatedAngle;
1184 QPointF itemTransformOrigin = mapFromScene( transformOrigin );
1203 Q_UNUSED( visitor );
1222 if ( !mItemCachedImage.isNull() )
1224 mItemCachedImage = QImage();
1243 painter->setRenderHint( QPainter::Antialiasing,
false );
1244 painter->setPen( Qt::NoPen );
1245 painter->setBrush( QColor( 100, 255, 100, 200 ) );
1246 painter->drawRect( rect() );
1252 path.addRect( QRectF( 0, 0, rect().width(), rect().height() ) );
1258 if ( !mFrame || !context.
painter() )
1261 QPainter *p = context.
painter();
1266 p->setBrush( Qt::NoBrush );
1274 if ( !mBackground || !context.
painter() )
1279 QPainter *p = context.
painter();
1280 p->setBrush( brush() );
1281 p->setPen( Qt::NoPen );
1290 bool fitsInCache =
false;
1291 const int xSize = std::floor(
static_cast<double>( QFontMetrics( QFont() ).horizontalAdvance(
'X' ) ) * painter->device()->devicePixelRatioF() );
1292 const QImage refreshingImage =
QgsApplication::svgCache()->
svgAsImage( QStringLiteral(
":/images/composer/refreshing_item.svg" ), xSize * 3, QColor(), QColor(), 1, 1, fitsInCache );
1295 painter->scale( 1.0 / previewScaleFactor / painter->device()->devicePixelRatioF(), 1.0 / previewScaleFactor / painter->device()->devicePixelRatioF() );
1296 painter->drawImage( xSize, xSize, refreshingImage );
1307 mMinimumSize = size;
1326QPointF QgsLayoutItem::itemPositionAtReferencePoint(
const ReferencePoint reference,
const QSizeF size )
const
1328 switch ( reference )
1331 return QPointF( size.width() / 2.0, 0 );
1333 return QPointF( size.width(), 0 );
1335 return QPointF( 0, size.height() / 2.0 );
1337 return QPointF( size.width() / 2.0, size.height() / 2.0 );
1339 return QPointF( size.width(), size.height() / 2.0 );
1341 return QPointF( 0, size.height() );
1343 return QPointF( size.width() / 2.0, size.height() );
1345 return QPointF( size.width(), size.height() );
1347 return QPointF( 0, 0 );
1350 return QPointF( 0, 0 );
1355 const QPointF itemPosition = mapFromScene( position );
1356 const QPointF adjustedPointInsideItem = itemPosition - itemPositionAtReferencePoint( reference, size );
1357 return mapToScene( adjustedPointInsideItem );
1362 const QPointF pointWithinItem = itemPositionAtReferencePoint( reference, rect().size() );
1363 return mapToScene( pointWithinItem );
1368 const QPointF topLeft =
mLayout->convertToLayoutUnits( point );
1369 const QPointF refPoint = topLeft + itemPositionAtReferencePoint( mReferencePoint, rect().size() );
1370 return mLayout->convertFromLayoutUnits( refPoint, point.
units() );
1384void QgsLayoutItem::initConnectionsToLayout()
1391void QgsLayoutItem::preparePainter( QPainter *painter )
1393 if ( !painter || !painter->device() )
1398 painter->setRenderHint( QPainter::Antialiasing, shouldDrawAntialiased() );
1403bool QgsLayoutItem::shouldDrawAntialiased()
const
1412bool QgsLayoutItem::shouldDrawDebugRect()
const
1417QSizeF QgsLayoutItem::applyMinimumSize(
const QSizeF targetSize )
1423 const QSizeF minimumSizeLayoutUnits =
mLayout->convertToLayoutUnits(
minimumSize() );
1424 return targetSize.expandedTo( minimumSizeLayoutUnits );
1427QSizeF QgsLayoutItem::applyFixedSize(
const QSizeF targetSize )
1434 QSizeF size = targetSize;
1435 const QSizeF fixedSizeLayoutUnits =
mLayout->convertToLayoutUnits(
fixedSize() );
1436 if ( fixedSizeLayoutUnits.width() > 0 )
1437 size.setWidth( fixedSizeLayoutUnits.width() );
1438 if ( fixedSizeLayoutUnits.height() > 0 )
1439 size.setHeight( fixedSizeLayoutUnits.height() );
1446 double r = mItemRotation;
1458 if ( !transformPoint.isNull() )
1462 QLineF refLine = QLineF( mapToScene( transformPoint ), mapToScene( QPointF( 0, 0 ) ) );
1464 refLine.setAngle( refLine.angle() - r + rotation() );
1466 const QPointF rotatedReferencePoint = refLine.p2();
1467 setPos( rotatedReferencePoint );
1470 setTransformOriginPoint( 0, 0 );
1471 QGraphicsItem::setRotation( r );
1474 updateStoredItemPosition();
1489 mEvaluatedOpacity = opacity / 100.0;
1495 setOpacity( mEvaluatedOpacity );
1508 setPen( Qt::NoPen );
1518 itemPen = QPen( frameColor );
1522 itemPen = QPen( mFrameColor );
1524 itemPen.setJoinStyle( mFrameJoinStyle );
1527 itemPen.setWidthF(
mLayout->convertToLayoutUnits( mFrameWidth ) );
1529 itemPen.setWidthF( mFrameWidth.
length() );
1541 return useDataDefined ? brush().color() : mBackgroundColor;
1556 setBrush( QBrush( mBackgroundColor, Qt::SolidPattern ) );
1566 QPainter::CompositionMode
blendMode = mBlendMode;
1571 if ( ok && !blendStr.isEmpty() )
1573 const QString blendstr = blendStr.trimmed();
1583 setCacheMode( QGraphicsItem::DeviceCoordinateCache );
1585 setCacheMode( QGraphicsItem::NoCache );
LayoutUnit
Layout measurement units.
@ Millimeters
Millimeters.
BlendMode
Blending modes defining the available composition modes that can be used when painting.
Base class for commands to undo/redo layout and layout object changes.
QColor valueAsColor(int key, const QgsExpressionContext &context, const QColor &defaultColor=QColor(), bool *ok=nullptr) const
Calculates the current value of the property with the specified key and interprets it as a color.
bool valueAsBool(int key, const QgsExpressionContext &context, bool defaultValue=false, bool *ok=nullptr) const
Calculates the current value of the property with the specified key and interprets it as an boolean.
double valueAsDouble(int key, const QgsExpressionContext &context, double defaultValue=0.0, bool *ok=nullptr) const
Calculates the current value of the property with the specified key and interprets it as a double.
QString valueAsString(int key, const QgsExpressionContext &context, const QString &defaultString=QString(), bool *ok=nullptr) const
Calculates the current value of the property with the specified key and interprets it as a string.
static QgsPageSizeRegistry * pageSizeRegistry()
Returns the application's page size registry, used for managing layout page sizes.
static QgsLayoutItemRegistry * layoutItemRegistry()
Returns the application's layout item registry, used for layout item types.
static QIcon getThemeIcon(const QString &name, const QColor &fillColor=QColor(), const QColor &strokeColor=QColor())
Helper to get a theme icon.
static QgsSvgCache * svgCache()
Returns the application's SVG cache, used for caching SVG images and handling parameter replacement w...
static QgsExpressionContextScope * layoutItemScope(const QgsLayoutItem *item)
Creates a new scope which contains variables and functions relating to a QgsLayoutItem.
Expression contexts are used to encapsulate the parameters around which a QgsExpression should be eva...
void appendScope(QgsExpressionContextScope *scope)
Appends a scope to the end of the context.
A geometry is the spatial representation of a feature.
static void multiplyOpacity(QImage &image, double factor, QgsFeedback *feedback=nullptr)
Multiplies opacity of image pixel values by a factor.
A container for grouping several QgsLayoutItems.
Item representing the paper in a layout.
Orientation
Page orientation.
@ Landscape
Landscape orientation.
@ Portrait
Portrait orientation.
@ LayoutItem
Base class for items.
Contains settings and helpers relating to a render of a QgsLayoutItem.
QgsLayoutItemRenderContext(QgsRenderContext &context, double viewScaleFactor=1.0)
Constructor for QgsLayoutItemRenderContext.
virtual void drawDebugRect(QPainter *painter)
Draws a debugging rectangle of the item's current bounds within the specified painter.
virtual void drawFrame(QgsRenderContext &context)
Draws the frame around the item.
QgsAbstractLayoutUndoCommand * createCommand(const QString &text, int id, QUndoCommand *parent=nullptr) override
Creates a new layout undo command with the specified text and parent.
virtual QgsGeometry clipPath() const
Returns the clipping path generated by this item, in layout coordinates.
virtual QPainterPath framePath() const
Returns the path to use when drawing the item's frame or background.
virtual void cleanup()
Called just before a batch of items are deleted, allowing them to run cleanup tasks.
bool isGroupMember() const
Returns true if the item is part of a QgsLayoutItemGroup group.
QColor backgroundColor(bool useDataDefined=true) const
Returns the background color for this item.
void drawRefreshingOverlay(QPainter *painter, const QStyleOptionGraphicsItem *itemStyle)
Draws a "refreshing" overlay icon on the item.
bool writeXml(QDomElement &parentElement, QDomDocument &document, const QgsReadWriteContext &context) const
Stores the item state in a DOM element.
virtual void refreshDataDefinedProperty(QgsLayoutObject::DataDefinedProperty property=QgsLayoutObject::DataDefinedProperty::AllProperties)
Refreshes a data defined property for the item by reevaluating the property's value and redrawing the...
virtual void setFrameStrokeWidth(QgsLayoutMeasurement width)
Sets the frame stroke width.
virtual bool accept(QgsStyleEntityVisitorInterface *visitor) const
Accepts the specified style entity visitor, causing it to visit all style entities associated with th...
void refreshItemRotation(QPointF *origin=nullptr)
Refreshes an item's rotation by rechecking it against any possible overrides such as data defined rot...
UndoCommand
Layout item undo commands, used for collapsing undo commands.
QgsLayoutItemGroup * parentGroup() const
Returns the item's parent group, if the item is part of a QgsLayoutItemGroup group.
double itemRotation() const
Returns the current rotation for the item, in degrees clockwise.
QgsLayoutItem(QgsLayout *layout, bool manageZValue=true)
Constructor for QgsLayoutItem, with the specified parent layout.
virtual void setSelected(bool selected)
Sets whether the item should be selected.
QPointF adjustPointForReferencePosition(QPointF point, QSizeF size, ReferencePoint reference) const
Adjusts the specified point at which a reference position of the item sits and returns the top left c...
virtual void zoomContent(double factor, QPointF point)
Zooms content of item.
virtual void setItemRotation(double rotation, bool adjustPosition=true)
Sets the layout item's rotation, in degrees clockwise.
void rotationChanged(double newRotation)
Emitted on item rotation change.
virtual QgsLayoutItem::ExportLayerDetail exportLayerDetails() const
Returns the details for the specified current export layer.
void setBackgroundColor(const QColor &color)
Sets the background color for this item.
virtual QIcon icon() const
Returns the item's icon.
void paint(QPainter *painter, const QStyleOptionGraphicsItem *itemStyle, QWidget *pWidget) override
Handles preparing a paint surface for the layout item and painting the item's content.
bool excludeFromExports() const
Returns whether the item should be excluded from layout exports and prints.
virtual bool nextExportPart()
Moves to the next export part for a multi-layered export item, during a multi-layered export.
double itemOpacity() const
Returns the item's opacity.
virtual QRectF rectWithFrame() const
Returns the item's rectangular bounds, including any bleed caused by the item's frame.
void beginCommand(const QString &commandText, UndoCommand command=UndoNone)
Starts new undo command for this item.
void cancelCommand()
Cancels the current item command and discards it.
void setItemOpacity(double opacity)
Sets the item's opacity.
virtual void setVisibility(bool visible)
Sets whether the item is visible.
virtual void redraw()
Triggers a redraw (update) of the item.
QgsLayoutPoint positionWithUnits() const
Returns the item's current position, including units.
QgsLayoutPoint topLeftToReferencePoint(const QgsLayoutPoint &point) const
Returns the position for the reference point of the item, if the top-left of the item was placed at t...
ReferencePoint
Fixed position reference point.
@ LowerMiddle
Lower center of item.
@ MiddleLeft
Middle left of item.
@ UpperRight
Upper right corner of item.
@ LowerLeft
Lower left corner of item.
@ UpperLeft
Upper left corner of item.
@ UpperMiddle
Upper center of item.
@ MiddleRight
Middle right of item.
@ LowerRight
Lower right corner of item.
virtual void startLayeredExport()
Starts a multi-layer export operation.
virtual bool writePropertiesToElement(QDomElement &element, QDomDocument &document, const QgsReadWriteContext &context) const
Stores item state within an XML DOM element.
void endCommand()
Completes the current item command and push it onto the layout's undo stack.
void refreshItemSize()
Refreshes an item's size by rechecking it against any possible item fixed or minimum sizes.
int page() const
Returns the page the item is currently on, with the first page returning 0.
QgsExpressionContext createExpressionContext() const override
This method needs to be reimplemented in all classes which implement this interface and return an exp...
virtual void setId(const QString &id)
Set the item's id name.
void setFrameStrokeColor(const QColor &color)
Sets the frame stroke color.
virtual void finalizeRestoreFromXml()
Called after all pending items have been restored from XML.
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 rotateItem(double angle, QPointF transformOrigin)
Rotates the item by a specified angle in degrees clockwise around a specified reference point.
bool readXml(const QDomElement &itemElement, const QDomDocument &document, const QgsReadWriteContext &context)
Sets the item state from a DOM element.
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.
~QgsLayoutItem() override
int type() const override
Returns a unique graphics item type identifier.
virtual void drawBackground(QgsRenderContext &context)
Draws the background for the item.
virtual QString displayName() const
Gets item display name.
virtual QgsLayoutSize minimumSize() const
Returns the minimum allowed size of the item, if applicable, or an empty size if item can be freely r...
virtual void attemptResize(const QgsLayoutSize &size, bool includesFrame=false)
Attempts to resize the item to a specified target size.
virtual bool requiresRasterization() const
Returns true if the item is drawn in such a way that forces the whole layout to be rasterized when ex...
bool shouldDrawItem() const
Returns whether the item should be drawn in the current context.
virtual void moveContent(double dx, double dy)
Moves the content of the item, by a specified dx and dy in layout units.
@ FlagOverridesPaint
Item overrides the default layout item painting method.
@ FlagDisableSceneCaching
Item should not have QGraphicsItem caching enabled.
virtual void stopLayeredExport()
Stops a multi-layer export operation.
virtual bool containsAdvancedEffects() const
Returns true if the item contains contents with blend modes or transparency effects which can only be...
virtual QgsLayoutSize fixedSize() const
Returns the fixed size of the item, if applicable, or an empty size if item can be freely resized.
virtual void setMoveContentPreviewOffset(double dx, double dy)
Sets temporary offset for the item, by a specified dx and dy in layout units.
void setExcludeFromExports(bool exclude)
Sets whether the item should be excluded from layout exports and prints.
void sizePositionChanged()
Emitted when the item's size or position changes.
void lockChanged()
Emitted if the item's lock status changes.
virtual QSizeF applyItemSizeConstraint(QSizeF targetSize)
Applies any item-specific size constraint handling to a given targetSize in layout units.
virtual void invalidateCache()
Forces a deferred update of any cached image the item uses.
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.
QPointF pagePos() const
Returns the item's position (in layout units) relative to the top left corner of its current page.
QString id() const
Returns the item's ID name.
void setBlendMode(QPainter::CompositionMode mode)
Sets the item's composition blending mode.
bool frameEnabled() const
Returns true if the item includes a frame.
void frameChanged()
Emitted if the item's frame style changes.
virtual Flags itemFlags() const
Returns the item's flags, which indicate how the item behaves.
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.
virtual bool readPropertiesFromElement(const QDomElement &element, const QDomDocument &document, const QgsReadWriteContext &context)
Sets item state from a DOM element.
ExportLayerBehavior
Behavior of item when exporting to layered outputs.
@ CanGroupWithAnyOtherItem
Item can be placed on a layer with any other item (default behavior)
virtual Q_DECL_DEPRECATED int numberExportLayers() const
Returns the number of layers that this item requires for exporting during layered exports (e....
virtual bool isRefreshing() const
Returns true if the item is currently refreshing content in the background.
void refreshBlendMode()
Refresh item's blend mode, considering data defined blend mode.
void setParentGroup(QgsLayoutItemGroup *group)
Sets the item's parent group.
QPointF positionAtReferencePoint(ReferencePoint reference) const
Returns the current position (in layout units) of a reference point for the item.
void refreshOpacity(bool updateItem=true)
Refresh item's opacity, considering data defined opacity.
QgsLayoutSize applyDataDefinedSize(const QgsLayoutSize &size)
Applies any present data defined size overrides to the specified layout size.
virtual void setMinimumSize(const QgsLayoutSize &size)
Sets the minimum allowed size for the layout item.
void refresh() override
Refreshes the item, causing a recalculation of any property overrides and recalculation of its positi...
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.
virtual double estimatedFrameBleed() const
Returns the estimated amount the item's frame bleeds outside the item's actual rectangle.
virtual ExportLayerBehavior exportLayerBehavior() const
Returns the behavior of this item during exporting to layered exports (e.g.
void setBackgroundEnabled(bool drawBackground)
Sets whether this item has a background drawn under it or not.
void refreshItemPosition()
Refreshes an item's position by rechecking it against any possible overrides such as data defined pos...
virtual void setFixedSize(const QgsLayoutSize &size)
Sets a fixed size for the layout item, which prevents it from being freely resized.
QPainter::CompositionMode blendMode() const
Returns the item's composition blending mode.
virtual void draw(QgsLayoutItemRenderContext &context)=0
Draws the item's contents using the specified item render context.
QgsLayoutPoint pagePositionWithUnits() const
Returns the item's position (in item units) relative to the top left corner of its current page.
This class provides a method of storing measurements for use in QGIS layouts using a variety of diffe...
static QgsLayoutMeasurement decodeMeasurement(const QString &string)
Decodes a measurement from a string.
QString encodeMeasurement() const
Encodes the layout measurement to a string.
double length() const
Returns the length of the measurement.
A base class for objects which belong to a layout.
QgsPropertyCollection mDataDefinedProperties
bool readObjectPropertiesFromElement(const QDomElement &parentElement, const QDomDocument &document, const QgsReadWriteContext &context)
Sets object properties from a DOM element.
const QgsLayout * layout() const
Returns the layout the object is attached to.
void changed()
Emitted when the object's properties change.
virtual void refresh()
Refreshes the object, causing a recalculation of any property overrides.
QPointer< QgsLayout > mLayout
QgsExpressionContext createExpressionContext() const override
Creates an expression context relating to the objects' current state.
DataDefinedProperty
Data defined properties for different item types.
@ PositionX
X position on page.
@ ItemWidth
Width of item.
@ ExcludeFromExports
Exclude item from exports.
@ ItemRotation
Rotation of item.
@ PositionY
Y position on page.
@ PaperOrientation
Paper orientation.
@ ItemHeight
Height of item.
@ BackgroundColor
Item background color.
@ BlendMode
Item blend mode.
@ PresetPaperSize
Preset paper size for composition.
@ FrameColor
Item frame color.
@ AllProperties
All properties for item.
bool writeObjectPropertiesToElement(QDomElement &parentElement, QDomDocument &document, const QgsReadWriteContext &context) const
Stores object properties within an XML DOM element.
This class provides a method of storing points, consisting of an x and y coordinate,...
double x() const
Returns x coordinate of point.
QPointF toQPointF() const
Converts the layout point to a QPointF.
QString encodePoint() const
Encodes the layout point to a string.
void setX(const double x)
Sets the x coordinate of point.
static QgsLayoutPoint decodePoint(const QString &string)
Decodes a point from a string.
double y() const
Returns y coordinate of point.
Qgis::LayoutUnit units() const
Returns the units for the point.
void setY(const double y)
Sets y coordinate of point.
@ FlagDebug
Debug/testing mode, items are drawn as solid rectangles.
@ FlagUseAdvancedEffects
Enable advanced effects such as blend modes.
@ FlagLosslessImageRendering
Render images losslessly whenever possible, instead of the default lossy jpeg rendering used for some...
@ FlagAntialiasing
Use antialiasing when drawing items.
@ FlagForceVectorOutput
Force output in vector format where possible, even if items require rasterization to keep their corre...
This class provides a method of storing sizes, consisting of a width and height, for use in QGIS layo...
static QgsLayoutSize decodeSize(const QString &string)
Decodes a size from a string.
double height() const
Returns the height of the size.
void setWidth(const double width)
Sets the width for the size.
Qgis::LayoutUnit units() const
Returns the units for the size.
double width() const
Returns the width of the size.
QString encodeSize() const
Encodes the layout size to a string.
void setHeight(const double height)
Sets the height for the size.
static QgsRenderContext createRenderContextForLayout(QgsLayout *layout, QPainter *painter, double dpi=-1)
Creates a render context suitable for the specified layout and painter destination.
static bool itemIsAClippingSource(const QgsLayoutItem *item)
Returns true if an item is a clipping item for another layout item.
static QgsLayoutItemPage::Orientation decodePaperOrientation(const QString &string, bool &ok)
Decodes a string representing a paper orientation and returns the decoded orientation.
static double normalizedAngle(double angle, bool allowNegative=false)
Ensures that an angle (in degrees) is in the range 0 <= angle < 360.
static Q_DECL_DEPRECATED double scaleFactorFromItemStyle(const QStyleOptionGraphicsItem *style)
Extracts the scale factor from an item style.
Base class for layouts, which can contain items such as maps, labels, scalebars, etc.
@ ZItem
Minimum z value for items.
Qgis::LayoutUnit units() const
Returns the native units for the layout.
A named page size for layouts.
QgsLayoutSize size
Page size.
static Qgis::BlendMode getBlendModeEnum(QPainter::CompositionMode blendMode)
Returns a Qgis::BlendMode corresponding to a QPainter::CompositionMode.
static QPainter::CompositionMode getCompositionMode(Qgis::BlendMode blendMode)
Returns a QPainter::CompositionMode corresponding to a Qgis::BlendMode.
bool isActive(int key) const final
Returns true if the collection contains an active property with the specified key.
The class is used as a container of context for various read/write operations on other objects.
Contains information about the context of a rendering operation.
double scaleFactor() const
Returns the scaling factor for the render to convert painter units to physical sizes.
QPainter * painter()
Returns the destination QPainter for the render operation.
void setPainterFlagsUsingContext(QPainter *painter=nullptr) const
Sets relevant flags on a destination painter, using the flags and settings currently defined for the ...
void setExpressionContext(const QgsExpressionContext &context)
Sets the expression context.
Scoped object for saving and restoring a QPainter object's state.
An interface for classes which can visit style entity (e.g.
QImage svgAsImage(const QString &path, double size, const QColor &fill, const QColor &stroke, double strokeWidth, double widthScaleFactor, bool &fitsInCache, double fixedAspectRatio=0, bool blocking=false, const QMap< QString, QString > ¶meters=QMap< QString, QString >())
Returns an SVG drawing as a QImage.
static Qt::PenJoinStyle decodePenJoinStyle(const QString &str)
static QPainter::CompositionMode decodeBlendMode(const QString &s)
static QString encodePenJoinStyle(Qt::PenJoinStyle style)
#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)
Contains details of a particular export layer relating to a layout item.