void TestQgsOfflineEditing::createSpatialiteAndSynchronizeBack()
{
offlineDbFile = "TestQgsOfflineEditing.sqlite";
QCOMPARE( mpLayer->name(), QStringLiteral( "points" ) );
QCOMPARE( mpLayer->featureCount(), numberOfFeatures );
QCOMPARE( mpLayer->fields().size(), numberOfFields );
//set on LayerTreeNode showFeatureCount property
QgsLayerTreeLayer *layerTreelayer = QgsProject::instance()->layerTreeRoot()->findLayer( mpLayer->id() );
layerTreelayer->setCustomProperty( QStringLiteral( "showFeatureCount" ), 1 );
//convert
mOfflineEditing->convertToOfflineProject( offlineDataPath, offlineDbFile, layerIds, false, QgsOfflineEditing::SpatiaLite );
mpLayer = qobject_cast<QgsVectorLayer *>( QgsProject::instance()->mapLayers().first() );
QCOMPARE( mpLayer->name(), QStringLiteral( "points (offline)" ) );
QCOMPARE( mpLayer->featureCount(), numberOfFeatures );
//check LayerTreeNode showFeatureCount property
layerTreelayer = QgsProject::instance()->layerTreeRoot()->findLayer( mpLayer->id() );
QCOMPARE( layerTreelayer->customProperty( QStringLiteral( "showFeatureCount" ), 0 ).toInt(), 1 );
//unset on LayerTreeNode showFeatureCount property
layerTreelayer->setCustomProperty( QStringLiteral( "showFeatureCount" ), 0 );
//synchronize back
mOfflineEditing->synchronize();
mpLayer = qobject_cast<QgsVectorLayer *>( QgsProject::instance()->mapLayers().first() );
QCOMPARE( mpLayer->name(), QStringLiteral( "points" ) );
QCOMPARE( mpLayer->featureCount(), numberOfFeatures );
QCOMPARE( mpLayer->fields().size(), numberOfFields );
//check LayerTreeNode showFeatureCount property
layerTreelayer = QgsProject::instance()->layerTreeRoot()->findLayer( mpLayer->id() );
QCOMPARE( layerTreelayer->customProperty( QStringLiteral( "showFeatureCount" ), 0 ).toInt(), 0 );
}
QVariant CustomLayerOrderModel::data( const QModelIndex& index, int role ) const
{
QString id = mOrder.at( index.row() );
if ( role == Qt::DisplayRole )
{
QgsMapLayer* layer = QgsMapLayerRegistry::instance()->mapLayer( id );
if ( layer )
return layer->name();
}
if ( role == Qt::UserRole + 1 )
{
QgsMapLayer* layer = QgsMapLayerRegistry::instance()->mapLayer( id );
if ( layer )
return layer->id();
}
if ( role == Qt::CheckStateRole )
{
QgsLayerTreeLayer* nodeLayer = mBridge->rootGroup()->findLayer( id );
if ( nodeLayer )
return nodeLayer->isVisible();
}
return QVariant();
}
QgsLayerTreeLayer* QgsLayerTreeLayer::readXML( QDomElement& element )
{
if ( element.tagName() != "layer-tree-layer" )
return 0;
QString layerID = element.attribute( "id" );
QString layerName = element.attribute( "name" );
Qt::CheckState checked = QgsLayerTreeUtils::checkStateFromXml( element.attribute( "checked" ) );
bool isExpanded = ( element.attribute( "expanded", "1" ) == "1" );
QgsLayerTreeLayer* nodeLayer = 0;
QgsMapLayer* layer = QgsMapLayerRegistry::instance()->mapLayer( layerID );
if ( layer )
nodeLayer = new QgsLayerTreeLayer( layer );
else
nodeLayer = new QgsLayerTreeLayer( layerID, layerName );
nodeLayer->readCommonXML( element );
nodeLayer->setVisible( checked );
nodeLayer->setExpanded( isExpanded );
return nodeLayer;
}
bool QgsLayerTreeModel::setData( const QModelIndex& index, const QVariant& value, int role )
{
QgsLayerTreeModelLegendNode *sym = index2symnode( index );
if ( sym )
{
if ( role == Qt::CheckStateRole && !testFlag( AllowSymbologyChangeState ) )
return false;
bool res = sym->setData( value, role );
if ( res )
emit dataChanged( index, index );
return res;
}
QgsLayerTreeNode* node = index2node( index );
if ( !node )
return QgsLayerTreeModel::setData( index, value, role );
if ( role == Qt::CheckStateRole )
{
if ( !testFlag( AllowNodeChangeVisibility ) )
return false;
if ( QgsLayerTree::isLayer( node ) )
{
QgsLayerTreeLayer* layer = QgsLayerTree::toLayer( node );
layer->setVisible(( Qt::CheckState )value.toInt() );
return true;
}
if ( QgsLayerTree::isGroup( node ) )
{
QgsLayerTreeGroup* group = QgsLayerTree::toGroup( node );
group->setVisible(( Qt::CheckState )value.toInt() );
return true;
}
return true;
}
else if ( role == Qt::EditRole )
{
if ( !testFlag( AllowNodeRename ) )
return false;
if ( QgsLayerTree::isLayer( node ) )
{
QgsLayerTreeLayer* layer = QgsLayerTree::toLayer( node );
layer->setLayerName( value.toString() );
emit dataChanged( index, index );
}
else if ( QgsLayerTree::isGroup( node ) )
{
QgsLayerTree::toGroup( node )->setName( value.toString() );
emit dataChanged( index, index );
}
}
return QAbstractItemModel::setData( index, value, role );
}
void QgsLayerTreeMapCanvasBridge::defaultLayerOrder( QgsLayerTreeNode* node, QStringList& order ) const
{
if ( QgsLayerTree::isLayer( node ) )
{
QgsLayerTreeLayer* nodeLayer = QgsLayerTree::toLayer( node );
order << nodeLayer->layerId();
}
foreach ( QgsLayerTreeNode* child, node->children() )
defaultLayerOrder( child, order );
}
foreach ( QgsLayerTreeNode* child, mChildren )
{
if ( QgsLayerTree::isLayer( child ) )
{
QgsLayerTreeLayer* childLayer = QgsLayerTree::toLayer( child );
if ( childLayer->layer() == layer )
{
removeChildren( mChildren.indexOf( child ), 1 );
break;
}
}
}
bool CustomLayerOrderModel::setData( const QModelIndex& index, const QVariant& value, int role )
{
if ( role == Qt::CheckStateRole )
{
QString id = mOrder.at( index.row() );
QgsLayerTreeLayer* nodeLayer = mBridge->rootGroup()->findLayer( id );
if ( nodeLayer )
{
nodeLayer->setVisible( static_cast< Qt::CheckState >( value.toInt() ) );
return true;
}
}
return false;
}
static void _addLayerTreeNodeToUriList( QgsLayerTreeNode *node, QgsMimeDataUtils::UriList &uris )
{
if ( QgsLayerTree::isGroup( node ) )
{
Q_FOREACH ( QgsLayerTreeNode *child, QgsLayerTree::toGroup( node )->children() )
_addLayerTreeNodeToUriList( child, uris );
}
else if ( QgsLayerTree::isLayer( node ) )
{
QgsLayerTreeLayer *nodeLayer = QgsLayerTree::toLayer( node );
QgsMapLayer *layer = nodeLayer->layer();
if ( !layer )
return;
QgsMimeDataUtils::Uri uri;
uri.name = layer->name();
uri.uri = layer->dataProvider()->dataSourceUri();
uri.providerKey = layer->dataProvider()->name();
switch ( layer->type() )
{
case QgsMapLayer::VectorLayer:
{
uri.layerType = QStringLiteral( "vector" );
if ( uri.providerKey == QStringLiteral( "memory" ) )
{
QUrl url = QUrl::fromEncoded( uri.uri.toUtf8() );
url.addQueryItem( QStringLiteral( "pid" ), QString::number( QCoreApplication::applicationPid() ) );
url.addQueryItem( QStringLiteral( "layerid" ), layer->id() );
uri.uri = QString( url.toEncoded() );
}
break;
}
case QgsMapLayer::RasterLayer:
{
uri.layerType = QStringLiteral( "raster" );
break;
}
case QgsMapLayer::MeshLayer:
case QgsMapLayer::PluginLayer:
{
// plugin layers do not have a standard way of storing their URI...
return;
}
}
uris << uri;
}
}
static void _collectMapLayers( const QList<QgsLayerTreeNode *> &nodes, QSet<QgsMapLayer *> &layersSet )
{
for ( QgsLayerTreeNode *node : nodes )
{
if ( QgsLayerTree::isLayer( node ) )
{
QgsLayerTreeLayer *nodeLayer = QgsLayerTree::toLayer( node );
if ( nodeLayer->layer() )
layersSet << nodeLayer->layer();
}
else if ( QgsLayerTree::isGroup( node ) )
{
_collectMapLayers( QgsLayerTree::toGroup( node )->children(), layersSet );
}
}
}
void QgsLayerTreeRegistryBridge::layersAdded( QList<QgsMapLayer*> layers )
{
if ( !mEnabled )
return;
foreach ( QgsMapLayer* layer, layers )
{
// add new layer to the top
QgsLayerTreeLayer* nodeLayer = mInsertionPointGroup->insertLayer( mInsertionPointIndex, layer );
// check whether the layer is marked as embedded
QString projectFile = QgsProject::instance()->layerIsEmbedded( nodeLayer->layerId() );
if ( !projectFile.isEmpty() )
{
nodeLayer->setCustomProperty( "embedded", 1 );
nodeLayer->setCustomProperty( "embedded_project", projectFile );
}
}
void QgsLayerTreeView::modelRowsInserted( const QModelIndex& index, int start, int end )
{
QgsLayerTreeNode* parentNode = layerTreeModel()->index2node( index );
if ( !parentNode )
return;
// Embedded widgets - replace placeholders in the model by actual widgets
if ( layerTreeModel()->testFlag( QgsLayerTreeModel::UseEmbeddedWidgets ) && QgsLayerTree::isLayer( parentNode ) )
{
QgsLayerTreeLayer* nodeLayer = QgsLayerTree::toLayer( parentNode );
if ( QgsMapLayer* layer = nodeLayer->layer() )
{
int widgetsCount = layer->customProperty( "embeddedWidgets/count", 0 ).toInt();
QList<QgsLayerTreeModelLegendNode*> legendNodes = layerTreeModel()->layerLegendNodes( nodeLayer );
for ( int i = 0; i < widgetsCount; ++i )
{
QString providerId = layer->customProperty( QString( "embeddedWidgets/%1/id" ).arg( i ) ).toString();
if ( QgsLayerTreeEmbeddedWidgetProvider* provider = QgsLayerTreeEmbeddedWidgetRegistry::instance()->provider( providerId ) )
{
QModelIndex index = layerTreeModel()->legendNode2index( legendNodes[i] );
setIndexWidget( index, provider->createWidget( layer, i ) );
}
}
}
}
if ( QgsLayerTree::isLayer( parentNode ) )
{
// if ShowLegendAsTree flag is enabled in model, we may need to expand some legend nodes
QStringList expandedNodeKeys = parentNode->customProperty( "expandedLegendNodes" ).toStringList();
if ( expandedNodeKeys.isEmpty() )
return;
Q_FOREACH ( QgsLayerTreeModelLegendNode* legendNode, layerTreeModel()->layerLegendNodes( QgsLayerTree::toLayer( parentNode ) ) )
{
QString ruleKey = legendNode->data( QgsLayerTreeModelLegendNode::RuleKeyRole ).toString();
if ( expandedNodeKeys.contains( ruleKey ) )
setExpanded( layerTreeModel()->legendNode2index( legendNode ), true );
}
return;
}
void QgsLayerTree::setCustomLayerOrder( const QStringList &customLayerOrder )
{
QList<QgsMapLayer *> layers;
for ( const auto &layerId : customLayerOrder )
{
QgsLayerTreeLayer *nodeLayer = findLayer( layerId );
if ( nodeLayer )
{
// configuration from 2.x projects might have non spatial layers
QgsMapLayer *layer = nodeLayer->layer();
if ( !layer || !layer->isSpatial() )
{
continue;
}
layers.append( layer );
}
}
setCustomLayerOrder( layers );
}
void QgsLayerTreeRegistryBridge::layersAdded( const QList<QgsMapLayer*>& layers )
{
if ( !mEnabled )
return;
QList<QgsLayerTreeNode*> nodes;
Q_FOREACH ( QgsMapLayer* layer, layers )
{
QgsLayerTreeLayer* nodeLayer = new QgsLayerTreeLayer( layer );
nodeLayer->setVisible( mNewLayersVisible ? Qt::Checked : Qt::Unchecked );
nodes << nodeLayer;
// check whether the layer is marked as embedded
QString projectFile = QgsProject::instance()->layerIsEmbedded( nodeLayer->layerId() );
if ( !projectFile.isEmpty() )
{
nodeLayer->setCustomProperty( "embedded", 1 );
nodeLayer->setCustomProperty( "embedded_project", projectFile );
}
}
QgsLayerTreeLayer *QgsLayerTreeUtils::insertLayerBelow( QgsLayerTreeGroup *group, const QgsMapLayer *refLayer, QgsMapLayer *layerToInsert )
{
// get the index of the reflayer
QgsLayerTreeLayer *inTree = group->findLayer( refLayer->id() );
if ( !inTree )
return nullptr;
int idx = 0;
const auto constChildren = inTree->parent()->children();
for ( QgsLayerTreeNode *vl : constChildren )
{
if ( vl->nodeType() == QgsLayerTreeNode::NodeLayer && static_cast<QgsLayerTreeLayer *>( vl )->layer() == refLayer )
{
break;
}
idx++;
}
// insert the new layer
QgsLayerTreeGroup *parent = static_cast<QgsLayerTreeGroup *>( inTree->parent() ) ? static_cast<QgsLayerTreeGroup *>( inTree->parent() ) : group;
return parent->insertLayer( idx, layerToInsert );
}
QgsLayerTreeGroup* QgsLayerTreeView::currentGroupNode() const
{
QgsLayerTreeNode* node = currentNode();
if ( QgsLayerTree::isGroup( node ) )
return QgsLayerTree::toGroup( node );
else if ( QgsLayerTree::isLayer( node ) )
{
QgsLayerTreeNode* parent = node->parent();
if ( QgsLayerTree::isGroup( parent ) )
return QgsLayerTree::toGroup( parent );
}
if ( QgsLayerTreeModelLegendNode* legendNode = layerTreeModel()->index2legendNode( selectionModel()->currentIndex() ) )
{
QgsLayerTreeLayer* parent = legendNode->layerNode();
if ( QgsLayerTree::isGroup( parent->parent() ) )
return QgsLayerTree::toGroup( parent->parent() );
}
return 0;
}
QVariant QgsLegendModel::data( const QModelIndex &index, int role ) const
{
// handle custom layer node labels
if ( QgsLayerTreeNode *node = index2node( index ) )
{
if ( QgsLayerTree::isLayer( node ) && ( role == Qt::DisplayRole || role == Qt::EditRole ) && !node->customProperty( QStringLiteral( "legend/title-label" ) ).isNull() )
{
QgsLayerTreeLayer *nodeLayer = QgsLayerTree::toLayer( node );
QString name = node->customProperty( QStringLiteral( "legend/title-label" ) ).toString();
if ( nodeLayer->customProperty( QStringLiteral( "showFeatureCount" ), 0 ).toInt() && role == Qt::DisplayRole )
{
QgsVectorLayer *vlayer = qobject_cast<QgsVectorLayer *>( nodeLayer->layer() );
if ( vlayer && vlayer->featureCount() >= 0 )
name += QStringLiteral( " [%1]" ).arg( vlayer->featureCount() );
}
return name;
}
}
return QgsLayerTreeModel::data( index, role );
}
void QgsLayerTreeRegistryBridge::layersAdded( QList<QgsMapLayer*> layers )
{
if ( !mEnabled )
return;
int i = 0;
foreach ( QgsMapLayer* layer, layers )
{
QgsLayerTreeLayer* nodeLayer = new QgsLayerTreeLayer( layer );
nodeLayer->setVisible( mNewLayersVisible ? Qt::Checked : Qt::Unchecked );
// add new layer to the top
mInsertionPointGroup->insertChildNode( mInsertionPointIndex + i++, nodeLayer );
// check whether the layer is marked as embedded
QString projectFile = QgsProject::instance()->layerIsEmbedded( nodeLayer->layerId() );
if ( !projectFile.isEmpty() )
{
nodeLayer->setCustomProperty( "embedded", 1 );
nodeLayer->setCustomProperty( "embedded_project", projectFile );
}
}
QStringList QgsLayerTreeUtils::invisibleLayerList( QgsLayerTreeNode *node )
{
QStringList list;
if ( QgsLayerTree::isGroup( node ) )
{
const auto constChildren = QgsLayerTree::toGroup( node )->children();
for ( QgsLayerTreeNode *child : constChildren )
{
list << invisibleLayerList( child );
}
}
else if ( QgsLayerTree::isLayer( node ) )
{
QgsLayerTreeLayer *layer = QgsLayerTree::toLayer( node );
if ( !layer->isVisible() )
list << layer->layerId();
}
return list;
}
static void _readOldLegendGroup( QDomElement& elem, QgsLayerTreeGroup* parentGroup, QgsProject* project )
{
QDomElement itemElem = elem.firstChildElement();
while ( !itemElem.isNull() )
{
if ( itemElem.tagName() == QLatin1String( "LayerItem" ) )
{
QString layerId = itemElem.attribute( QStringLiteral( "layerId" ) );
if ( QgsMapLayer* layer = project->mapLayer( layerId ) )
{
QgsLayerTreeLayer* nodeLayer = parentGroup->addLayer( layer );
QString userText = itemElem.attribute( QStringLiteral( "userText" ) );
if ( !userText.isEmpty() )
nodeLayer->setCustomProperty( QStringLiteral( "legend/title-label" ), userText );
QString style = itemElem.attribute( QStringLiteral( "style" ) );
if ( !style.isEmpty() )
nodeLayer->setCustomProperty( QStringLiteral( "legend/title-style" ), style );
QString showFeatureCount = itemElem.attribute( QStringLiteral( "showFeatureCount" ) );
if ( showFeatureCount.toInt() )
nodeLayer->setCustomProperty( QStringLiteral( "showFeatureCount" ), 1 );
// support for individual legend items (user text, order) not implemented yet
}
}
else if ( itemElem.tagName() == QLatin1String( "GroupItem" ) )
{
QgsLayerTreeGroup* nodeGroup = parentGroup->addGroup( itemElem.attribute( QStringLiteral( "userText" ) ) );
QString style = itemElem.attribute( QStringLiteral( "style" ) );
if ( !style.isEmpty() )
nodeGroup->setCustomProperty( QStringLiteral( "legend/title-style" ), style );
_readOldLegendGroup( itemElem, nodeGroup, project );
}
itemElem = itemElem.nextSiblingElement();
}
}
void QgsLayerTreeMapCanvasBridge::setCanvasLayers( QgsLayerTreeNode *node, QList<QgsMapLayer *> &canvasLayers, QList<QgsMapLayer *> &overviewLayers, QList<QgsMapLayer *> &allLayers )
{
if ( QgsLayerTree::isLayer( node ) )
{
QgsLayerTreeLayer *nodeLayer = QgsLayerTree::toLayer( node );
if ( nodeLayer->layer() && nodeLayer->layer()->isSpatial() )
{
allLayers << nodeLayer->layer();
if ( nodeLayer->isVisible() )
canvasLayers << nodeLayer->layer();
if ( nodeLayer->customProperty( QStringLiteral( "overview" ), 0 ).toInt() )
overviewLayers << nodeLayer->layer();
}
}
const QList<QgsLayerTreeNode *> children = node->children();
for ( QgsLayerTreeNode *child : children )
setCanvasLayers( child, canvasLayers, overviewLayers, allLayers );
}
static void _readOldLegendLayer( const QDomElement &layerElem, QgsLayerTreeGroup *parent )
{
QDomElement layerFileElem = layerElem.firstChildElement( QStringLiteral( "filegroup" ) ).firstChildElement( QStringLiteral( "legendlayerfile" ) );
QString layerId = layerFileElem.attribute( QStringLiteral( "layerid" ) );
QgsLayerTreeLayer *layerNode = new QgsLayerTreeLayer( layerId, layerElem.attribute( QStringLiteral( "name" ) ) );
layerNode->setItemVisibilityChecked( QgsLayerTreeUtils::checkStateFromXml( layerElem.attribute( QStringLiteral( "checked" ) ) ) != Qt::Unchecked );
layerNode->setExpanded( layerElem.attribute( QStringLiteral( "open" ) ) == QLatin1String( "true" ) );
if ( layerFileElem.attribute( QStringLiteral( "isInOverview" ) ) == QLatin1String( "1" ) )
layerNode->setCustomProperty( QStringLiteral( "overview" ), 1 );
if ( layerElem.attribute( QStringLiteral( "embedded" ) ) == QLatin1String( "1" ) )
layerNode->setCustomProperty( QStringLiteral( "embedded" ), 1 );
if ( layerElem.attribute( QStringLiteral( "showFeatureCount" ) ) == QLatin1String( "1" ) )
layerNode->setCustomProperty( QStringLiteral( "showFeatureCount" ), 1 );
// drawing order is handled by readOldLegendLayerOrder()
parent->addChildNode( layerNode );
}
void TestQgsOfflineEditing::createGeopackageAndSynchronizeBack()
{
offlineDbFile = "TestQgsOfflineEditing.gpkg";
QCOMPARE( mpLayer->name(), QStringLiteral( "points" ) );
QCOMPARE( mpLayer->featureCount(), numberOfFeatures );
QCOMPARE( mpLayer->fields().size(), numberOfFields );
QgsFeature firstFeatureBeforeAction;
QgsFeatureIterator it = mpLayer->getFeatures();
it.nextFeature( firstFeatureBeforeAction );
connect( mOfflineEditing, &QgsOfflineEditing::warning, this, []( const QString & title, const QString & message ) { qDebug() << title << message; } );
//set on LayerTreeNode showFeatureCount property
QgsLayerTreeLayer *layerTreelayer = QgsProject::instance()->layerTreeRoot()->findLayer( mpLayer->id() );
layerTreelayer->setCustomProperty( QStringLiteral( "showFeatureCount" ), 1 );
layerTreelayer->setItemVisibilityChecked( false );
//convert
mOfflineEditing->convertToOfflineProject( offlineDataPath, offlineDbFile, layerIds, false, QgsOfflineEditing::GPKG );
mpLayer = qobject_cast<QgsVectorLayer *>( QgsProject::instance()->mapLayers().first() );
QCOMPARE( mpLayer->name(), QStringLiteral( "points (offline)" ) );
QCOMPARE( mpLayer->featureCount(), numberOfFeatures );
//comparing with the number +1 because GPKG created an fid
QCOMPARE( mpLayer->fields().size(), numberOfFields + 1 );
//check LayerTreeNode showFeatureCount property
layerTreelayer = QgsProject::instance()->layerTreeRoot()->findLayer( mpLayer->id() );
QCOMPARE( layerTreelayer->customProperty( QStringLiteral( "showFeatureCount" ), 0 ).toInt(), 1 );
QCOMPARE( layerTreelayer->isVisible(), false );
QgsFeature firstFeatureInAction;
it = mpLayer->getFeatures();
it.nextFeature( firstFeatureInAction );
//compare some values
QCOMPARE( firstFeatureInAction.attribute( QStringLiteral( "Class" ) ).toString(), firstFeatureBeforeAction.attribute( QStringLiteral( "Class" ) ).toString() );
QCOMPARE( firstFeatureInAction.attribute( QStringLiteral( "Heading" ) ).toString(), firstFeatureBeforeAction.attribute( QStringLiteral( "Heading" ) ).toString() );
QCOMPARE( firstFeatureInAction.attribute( QStringLiteral( "Cabin Crew" ) ).toString(), firstFeatureBeforeAction.attribute( QStringLiteral( "Cabin Crew" ) ).toString() );
QgsFeature newFeature( mpLayer->dataProvider()->fields() );
newFeature.setAttribute( QStringLiteral( "Class" ), QStringLiteral( "Superjet" ) );
mpLayer->startEditing();
mpLayer->addFeature( newFeature );
mpLayer->commitChanges();
QCOMPARE( mpLayer->featureCount(), numberOfFeatures + 1 );
//unset on LayerTreeNode showFeatureCount property
layerTreelayer->setCustomProperty( QStringLiteral( "showFeatureCount" ), 0 );
//synchronize back
mOfflineEditing->synchronize();
mpLayer = qobject_cast<QgsVectorLayer *>( QgsProject::instance()->mapLayers().first() );
QCOMPARE( mpLayer->name(), QStringLiteral( "points" ) );
QCOMPARE( mpLayer->dataProvider()->featureCount(), numberOfFeatures + 1 );
QCOMPARE( mpLayer->fields().size(), numberOfFields );
//check LayerTreeNode showFeatureCount property
layerTreelayer = QgsProject::instance()->layerTreeRoot()->findLayer( mpLayer->id() );
QCOMPARE( layerTreelayer->customProperty( QStringLiteral( "showFeatureCount" ), 0 ).toInt(), 0 );
//get last feature
QgsFeature f = mpLayer->getFeature( mpLayer->dataProvider()->featureCount() - 1 );
qDebug() << "FID:" << f.id() << "Class:" << f.attribute( "Class" ).toString();
QCOMPARE( f.attribute( QStringLiteral( "Class" ) ).toString(), QStringLiteral( "Superjet" ) );
QgsFeature firstFeatureAfterAction;
it = mpLayer->getFeatures();
it.nextFeature( firstFeatureAfterAction );
QCOMPARE( firstFeatureAfterAction, firstFeatureBeforeAction );
//and delete the feature again
QgsFeatureIds idsToClean;
idsToClean << f.id();
mpLayer->dataProvider()->deleteFeatures( idsToClean );
QCOMPARE( mpLayer->dataProvider()->featureCount(), numberOfFeatures );
}
void QgsLayerTreeUtils::setLegendFilterByExpression( QgsLayerTreeLayer &layer, const QString &expr, bool enabled )
{
layer.setCustomProperty( QStringLiteral( "legend/expressionFilter" ), expr );
layer.setCustomProperty( QStringLiteral( "legend/expressionFilterEnabled" ), enabled );
}
QString QgsLayerTreeUtils::legendFilterByExpression( const QgsLayerTreeLayer &layer, bool *enabled )
{
if ( enabled )
*enabled = layer.customProperty( QStringLiteral( "legend/expressionFilterEnabled" ), "" ).toBool();
return layer.customProperty( QStringLiteral( "legend/expressionFilter" ), "" ).toString();
}
QVariant QgsLayerTreeModel::data( const QModelIndex &index, int role ) const
{
if ( !index.isValid() )
return QVariant();
if ( QgsLayerTreeModelLegendNode* sym = index2symnode( index ) )
{
if ( role == Qt::CheckStateRole && !testFlag( AllowSymbologyChangeState ) )
return QVariant();
return sym->data( role );
}
QgsLayerTreeNode* node = index2node( index );
if ( role == Qt::DisplayRole || role == Qt::EditRole )
{
if ( QgsLayerTree::isGroup( node ) )
return QgsLayerTree::toGroup( node )->name();
else if ( QgsLayerTree::isLayer( node ) )
{
QgsLayerTreeLayer* nodeLayer = QgsLayerTree::toLayer( node );
QString name = nodeLayer->layerName();
if ( nodeLayer->customProperty( "showFeatureCount", 0 ).toInt() && role == Qt::DisplayRole )
{
QgsVectorLayer* vlayer = qobject_cast<QgsVectorLayer*>( nodeLayer->layer() );
if ( vlayer && vlayer->pendingFeatureCount() >= 0 )
name += QString( " [%1]" ).arg( vlayer->pendingFeatureCount() );
}
return name;
}
}
else if ( role == Qt::DecorationRole && index.column() == 0 )
{
if ( QgsLayerTree::isGroup( node ) )
return iconGroup();
else if ( QgsLayerTree::isLayer( node ) )
{
QgsLayerTreeLayer* nodeLayer = QgsLayerTree::toLayer( node );
// if there's just on legend entry that should be embedded in layer - do that!
if ( testFlag( ShowSymbology ) && mSymbologyNodes[nodeLayer].count() == 1 && mSymbologyNodes[nodeLayer][0]->isEmbeddedInParent() )
return mSymbologyNodes[nodeLayer][0]->data( Qt::DecorationRole );
QgsMapLayer* layer = QgsLayerTree::toLayer( node )->layer();
if ( !layer )
return QVariant();
if ( layer->type() == QgsMapLayer::RasterLayer )
{
if ( testFlag( ShowRasterPreviewIcon ) )
{
QgsRasterLayer* rlayer = qobject_cast<QgsRasterLayer *>( layer );
return QIcon( rlayer->previewAsPixmap( QSize( 32, 32 ) ) );
}
else
return QgsLayerItem::iconRaster();
}
else if ( layer->type() == QgsMapLayer::VectorLayer )
{
QgsVectorLayer* vlayer = static_cast<QgsVectorLayer*>( layer );
if ( vlayer->isEditable() )
{
if ( vlayer->isModified() )
return QIcon( QgsApplication::getThemePixmap( "/mIconEditableEdits.png" ) );
else
return QIcon( QgsApplication::getThemePixmap( "/mIconEditable.png" ) );
}
if ( vlayer->geometryType() == QGis::Point )
return QgsLayerItem::iconPoint();
else if ( vlayer->geometryType() == QGis::Line )
return QgsLayerItem::iconLine();
else if ( vlayer->geometryType() == QGis::Polygon )
return QgsLayerItem::iconPolygon();
else if ( vlayer->geometryType() == QGis::NoGeometry )
return QgsLayerItem::iconTable();
}
return QgsLayerItem::iconDefault();
}
}
else if ( role == Qt::CheckStateRole )
{
if ( !testFlag( AllowNodeChangeVisibility ) )
return QVariant();
if ( QgsLayerTree::isLayer( node ) )
{
QgsLayerTreeLayer* nodeLayer = QgsLayerTree::toLayer( node );
if ( nodeLayer->layer() && nodeLayer->layer()->type() == QgsMapLayer::VectorLayer )
{
if ( qobject_cast<QgsVectorLayer*>( nodeLayer->layer() )->geometryType() == QGis::NoGeometry )
return QVariant(); // do not show checkbox for non-spatial tables
}
return nodeLayer->isVisible();
}
else if ( QgsLayerTree::isGroup( node ) )
{
QgsLayerTreeGroup* nodeGroup = QgsLayerTree::toGroup( node );
return nodeGroup->isVisible();
}
}
else if ( role == Qt::FontRole )
{
QFont f( QgsLayerTree::isLayer( node ) ? mFontLayer : ( QgsLayerTree::isGroup( node ) ? mFontGroup : QFont() ) );
if ( node->customProperty( "embedded" ).toInt() )
f.setItalic( true );
if ( index == mCurrentIndex )
f.setUnderline( true );
return f;
}
else if ( role == Qt::ToolTipRole )
{
if ( QgsLayerTree::isLayer( node ) )
{
if ( QgsMapLayer* layer = QgsLayerTree::toLayer( node )->layer() )
return layer->publicSource();
}
}
return QVariant();
}
void QgsLayerTreeMapCanvasBridge::setCanvasLayers()
{
QList<QgsMapLayer *> canvasLayers, overviewLayers, allLayerOrder;
if ( mRoot->hasCustomLayerOrder() )
{
const QList<QgsMapLayer *> customOrderLayers = mRoot->customLayerOrder();
for ( const QgsMapLayer *layer : customOrderLayers )
{
QgsLayerTreeLayer *nodeLayer = mRoot->findLayer( layer->id() );
if ( nodeLayer )
{
if ( !nodeLayer->layer()->isSpatial() )
continue;
allLayerOrder << nodeLayer->layer();
if ( nodeLayer->isVisible() )
canvasLayers << nodeLayer->layer();
if ( nodeLayer->customProperty( QStringLiteral( "overview" ), 0 ).toInt() )
overviewLayers << nodeLayer->layer();
}
}
}
else
{
setCanvasLayers( mRoot, canvasLayers, overviewLayers, allLayerOrder );
}
const QList<QgsLayerTreeLayer *> layerNodes = mRoot->findLayers();
int currentSpatialLayerCount = 0;
for ( QgsLayerTreeLayer *layerNode : layerNodes )
{
if ( layerNode->layer() && layerNode->layer()->isSpatial() )
currentSpatialLayerCount++;
}
bool firstLayers = mAutoSetupOnFirstLayer && !mHasLayersLoaded && currentSpatialLayerCount != 0;
mCanvas->setLayers( canvasLayers );
if ( mOverviewCanvas )
mOverviewCanvas->setLayers( overviewLayers );
if ( firstLayers )
{
// if we are moving from zero to non-zero layers, let's zoom to those data
mCanvas->zoomToFullExtent();
}
if ( !mFirstCRS.isValid() )
{
// find out what is the first used CRS in case we may need to turn on OTF projections later
for ( const QgsLayerTreeLayer *layerNode : layerNodes )
{
if ( layerNode->layer() && layerNode->layer()->crs().isValid() )
{
mFirstCRS = layerNode->layer()->crs();
break;
}
}
}
if ( mFirstCRS.isValid() && firstLayers )
{
QgsProject::instance()->setCrs( mFirstCRS );
}
mHasLayersLoaded = currentSpatialLayerCount;
if ( currentSpatialLayerCount == 0 )
mFirstCRS = QgsCoordinateReferenceSystem();
mPendingCanvasUpdate = false;
emit canvasLayersChanged( canvasLayers );
}
QVariant QgsLayerTreeModel::data( const QModelIndex &index, int role ) const
{
if ( !index.isValid() || index.column() > 1 )
return QVariant();
if ( QgsLayerTreeModelLegendNode* sym = index2legendNode( index ) )
return legendNodeData( sym, role );
QgsLayerTreeNode* node = index2node( index );
if ( role == Qt::DisplayRole || role == Qt::EditRole )
{
if ( QgsLayerTree::isGroup( node ) )
return QgsLayerTree::toGroup( node )->name();
if ( QgsLayerTree::isLayer( node ) )
{
QgsLayerTreeLayer* nodeLayer = QgsLayerTree::toLayer( node );
QString name = nodeLayer->layerName();
if ( nodeLayer->customProperty( "showFeatureCount", 0 ).toInt() && role == Qt::DisplayRole )
{
QgsVectorLayer* vlayer = qobject_cast<QgsVectorLayer*>( nodeLayer->layer() );
if ( vlayer && vlayer->featureCount() >= 0 )
name += QString( " [%1]" ).arg( vlayer->featureCount() );
}
return name;
}
}
else if ( role == Qt::DecorationRole && index.column() == 0 )
{
if ( QgsLayerTree::isGroup( node ) )
return iconGroup();
if ( QgsLayerTree::isLayer( node ) )
{
QgsLayerTreeLayer *nodeLayer = QgsLayerTree::toLayer( node );
QgsMapLayer *layer = nodeLayer->layer();
if ( !layer )
return QVariant();
// icons possibly overriding default icon
if ( layer->type() == QgsMapLayer::RasterLayer )
{
if ( testFlag( ShowRasterPreviewIcon ) )
{
QgsRasterLayer* rlayer = qobject_cast<QgsRasterLayer *>( layer );
return QIcon( QPixmap::fromImage( rlayer->previewAsImage( QSize( 32, 32 ) ) ) );
}
else
{
return QgsLayerItem::iconRaster();
}
}
QgsVectorLayer *vlayer = dynamic_cast<QgsVectorLayer*>( layer );
QIcon icon;
// if there's just on legend entry that should be embedded in layer - do that!
if ( testFlag( ShowLegend ) && legendEmbeddedInParent( nodeLayer ) )
{
icon = legendIconEmbeddedInParent( nodeLayer );
}
else if ( vlayer && layer->type() == QgsMapLayer::VectorLayer )
{
if ( vlayer->geometryType() == QGis::Point )
icon = QgsLayerItem::iconPoint();
else if ( vlayer->geometryType() == QGis::Line )
icon = QgsLayerItem::iconLine();
else if ( vlayer->geometryType() == QGis::Polygon )
icon = QgsLayerItem::iconPolygon();
else if ( vlayer->geometryType() == QGis::NoGeometry )
icon = QgsLayerItem::iconTable();
else
icon = QgsLayerItem::iconDefault();
}
if ( vlayer && vlayer->isEditable() )
{
QPixmap pixmap( icon.pixmap( 16, 16 ) );
QPainter painter( &pixmap );
painter.drawPixmap( 0, 0, 16, 16, QgsApplication::getThemePixmap( vlayer->isModified() ? "/mIconEditableEdits.png" : "/mIconEditable.png" ) );
painter.end();
icon = QIcon( pixmap );
}
return icon;
}
}
else if ( role == Qt::CheckStateRole )
{
if ( !testFlag( AllowNodeChangeVisibility ) )
return QVariant();
if ( QgsLayerTree::isLayer( node ) )
{
QgsLayerTreeLayer* nodeLayer = QgsLayerTree::toLayer( node );
if ( nodeLayer->layer() && nodeLayer->layer()->type() == QgsMapLayer::VectorLayer )
{
if ( qobject_cast<QgsVectorLayer*>( nodeLayer->layer() )->geometryType() == QGis::NoGeometry )
return QVariant(); // do not show checkbox for non-spatial tables
}
return nodeLayer->isVisible();
}
else if ( QgsLayerTree::isGroup( node ) )
{
QgsLayerTreeGroup* nodeGroup = QgsLayerTree::toGroup( node );
return nodeGroup->isVisible();
}
}
else if ( role == Qt::FontRole )
{
QFont f( QgsLayerTree::isLayer( node ) ? mFontLayer : ( QgsLayerTree::isGroup( node ) ? mFontGroup : QFont() ) );
if ( node->customProperty( "embedded" ).toInt() )
f.setItalic( true );
if ( index == mCurrentIndex )
f.setUnderline( true );
return f;
}
else if ( role == Qt::ToolTipRole )
{
if ( QgsLayerTree::isLayer( node ) )
{
if ( QgsMapLayer* layer = QgsLayerTree::toLayer( node )->layer() )
return layer->publicSource();
}
}
return QVariant();
}
