void QgsComposerItem::setBlendMode( const QPainter::CompositionMode blendMode )
{
mBlendMode = blendMode;
// Update the composer effect to use the new blend mode
QgsExpressionContext context = createExpressionContext();
refreshBlendMode( context );
}
void QgsLayoutItemPicture::refreshPicture( const QgsExpressionContext *context )
{
QgsExpressionContext scopedContext = createExpressionContext();
const QgsExpressionContext *evalContext = context ? context : &scopedContext;
QString source = mSourcePath;
//data defined source set?
mHasExpressionError = false;
if ( mDataDefinedProperties.isActive( QgsLayoutObject::PictureSource ) )
{
bool ok = false;
source = mDataDefinedProperties.valueAsString( QgsLayoutObject::PictureSource, *evalContext, source, &ok );
if ( ok )
{
source = source.trimmed();
QgsDebugMsg( QString( "exprVal PictureSource:%1" ).arg( source ) );
}
else
{
mHasExpressionError = true;
source = QString();
QgsMessageLog::logMessage( tr( "Picture expression eval error" ) );
}
}
loadPicture( source );
}
void QgsComposerNodesItem::drawSelectedNode( QPainter *painter ) const
{
double rectSize = 3.0 / horizontalViewScaleFactor();
QgsStringMap properties;
properties.insert( "name", "square" );
properties.insert( "color", "0, 0, 0, 0" );
properties.insert( "color_border", "blue" );
properties.insert( "width_border", "4" );
QScopedPointer<QgsMarkerSymbolV2> symbol;
symbol.reset( QgsMarkerSymbolV2::createSimple( properties ) );
symbol.data()->setSize( rectSize );
QgsMapSettings ms = mComposition->mapSettings();
ms.setOutputDpi( painter->device()->logicalDpiX() );
QgsRenderContext context = QgsRenderContext::fromMapSettings( ms );
context.setPainter( painter );
context.setForceVectorOutput( true );
QScopedPointer<QgsExpressionContext> expressionContext;
expressionContext.reset( createExpressionContext() );
context.setExpressionContext( *expressionContext.data() );
symbol.data()->startRender( context );
symbol.data()->renderPoint( mPolygon.at( mSelectedNode ), nullptr, context );
symbol.data()->stopRender( context );
}
void QgsComposerItem::setBlendMode( const QPainter::CompositionMode blendMode )
{
mBlendMode = blendMode;
// Update the composer effect to use the new blend mode
QScopedPointer< QgsExpressionContext > context( createExpressionContext() );
refreshBlendMode( *context.data() );
}
bool QgsLayoutAtlas::updateFilenameExpression( QString &error )
{
if ( !mCoverageLayer )
{
return false;
}
QgsExpressionContext expressionContext = createExpressionContext();
if ( !mFilenameExpressionString.isEmpty() )
{
mFilenameExpression = QgsExpression( mFilenameExpressionString );
// expression used to evaluate each filename
// test for evaluation errors
if ( mFilenameExpression.hasParserError() )
{
error = mFilenameExpression.parserErrorString();
return false;
}
// prepare the filename expression
mFilenameExpression.prepare( &expressionContext );
}
// regenerate current filename
evalFeatureFilename( expressionContext );
return true;
}
void QgsComposerNodesItem::drawNodes( QPainter *painter ) const
{
double rectSize = 3.0 / horizontalViewScaleFactor();
QgsStringMap properties;
properties.insert( QStringLiteral( "name" ), QStringLiteral( "cross" ) );
properties.insert( QStringLiteral( "color_border" ), QStringLiteral( "red" ) );
std::unique_ptr<QgsMarkerSymbol> symbol;
symbol.reset( QgsMarkerSymbol::createSimple( properties ) );
symbol->setSize( rectSize );
symbol->setAngle( 45 );
QgsRenderContext context = QgsComposerUtils::createRenderContextForComposition( mComposition, painter );
context.setForceVectorOutput( true );
QgsExpressionContext expressionContext = createExpressionContext();
context.setExpressionContext( expressionContext );
symbol->startRender( context );
Q_FOREACH ( QPointF pt, mPolygon )
symbol->renderPoint( pt, nullptr, context );
symbol->stopRender( context );
if ( mSelectedNode >= 0 && mSelectedNode < mPolygon.size() )
drawSelectedNode( painter );
}
bool QgsAtlasComposition::updateFilenameExpression()
{
if ( !mCoverageLayer )
{
return false;
}
QgsExpressionContext expressionContext = createExpressionContext();
if ( !mFilenamePattern.isEmpty() )
{
mFilenameExpr.reset( new QgsExpression( mFilenamePattern ) );
// expression used to evaluate each filename
// test for evaluation errors
if ( mFilenameExpr->hasParserError() )
{
mFilenameParserError = mFilenameExpr->parserErrorString();
return false;
}
// prepare the filename expression
mFilenameExpr->prepare( &expressionContext );
}
//if atlas preview is currently enabled, regenerate filename for current feature
if ( mComposition->atlasMode() == QgsComposition::PreviewAtlas )
{
evalFeatureFilename( expressionContext );
}
return true;
}
void QgsComposerArrow::drawLine( QPainter *painter )
{
if ( ! mLineSymbol || ! mComposition )
{
return;
}
QPaintDevice* thePaintDevice = painter->device();
painter->save();
//setup painter scaling to dots so that raster symbology is drawn to scale
double dotsPerMM = thePaintDevice->logicalDpiX() / 25.4;
painter->scale( 1 / dotsPerMM, 1 / dotsPerMM ); //scale painter from mm to dots
//setup render context
QgsMapSettings ms = mComposition->mapSettings();
//context units should be in dots
ms.setOutputDpi( painter->device()->logicalDpiX() );
QgsRenderContext context = QgsRenderContext::fromMapSettings( ms );
context.setForceVectorOutput( true );
context.setPainter( painter );
QgsExpressionContext expressionContext = createExpressionContext();
context.setExpressionContext( expressionContext );
//line scaled to dots
QPolygonF line;
line << QPointF( mStartPoint.x() - pos().x(), mStartPoint.y() - pos().y() ) * dotsPerMM
<< QPointF( mStopPoint.x() - pos().x(), mStopPoint.y() - pos().y() ) * dotsPerMM;
mLineSymbol->startRender( context );
mLineSymbol->renderPolyline( line, nullptr, context );
mLineSymbol->stopRender( context );
painter->restore();
}
void QgsComposerNodesItem::drawNodes( QPainter *painter ) const
{
double rectSize = 3.0 / horizontalViewScaleFactor();
QgsStringMap properties;
properties.insert( "name", "cross" );
properties.insert( "color_border", "red" );
QScopedPointer<QgsMarkerSymbolV2> symbol;
symbol.reset( QgsMarkerSymbolV2::createSimple( properties ) );
symbol.data()->setSize( rectSize );
symbol.data()->setAngle( 45 );
QgsMapSettings ms = mComposition->mapSettings();
ms.setOutputDpi( painter->device()->logicalDpiX() );
QgsRenderContext context = QgsRenderContext::fromMapSettings( ms );
context.setPainter( painter );
context.setForceVectorOutput( true );
QScopedPointer<QgsExpressionContext> expressionContext;
expressionContext.reset( createExpressionContext() );
context.setExpressionContext( *expressionContext.data() );
symbol.data()->startRender( context );
Q_FOREACH ( QPointF pt, mPolygon )
symbol.data()->renderPoint( pt, nullptr, context );
symbol.data()->stopRender( context );
if ( mSelectedNode >= 0 && mSelectedNode < mPolygon.size() )
drawSelectedNode( painter );
}
void QgsComposerPolygon::_draw( QPainter *painter )
{
//setup painter scaling to dots so that raster symbology is drawn to scale
const double dotsPerMM = painter->device()->logicalDpiX() / 25.4;
QgsMapSettings ms = mComposition->mapSettings();
ms.setOutputDpi( painter->device()->logicalDpiX() );
QgsRenderContext context = QgsRenderContext::fromMapSettings( ms );
context.setPainter( painter );
context.setForceVectorOutput( true );
QScopedPointer<QgsExpressionContext> expressionContext;
expressionContext.reset( createExpressionContext() );
context.setExpressionContext( *expressionContext.data() );
painter->scale( 1 / dotsPerMM, 1 / dotsPerMM ); // scale painter from mm to dots
QTransform t = QTransform::fromScale( dotsPerMM, dotsPerMM );
QList<QPolygonF> rings; //empty
QPainterPath polygonPath;
polygonPath.addPolygon( mPolygon );
mPolygonStyleSymbol->startRender( context );
mPolygonStyleSymbol->renderPolygon( polygonPath.toFillPolygon( t ), &rings,
nullptr, context );
mPolygonStyleSymbol->stopRender( context );
painter->scale( dotsPerMM, dotsPerMM );
}
void QgsComposerPicture::refreshPicture( const QgsExpressionContext *context )
{
const QgsExpressionContext* evalContext = context;
QScopedPointer< QgsExpressionContext > scopedContext;
if ( !evalContext )
{
scopedContext.reset( createExpressionContext() );
evalContext = scopedContext.data();
}
QString source = mSourcePath;
//data defined source set?
mHasExpressionError = false;
QVariant exprVal;
if ( dataDefinedProperty( QgsComposerObject::PictureSource )->isActive() )
{
if ( dataDefinedEvaluate( QgsComposerObject::PictureSource, exprVal, *evalContext ) )
{
source = exprVal.toString().trimmed();
QgsDebugMsg( QString( "exprVal PictureSource:%1" ).arg( source ) );
}
else
{
mHasExpressionError = true;
source = QString();
QgsMessageLog::logMessage( tr( "Picture expression eval error" ) );
}
}
loadPicture( source );
}
void QgsComposerLegend::refreshDataDefinedProperty( const QgsComposerObject::DataDefinedProperty property, const QgsExpressionContext *context )
{
QgsExpressionContext scopedContext = createExpressionContext();
const QgsExpressionContext *evalContext = context ? context : &scopedContext;
bool forceUpdate = false;
//updates data defined properties and redraws item to match
if ( property == QgsComposerObject::LegendTitle || property == QgsComposerObject::AllProperties )
{
bool ok = false;
QString t = mDataDefinedProperties.valueAsString( QgsComposerObject::LegendTitle, *evalContext, mTitle, &ok );
if ( ok )
{
mSettings.setTitle( t );
forceUpdate = true;
}
}
if ( property == QgsComposerObject::LegendColumnCount || property == QgsComposerObject::AllProperties )
{
bool ok = false;
int cols = mDataDefinedProperties.valueAsInt( QgsComposerObject::LegendColumnCount, *evalContext, mColumnCount, &ok );
if ( ok && cols >= 0 )
{
mSettings.setColumnCount( cols );
forceUpdate = true;
}
}
if ( forceUpdate )
{
adjustBoxSize();
update();
}
QgsComposerObject::refreshDataDefinedProperty( property, context );
}
void QgsActionManager::doAction( int index, const QgsFeature& feat, int defaultValueIndex )
{
QgsExpressionContext context = createExpressionContext();
QgsExpressionContextScope* actionScope = new QgsExpressionContextScope();
actionScope->setVariable( "current_field", feat.attribute( defaultValueIndex ) );
context << actionScope;
doAction( index, feat, context );
}
void QgsComposerItem::setBackgroundColor( const QColor &backgroundColor )
{
mBackgroundColor = backgroundColor;
setBrush( QBrush( mBackgroundColor, Qt::SolidPattern ) );
// apply any datadefined overrides
QgsExpressionContext context = createExpressionContext();
refreshBackgroundColor( true, context );
}
QString QgsAttributeAction::expandAction( QString action, QgsFeature &feat, const QMap<QString, QVariant> *substitutionMap )
{
// This function currently replaces each expression between [% and %]
// in the action with the result of its evaluation on the feature
// passed as argument.
// Additional substitutions can be passed through the substitutionMap
// parameter
QString expr_action;
int index = 0;
while ( index < action.size() )
{
QRegExp rx = QRegExp( "\\[%([^\\]]+)%\\]" );
int pos = rx.indexIn( action, index );
if ( pos < 0 )
break;
int start = index;
index = pos + rx.matchedLength();
QString to_replace = rx.cap( 1 ).trimmed();
QgsDebugMsg( "Found expression: " + to_replace );
if ( substitutionMap && substitutionMap->contains( to_replace ) )
{
expr_action += action.mid( start, pos - start ) + substitutionMap->value( to_replace ).toString();
continue;
}
QgsExpression exp( to_replace );
if ( exp.hasParserError() )
{
QgsDebugMsg( "Expression parser error: " + exp.parserErrorString() );
expr_action += action.mid( start, index - start );
continue;
}
QgsExpressionContext context = createExpressionContext();
context.setFeature( feat );
QVariant result = exp.evaluate( &context );
if ( exp.hasEvalError() )
{
QgsDebugMsg( "Expression parser eval error: " + exp.evalErrorString() );
expr_action += action.mid( start, index - start );
continue;
}
QgsDebugMsg( "Expression result is: " + result.toString() );
expr_action += action.mid( start, pos - start ) + result.toString();
}
expr_action += action.mid( index );
return expr_action;
}
QString QgsComposerLabel::displayText() const
{
QString displayText = mText;
replaceDateText( displayText );
QgsExpressionContext context = createExpressionContext();
return QgsExpression::replaceExpressionText( displayText, &context, mDistanceArea );
}
QString QgsLayoutItemLabel::currentText() const
{
QString displayText = mText;
replaceDateText( displayText );
QgsExpressionContext context = createExpressionContext();
return QgsExpression::replaceExpressionText( displayText, &context, mDistanceArea.get() );
}
void QgsPaperItem::paint( QPainter* painter, const QStyleOptionGraphicsItem* itemStyle, QWidget* pWidget )
{
Q_UNUSED( itemStyle );
Q_UNUSED( pWidget );
if ( !painter || !mComposition || !mComposition->pagesVisible() )
{
return;
}
//setup painter scaling to dots so that raster symbology is drawn to scale
double dotsPerMM = painter->device()->logicalDpiX() / 25.4;
//setup render context
QgsMapSettings ms = mComposition->mapSettings();
//context units should be in dots
ms.setOutputDpi( painter->device()->logicalDpiX() );
QgsRenderContext context = QgsRenderContext::fromMapSettings( ms );
context.setPainter( painter );
context.setForceVectorOutput( true );
QgsExpressionContext* expressionContext = createExpressionContext();
context.setExpressionContext( *expressionContext );
delete expressionContext;
painter->save();
if ( mComposition->plotStyle() == QgsComposition::Preview )
{
//if in preview mode, draw page border and shadow so that it's
//still possible to tell where pages with a transparent style begin and end
painter->setRenderHint( QPainter::Antialiasing, false );
//shadow
painter->setBrush( QBrush( QColor( 150, 150, 150 ) ) );
painter->setPen( Qt::NoPen );
painter->drawRect( QRectF( 1, 1, rect().width() + 1, rect().height() + 1 ) );
//page area
painter->setBrush( QColor( 215, 215, 215 ) );
painter->setPen( QPen( QColor( 100, 100, 100 ) ) );
painter->drawRect( QRectF( 0, 0, rect().width(), rect().height() ) );
}
painter->scale( 1 / dotsPerMM, 1 / dotsPerMM ); // scale painter from mm to dots
painter->setRenderHint( QPainter::Antialiasing );
mComposition->pageStyleSymbol()->startRender( context );
calculatePageMargin();
QPolygonF pagePolygon = QPolygonF( QRectF( mPageMargin * dotsPerMM, mPageMargin * dotsPerMM,
( rect().width() - 2 * mPageMargin ) * dotsPerMM, ( rect().height() - 2 * mPageMargin ) * dotsPerMM ) );
QList<QPolygonF> rings; //empty list
mComposition->pageStyleSymbol()->renderPolygon( pagePolygon, &rings, nullptr, context );
mComposition->pageStyleSymbol()->stopRender( context );
painter->restore();
}
void QgsLayoutItemHtml::refreshDataDefinedProperty( const QgsLayoutObject::DataDefinedProperty property )
{
QgsExpressionContext context = createExpressionContext();
//updates data defined properties and redraws item to match
if ( property == QgsLayoutObject::SourceUrl || property == QgsLayoutObject::AllProperties )
{
loadHtml( true, &context );
}
}
void QgsComposerObject::prepareDataDefinedExpressions() const
{
QScopedPointer< QgsExpressionContext > context( createExpressionContext() );
//prepare all QgsDataDefineds
QMap< DataDefinedProperty, QgsDataDefined* >::const_iterator it = mDataDefinedProperties.constBegin();
if ( it != mDataDefinedProperties.constEnd() )
{
it.value()->prepareExpression( *context.data() );
}
}
void QgsActionManager::doAction( const QUuid& actionId, const QgsFeature& feature, int defaultValueIndex )
{
QgsExpressionContext context = createExpressionContext();
QgsExpressionContextScope* actionScope = new QgsExpressionContextScope();
actionScope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "field_index" ), defaultValueIndex, true ) );
if ( defaultValueIndex >= 0 && defaultValueIndex < feature.fields().size() )
actionScope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "field_name" ), feature.fields().at( defaultValueIndex ).name(), true ) );
actionScope->addVariable( QgsExpressionContextScope::StaticVariable( QStringLiteral( "field_value" ), feature.attribute( defaultValueIndex ), true ) );
context << actionScope;
doAction( actionId, feature, context );
}
void QgsComposerItem::setItemRotation( const double r, const bool adjustPosition )
{
mItemRotation = r;
if ( mItemRotation >= 360.0 || mItemRotation <= -360.0 )
{
mItemRotation = std::fmod( mItemRotation, 360.0 );
}
QgsExpressionContext context = createExpressionContext();
refreshRotation( true, adjustPosition, context );
}
void QgsLayoutItemPicture::refreshDataDefinedProperty( const QgsLayoutObject::DataDefinedProperty property )
{
if ( property == QgsLayoutObject::PictureSource || property == QgsLayoutObject::PictureSvgBackgroundColor
|| property == QgsLayoutObject::PictureSvgStrokeColor || property == QgsLayoutObject::PictureSvgStrokeWidth
|| property == QgsLayoutObject::AllProperties )
{
QgsExpressionContext context = createExpressionContext();
refreshPicture( &context );
}
QgsLayoutItem::refreshDataDefinedProperty( property );
}
void QgsComposerHtml::refreshDataDefinedProperty( const QgsComposerObject::DataDefinedProperty property, const QgsExpressionContext* context )
{
QgsExpressionContext scopedContext = createExpressionContext();
const QgsExpressionContext* evalContext = context ? context : &scopedContext;
//updates data defined properties and redraws item to match
if ( property == QgsComposerObject::SourceUrl || property == QgsComposerObject::AllProperties )
{
loadHtml( true, evalContext );
}
QgsComposerObject::refreshDataDefinedProperty( property, context );
}
QVariantMap QgsProcessingFeatureBasedAlgorithm::processAlgorithm( const QVariantMap ¶meters, QgsProcessingContext &context, QgsProcessingFeedback *feedback )
{
prepareSource( parameters, context );
QString dest;
std::unique_ptr< QgsFeatureSink > sink( parameterAsSink( parameters, QStringLiteral( "OUTPUT" ), context, dest,
outputFields( mSource->fields() ),
outputWkbType( mSource->wkbType() ),
outputCrs( mSource->sourceCrs() ),
sinkFlags() ) );
if ( !sink )
throw QgsProcessingException( invalidSinkError( parameters, QStringLiteral( "OUTPUT" ) ) );
// prepare expression context for feature iteration
QgsExpressionContext prevContext = context.expressionContext();
QgsExpressionContext algContext = prevContext;
algContext.appendScopes( createExpressionContext( parameters, context, mSource.get() ).takeScopes() );
context.setExpressionContext( algContext );
long count = mSource->featureCount();
QgsFeature f;
QgsFeatureIterator it = mSource->getFeatures( request(), sourceFlags() );
double step = count > 0 ? 100.0 / count : 1;
int current = 0;
while ( it.nextFeature( f ) )
{
if ( feedback->isCanceled() )
{
break;
}
context.expressionContext().setFeature( f );
const QgsFeatureList transformed = processFeature( f, context, feedback );
for ( QgsFeature transformedFeature : transformed )
sink->addFeature( transformedFeature, QgsFeatureSink::FastInsert );
feedback->setProgress( current * step );
current++;
}
mSource.reset();
// probably not necessary - context's aren't usually recycled, but can't hurt
context.setExpressionContext( prevContext );
QVariantMap outputs;
outputs.insert( QStringLiteral( "OUTPUT" ), dest );
return outputs;
}
void QgsComposerItem::refreshDataDefinedProperty( const QgsComposerObject::DataDefinedProperty property, const QgsExpressionContext *context )
{
//maintain 2.10 API
//TODO QGIS 3.0 - remove this
const QgsExpressionContext* evalContext = context;
QScopedPointer< QgsExpressionContext > scopedContext;
if ( !evalContext )
{
scopedContext.reset( createExpressionContext() );
evalContext = scopedContext.data();
}
//update data defined properties and redraw item to match
if ( property == QgsComposerObject::PositionX || property == QgsComposerObject::PositionY ||
property == QgsComposerObject::ItemWidth || property == QgsComposerObject::ItemHeight ||
property == QgsComposerObject::AllProperties )
{
QRectF beforeRect = QRectF( pos().x(), pos().y(), rect().width(), rect().height() );
QRectF evaluatedRect = evalItemRect( beforeRect, false, evalContext );
if ( evaluatedRect != beforeRect )
{
setSceneRect( evaluatedRect );
}
}
if ( property == QgsComposerObject::ItemRotation || property == QgsComposerObject::AllProperties )
{
refreshRotation( false, true, *evalContext );
}
if ( property == QgsComposerObject::Transparency || property == QgsComposerObject::AllProperties )
{
refreshTransparency( false, *evalContext );
}
if ( property == QgsComposerObject::BlendMode || property == QgsComposerObject::AllProperties )
{
refreshBlendMode( *evalContext );
}
if ( property == QgsComposerObject::ExcludeFromExports || property == QgsComposerObject::AllProperties )
{
bool exclude = mExcludeFromExports;
//data defined exclude from exports set?
QVariant exprVal;
if ( dataDefinedEvaluate( QgsComposerObject::ExcludeFromExports, exprVal, *evalContext ) && !exprVal.isNull() )
{
exclude = exprVal.toBool();
}
mEvaluatedExcludeFromExports = exclude;
}
update();
}
void QgsComposerItem::setItemRotation( const double r, const bool adjustPosition )
{
if ( r >= 360 )
{
mItemRotation = ( static_cast< int >( r ) ) % 360;
}
else
{
mItemRotation = r;
}
QScopedPointer< QgsExpressionContext > context( createExpressionContext() );
refreshRotation( true, adjustPosition, *context.data() );
}
void QgsLayoutItemPicture::loadLocalPicture( const QString &path )
{
QFile pic;
pic.setFileName( path );
if ( !pic.exists() )
{
mMode = FormatUnknown;
}
else
{
QFileInfo sourceFileInfo( pic );
QString sourceFileSuffix = sourceFileInfo.suffix();
if ( sourceFileSuffix.compare( QLatin1String( "svg" ), Qt::CaseInsensitive ) == 0 )
{
//try to open svg
QgsExpressionContext context = createExpressionContext();
QColor fillColor = mDataDefinedProperties.valueAsColor( QgsLayoutObject::PictureSvgBackgroundColor, context, mSvgFillColor );
QColor strokeColor = mDataDefinedProperties.valueAsColor( QgsLayoutObject::PictureSvgStrokeColor, context, mSvgStrokeColor );
double strokeWidth = mDataDefinedProperties.valueAsDouble( QgsLayoutObject::PictureSvgStrokeWidth, context, mSvgStrokeWidth );
const QByteArray &svgContent = QgsApplication::svgCache()->svgContent( path, rect().width(), fillColor, strokeColor, strokeWidth,
1.0 );
mSVG.load( svgContent );
if ( mSVG.isValid() )
{
mMode = FormatSVG;
QRect viewBox = mSVG.viewBox(); //take width/height ratio from view box instead of default size
mDefaultSvgSize.setWidth( viewBox.width() );
mDefaultSvgSize.setHeight( viewBox.height() );
}
else
{
mMode = FormatUnknown;
}
}
else
{
//try to open raster with QImageReader
QImageReader imageReader( pic.fileName() );
if ( imageReader.read( &mImage ) )
{
mMode = FormatRaster;
}
else
{
mMode = FormatUnknown;
}
}
}
}
void QgsComposerItem::refreshDataDefinedProperty( const QgsComposerObject::DataDefinedProperty property, const QgsExpressionContext *context )
{
//maintain 2.10 API
//TODO QGIS 3.0 - remove this
QgsExpressionContext scopedContext = createExpressionContext();
const QgsExpressionContext *evalContext = context ? context : &scopedContext;
//update data defined properties and redraw item to match
if ( property == QgsComposerObject::PositionX || property == QgsComposerObject::PositionY ||
property == QgsComposerObject::ItemWidth || property == QgsComposerObject::ItemHeight ||
property == QgsComposerObject::AllProperties )
{
QRectF beforeRect = QRectF( pos().x(), pos().y(), rect().width(), rect().height() );
QRectF evaluatedRect = evalItemRect( beforeRect, false, evalContext );
if ( evaluatedRect != beforeRect )
{
setSceneRect( evaluatedRect );
}
}
if ( property == QgsComposerObject::ItemRotation || property == QgsComposerObject::AllProperties )
{
refreshRotation( false, true, *evalContext );
}
if ( property == QgsComposerObject::Opacity || property == QgsComposerObject::AllProperties )
{
refreshOpacity( false, *evalContext );
}
if ( property == QgsComposerObject::BlendMode || property == QgsComposerObject::AllProperties )
{
refreshBlendMode( *evalContext );
}
if ( property == QgsComposerObject::FrameColor || property == QgsComposerObject::AllProperties )
{
refreshFrameColor( false, *evalContext );
}
if ( property == QgsComposerObject::BackgroundColor || property == QgsComposerObject::AllProperties )
{
refreshBackgroundColor( false, *evalContext );
}
if ( property == QgsComposerObject::ExcludeFromExports || property == QgsComposerObject::AllProperties )
{
bool exclude = mExcludeFromExports;
//data defined exclude from exports set?
exclude = mDataDefinedProperties.valueAsBool( QgsComposerObject::ExcludeFromExports, *evalContext, exclude );
mEvaluatedExcludeFromExports = exclude;
}
update();
}
void QgsComposerItem::setFrameStrokeColor( const QColor &color )
{
if ( mFrameColor == color )
{
//no change
return;
}
mFrameColor = color;
QPen itemPen = pen();
itemPen.setColor( mFrameColor );
setPen( itemPen );
// apply any datadefined overrides
QgsExpressionContext context = createExpressionContext();
refreshFrameColor( true, context );
emit frameChanged();
}
