bool QgsComposerTextTableV2::getTableContents( QgsComposerTableContents& contents )
{
contents.clear();
QList< QStringList >::const_iterator rowIt = mRowText.constBegin();
for ( ; rowIt != mRowText.constEnd(); ++rowIt )
{
QgsComposerTableRow currentRow;
for ( int i = 0; i < mColumns.count(); ++i )
{
if ( i < ( *rowIt ).count() )
{
currentRow << ( *rowIt ).at( i );
}
else
{
currentRow << QString();
}
}
contents << currentRow;
}
recalculateTableSize();
return true;
}
void QgsLayoutTable::setHeaderMode( const QgsLayoutTable::HeaderMode mode )
{
if ( mode == mHeaderMode )
{
return;
}
mHeaderMode = mode;
recalculateTableSize();
emit changed();
}
void QgsLayoutTable::setWrapBehavior( QgsLayoutTable::WrapBehavior behavior )
{
if ( behavior == mWrapBehavior )
{
return;
}
mWrapBehavior = behavior;
recalculateTableSize();
emit changed();
}
void QgsComposerTableV2::setHeaderMode( const QgsComposerTableV2::HeaderMode mode )
{
if ( mode == mHeaderMode )
{
return;
}
mHeaderMode = mode;
recalculateTableSize();
emit changed();
}
void QgsComposerTableV2::setWrapBehaviour( QgsComposerTableV2::WrapBehaviour behaviour )
{
if ( behaviour == mWrapBehaviour )
{
return;
}
mWrapBehaviour = behaviour;
recalculateTableSize();
emit changed();
}
void QgsLayoutTable::setHorizontalGrid( const bool horizontalGrid )
{
if ( horizontalGrid == mHorizontalGrid )
{
return;
}
mHorizontalGrid = horizontalGrid;
//since grid spacing has changed, we need to recalculate the table size
recalculateTableSize();
emit changed();
}
void QgsLayoutTable::setGridStrokeWidth( const double width )
{
if ( qgsDoubleNear( width, mGridStrokeWidth ) )
{
return;
}
mGridStrokeWidth = width;
//since grid spacing has changed, we need to recalculate the table size
recalculateTableSize();
emit changed();
}
void QgsLayoutTable::setHeaderFont( const QFont &font )
{
if ( font == mHeaderFont )
{
return;
}
mHeaderFont = font;
//since font attributes have changed, we need to recalculate the table size
recalculateTableSize();
emit changed();
}
void QgsComposerTableV2::setGridStrokeWidth( const double width )
{
if ( width == mGridStrokeWidth )
{
return;
}
mGridStrokeWidth = width;
//since grid spacing has changed, we need to recalculate the table size
recalculateTableSize();
emit changed();
}
void QgsLayoutTable::setVerticalGrid( const bool verticalGrid )
{
if ( verticalGrid == mVerticalGrid )
{
return;
}
mVerticalGrid = verticalGrid;
//since grid spacing has changed, we need to recalculate the table size
recalculateTableSize();
emit changed();
}
void QgsComposerTableV2::setContentFont( const QFont &font )
{
if ( font == mContentFont )
{
return;
}
mContentFont = font;
//since font attributes have changed, we need to recalculate the table size
recalculateTableSize();
emit changed();
}
void QgsComposerTableV2::setShowGrid( const bool showGrid )
{
if ( showGrid == mShowGrid )
{
return;
}
mShowGrid = showGrid;
//since grid spacing has changed, we need to recalculate the table size
recalculateTableSize();
emit changed();
}
void QgsComposerTableV2::setEmptyTableMessage( const QString message )
{
if ( message == mEmptyTableMessage )
{
return;
}
mEmptyTableMessage = message;
//since message has changed, we need to recalculate the table size
recalculateTableSize();
emit changed();
}
void QgsComposerTableV2::setEmptyTableBehaviour( const QgsComposerTableV2::EmptyTableMode mode )
{
if ( mode == mEmptyTableMode )
{
return;
}
mEmptyTableMode = mode;
//since appearance has changed, we need to recalculate the table size
recalculateTableSize();
emit changed();
}
void QgsComposerTableV2::setCellMargin( const double margin )
{
if ( margin == mCellMargin )
{
return;
}
mCellMargin = margin;
//since spacing has changed, we need to recalculate the table size
recalculateTableSize();
emit changed();
}
void QgsLayoutTable::setCellMargin( const double margin )
{
if ( qgsDoubleNear( margin, mCellMargin ) )
{
return;
}
mCellMargin = margin;
//since spacing has changed, we need to recalculate the table size
recalculateTableSize();
emit changed();
}
bool QgsComposerAttributeTableV2::getTableContents( QgsComposerTableContents &contents )
{
contents.clear();
if (( mSource == QgsComposerAttributeTableV2::AtlasFeature || mSource == QgsComposerAttributeTableV2::RelationChildren )
&& !mComposition->atlasComposition().enabled() )
{
//source mode requires atlas, but atlas disabled
return false;
}
QgsVectorLayer* layer = sourceLayer();
if ( !layer )
{
//no source layer
return false;
}
//prepare filter expression
std::auto_ptr<QgsExpression> filterExpression;
bool activeFilter = false;
if ( mFilterFeatures && !mFeatureFilter.isEmpty() )
{
filterExpression = std::auto_ptr<QgsExpression>( new QgsExpression( mFeatureFilter ) );
if ( !filterExpression->hasParserError() )
{
activeFilter = true;
}
}
QgsRectangle selectionRect;
if ( mComposerMap && mShowOnlyVisibleFeatures )
{
selectionRect = *mComposerMap->currentMapExtent();
if ( layer && mComposition->mapSettings().hasCrsTransformEnabled() )
{
//transform back to layer CRS
QgsCoordinateTransform coordTransform( layer->crs(), mComposition->mapSettings().destinationCrs() );
try
{
selectionRect = coordTransform.transformBoundingBox( selectionRect, QgsCoordinateTransform::ReverseTransform );
}
catch ( QgsCsException &cse )
{
Q_UNUSED( cse );
return false;
}
}
}
QgsFeatureRequest req;
if ( mSource == QgsComposerAttributeTableV2::RelationChildren )
{
QgsRelation relation = QgsProject::instance()->relationManager()->relation( mRelationId );
QgsFeature* atlasFeature = mComposition->atlasComposition().currentFeature();
if ( atlasFeature )
{
req = relation.getRelatedFeaturesRequest( *atlasFeature );
}
else
{
//no atlas feature, so empty table
return true;
}
}
if ( !selectionRect.isEmpty() )
req.setFilterRect( selectionRect );
req.setFlags( mShowOnlyVisibleFeatures ? QgsFeatureRequest::ExactIntersect : QgsFeatureRequest::NoFlags );
if ( mSource == QgsComposerAttributeTableV2::AtlasFeature
&& mComposition->atlasComposition().enabled() )
{
//source mode is current atlas feature
QgsFeature* atlasFeature = mComposition->atlasComposition().currentFeature();
if ( atlasFeature )
{
req.setFilterFid( atlasFeature->id() );
}
else
{
//no atlas feature, so empty table
return true;
}
}
QgsFeature f;
int counter = 0;
QgsFeatureIterator fit = layer->getFeatures( req );
while ( fit.nextFeature( f ) && counter < mMaximumNumberOfFeatures )
{
//check feature against filter
if ( activeFilter )
{
QVariant result = filterExpression->evaluate( &f, layer->pendingFields() );
// skip this feature if the filter evaluation is false
if ( !result.toBool() )
{
continue;
}
}
//check against atlas feature intersection
if ( mFilterToAtlasIntersection )
{
if ( !f.geometry() || ! mComposition->atlasComposition().enabled() )
{
continue;
}
QgsFeature* atlasFeature = mComposition->atlasComposition().currentFeature();
if ( !atlasFeature || !atlasFeature->geometry() ||
!f.geometry()->intersects( atlasFeature->geometry() ) )
{
//feature falls outside current atlas feature
continue;
}
}
QgsComposerTableRow currentRow;
QList<QgsComposerTableColumn*>::const_iterator columnIt = mColumns.constBegin();
for ( ; columnIt != mColumns.constEnd(); ++columnIt )
{
int idx = layer->fieldNameIndex(( *columnIt )->attribute() );
if ( idx != -1 )
{
currentRow << f.attributes()[idx];
}
else
{
// Lets assume it's an expression
QgsExpression* expression = new QgsExpression(( *columnIt )->attribute() );
expression->setCurrentRowNumber( counter + 1 );
expression->prepare( layer->pendingFields() );
QVariant value = expression->evaluate( f ) ;
currentRow << value;
}
}
if ( !mShowUniqueRowsOnly || !contentsContainsRow( contents, currentRow ) )
{
contents << currentRow;
++counter;
}
}
//sort the list, starting with the last attribute
QgsComposerAttributeTableCompareV2 c;
QList< QPair<int, bool> > sortColumns = sortAttributes();
for ( int i = sortColumns.size() - 1; i >= 0; --i )
{
c.setSortColumn( sortColumns.at( i ).first );
c.setAscending( sortColumns.at( i ).second );
qStableSort( contents.begin(), contents.end(), c );
}
recalculateTableSize();
return true;
}