5983636709

Committed 26 Aug 2023 07:50AM UTC coverage: 62.064% (+1.1%) from 60.955%

Build # 5983636709

Build Type

push

github

Committed by

web-flow

Commit Message

Lcov to lnx (#2772)

move lcov to linux tests

Run Details

7552 of 12168 relevant lines covered (62.06%)

102.52 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

69.23

/app/layersproxymodel.cpp

/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/

#include "qgsvectorlayer.h"
#include "layersproxymodel.h"

#include "qgsproject.h"
#include "qgslayertree.h"

LayersProxyModel::LayersProxyModel( LayersModel *model, LayerModelTypes modelType ) :
  mModelType( modelType ),
  mModel( model )
{
  setSourceModel( mModel );

  switch ( mModelType )
  {
    case ActiveLayerSelection:
      filterFunction = [this]( QgsMapLayer * layer ) { return recordingAllowed( layer ); };
      break;
    default:
      filterFunction = []( QgsMapLayer * ) { return true; };
      break;
  }
}

bool LayersProxyModel::filterAcceptsRow( int source_row, const QModelIndex &source_parent ) const
{
  if ( !QgsMapLayerProxyModel::filterAcceptsRow( source_row, source_parent ) )
    return false;

  // get layer from row and parent index
  QModelIndex index = mModel->index( source_row, 0, source_parent );
  QgsMapLayer *layer = mModel->layerFromIndex( index );

  return filterFunction( layer );
}

bool layerHasGeometry( const QgsVectorLayer *layer )
{
  if ( !layer || !layer->isValid() )
    return false;
  return layer->wkbType() != Qgis::WkbType::NoGeometry && layer->wkbType() != Qgis::WkbType::Unknown;
}

bool LayersProxyModel::recordingAllowed( QgsMapLayer *layer ) const
{
  if ( !layer || !layer->isValid() )
    return false;

  QgsVectorLayer *vectorLayer = qobject_cast<QgsVectorLayer *>( layer );
  return ( vectorLayer && !vectorLayer->readOnly() && layerHasGeometry( vectorLayer ) && layerVisible( layer ) );
}

bool LayersProxyModel::layerVisible( QgsMapLayer *layer ) const
{
  QgsLayerTree *root = QgsProject::instance()->layerTreeRoot();
  QgsLayerTreeLayer *layerTree = root->findLayer( layer );

  if ( layerTree )
    return layerTree->isVisible();

  return false;
}

QList<QgsMapLayer *> LayersProxyModel::layers() const
{
  QList<QgsMapLayer *> filteredLayers;

  if ( !mModel )
    return filteredLayers;

  QList<QgsMapLayer *> allLayers = mModel->layers();
  int layersCount = allLayers.size();

  for ( int i = 0; i < layersCount; i++ )
  {
    if ( filterFunction( allLayers.at( i ) ) )
      filteredLayers << allLayers.at( i );
  }
  return filteredLayers;
}

void LayersProxyModel::refreshData()
{
  invalidate();
}

QgsMapLayer *LayersProxyModel::firstUsableLayer() const
{
  QList<QgsMapLayer *> filteredLayers = layers();

  if ( filteredLayers.size() > 0 )
  {
    return filteredLayers.at( 0 );
  }

  return nullptr;
}

QModelIndex LayersProxyModel::indexFromLayerId( QString layerId ) const
{
  if ( layerId.isEmpty() )
    return QModelIndex();

  QgsVectorLayer *layer = layerFromLayerId( layerId );

  return mModel->indexFromLayer( layer ); // return source model index to skip converting indexes in proxy model
}

QgsVectorLayer *LayersProxyModel::layerFromLayerId( QString layerId ) const
{
  QList<QgsMapLayer *> filteredLayers = layers();

  for ( int i = 0; i < filteredLayers.count(); i++ )
  {
    if ( filteredLayers.at( i )->id() == layerId )
    {
      QgsVectorLayer *layer = qobject_cast<QgsVectorLayer *>( filteredLayers.at( i ) );
      if ( layer )
        return layer;
    }
  }
  return nullptr;
}

QgsVectorLayer *LayersProxyModel::layerFromLayerName( const QString &layerName ) const
{
  QList<QgsMapLayer *> filteredLayers = layers();

  for ( int i = 0; i < filteredLayers.count(); i++ )
  {
    if ( filteredLayers.at( i )->name() == layerName )
    {
      QgsVectorLayer *layer = qobject_cast<QgsVectorLayer *>( filteredLayers.at( i ) );
      if ( layer )
        return layer;
    }
  }
  return nullptr;
}

QVariant LayersProxyModel::getData( QModelIndex index, int role ) const
{
  return sourceModel()->data( index, role );
}

1	/***************************************************************************
2	* *
3	* This program is free software; you can redistribute it and/or modify *
4	* it under the terms of the GNU General Public License as published by *
5	* the Free Software Foundation; either version 2 of the License, or *
6	* (at your option) any later version. *
7	* *
8	***************************************************************************/
9
10	#include "qgsvectorlayer.h"
11	#include "layersproxymodel.h"
12
13	#include "qgsproject.h"
14	#include "qgslayertree.h"
15
16	LayersProxyModel::LayersProxyModel( LayersModel *model, LayerModelTypes modelType ) :	20✔
17	mModelType( modelType ),	20✔
18	mModel( model )	20✔
19	{
20	setSourceModel( mModel );	20✔
21
22	switch ( mModelType )	20✔
23	{
24	case ActiveLayerSelection:	20✔
25	filterFunction = [this]( QgsMapLayer * layer ) { return recordingAllowed( layer ); };	151✔
26	break;	20✔
27	default:	×
28	filterFunction = []( QgsMapLayer * ) { return true; };	×
29	break;	×
30	}
31	}	20✔
32
33	bool LayersProxyModel::filterAcceptsRow( int source_row, const QModelIndex &source_parent ) const	105✔
34	{
35	if ( !QgsMapLayerProxyModel::filterAcceptsRow( source_row, source_parent ) )	105✔
36	return false;	×
37
38	// get layer from row and parent index
39	QModelIndex index = mModel->index( source_row, 0, source_parent );	105✔
40	QgsMapLayer *layer = mModel->layerFromIndex( index );	105✔
41
42	return filterFunction( layer );	105✔
43	}
44
45	bool layerHasGeometry( const QgsVectorLayer *layer )	130✔
46	{
47	if ( !layer \|\| !layer->isValid() )	130✔
48	return false;	×
49	return layer->wkbType() != Qgis::WkbType::NoGeometry && layer->wkbType() != Qgis::WkbType::Unknown;	130✔
50	}
51
52	bool LayersProxyModel::recordingAllowed( QgsMapLayer *layer ) const	131✔
53	{
54	if ( !layer \|\| !layer->isValid() )	131✔
55	return false;	×
56
57	QgsVectorLayer vectorLayer = qobject_cast<QgsVectorLayer >( layer );	131✔
58	return ( vectorLayer && !vectorLayer->readOnly() && layerHasGeometry( vectorLayer ) && layerVisible( layer ) );	131✔
59	}
60
61	bool LayersProxyModel::layerVisible( QgsMapLayer *layer ) const	110✔
62	{
63	QgsLayerTree *root = QgsProject::instance()->layerTreeRoot();	110✔
64	QgsLayerTreeLayer *layerTree = root->findLayer( layer );	110✔
65
66	if ( layerTree )	110✔
67	return layerTree->isVisible();	106✔
68
69	return false;	4✔
70	}
71
72	QList<QgsMapLayer *> LayersProxyModel::layers() const	5✔
73	{
74	QList<QgsMapLayer *> filteredLayers;	5✔
75
76	if ( !mModel )	5✔
77	return filteredLayers;	×
78
79	QList<QgsMapLayer *> allLayers = mModel->layers();	5✔
80	int layersCount = allLayers.size();	5✔
81
82	for ( int i = 0; i < layersCount; i++ )	31✔
83	{
84	if ( filterFunction( allLayers.at( i ) ) )	26✔
85	filteredLayers << allLayers.at( i );	23✔
86	}
87	return filteredLayers;	5✔
88	}	5✔
89
90	void LayersProxyModel::refreshData()	3✔
91	{
92	invalidate();	3✔
93	}	3✔
94
95	QgsMapLayer *LayersProxyModel::firstUsableLayer() const	2✔
96	{
97	QList<QgsMapLayer *> filteredLayers = layers();	2✔
98
99	if ( filteredLayers.size() > 0 )	2✔
100	{
101	return filteredLayers.at( 0 );	2✔
102	}
103
104	return nullptr;	×
105	}	2✔
106
107	QModelIndex LayersProxyModel::indexFromLayerId( QString layerId ) const	×
108	{
109	if ( layerId.isEmpty() )	×
110	return QModelIndex();	×
111
112	QgsVectorLayer *layer = layerFromLayerId( layerId );	×
113
114	return mModel->indexFromLayer( layer ); // return source model index to skip converting indexes in proxy model	×
115	}
116
117	QgsVectorLayer *LayersProxyModel::layerFromLayerId( QString layerId ) const	×
118	{
119	QList<QgsMapLayer *> filteredLayers = layers();	×
120
121	for ( int i = 0; i < filteredLayers.count(); i++ )	×
122	{
123	if ( filteredLayers.at( i )->id() == layerId )	×
124	{
125	QgsVectorLayer layer = qobject_cast<QgsVectorLayer >( filteredLayers.at( i ) );	×
126	if ( layer )	×
127	return layer;	×
128	}
129	}
130	return nullptr;	×
131	}	×
132
133	QgsVectorLayer *LayersProxyModel::layerFromLayerName( const QString &layerName ) const	3✔
134	{
135	QList<QgsMapLayer *> filteredLayers = layers();	3✔
136
137	for ( int i = 0; i < filteredLayers.count(); i++ )	11✔
138	{
139	if ( filteredLayers.at( i )->name() == layerName )	9✔
140	{
141	QgsVectorLayer layer = qobject_cast<QgsVectorLayer >( filteredLayers.at( i ) );	1✔
142	if ( layer )	1✔
143	return layer;	1✔
144	}
145	}
146	return nullptr;	2✔
147	}	3✔
148
149	QVariant LayersProxyModel::getData( QModelIndex index, int role ) const	×
150	{
151	return sourceModel()->data( index, role );	×
152	}

MerginMaps / input / 5983636709

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous