def tab2map(self):
QApplication.setOverrideCursor(Qt.WaitCursor)
self.ml.selectionChanged.disconnect(self.map2tab)
idx = self.tableView.selectionModel().selectedIndexes()[0]
featureId = idx.row() + self.p
s = self.model.itemData(idx)
lst = s[0].strip().replace(' ', '').split(',')
self.ml.removeSelection()
for sid in lst:
self.ml.select(int(sid) - self.p)
provider = self.ml.dataProvider()
feat = QgsFeature()
layer = QgsVectorLayerCache(self.ml, provider.featureCount())
layer.featureAtId(idx.row() + self.mod, feat)
geom = QgsGeometry(feat.geometry())
self.mRubberBand.setToGeometry(geom, self.ml)
self.mRubberBand.show()
self.ml.selectionChanged.connect(self.map2tab)
QApplication.restoreOverrideCursor()
def tab2map(self):
QApplication.setOverrideCursor(Qt.WaitCursor)
self.ml.selectionChanged.disconnect(self.map2tab)
idx = self.tableView.selectionModel().selectedIndexes()[0]
featureId = idx.row() + self.p
s = self.model.itemData(idx)
lst = s[0].strip().replace(' ', '').split(',')
self.ml.removeSelection()
for sid in lst:
self.ml.select(int(sid)-self.p)
provider = self.ml.dataProvider()
feat = QgsFeature()
layer = QgsVectorLayerCache(self.ml, provider.featureCount())
layer.featureAtId(idx.row()+self.mod, feat)
geom = QgsGeometry(feat.geometry())
self.mRubberBand.setToGeometry(geom, self.ml)
self.mRubberBand.show()
self.ml.selectionChanged.connect(self.map2tab)
QApplication.restoreOverrideCursor()
def setUpClass(cls):
"""Run before all tests"""
# Create test layer for FeatureSourceTestCase
cls.vl = QgsVectorLayer(
'Point?crs=epsg:4326&field=pk:integer&field=cnt:integer&field=name:string(0)&field=name2:string(0)&field=num_char:string&key=pk',
'test', 'memory')
assert (cls.vl.isValid())
f1 = QgsFeature(5)
f1.setAttributes([5, -200, NULL, 'NuLl', '5'])
f1.setGeometry(QgsGeometry.fromWkt('Point (-71.123 78.23)'))
f2 = QgsFeature(3)
f2.setAttributes([3, 300, 'Pear', 'PEaR', '3'])
f3 = QgsFeature(1)
f3.setAttributes([1, 100, 'Orange', 'oranGe', '1'])
f3.setGeometry(QgsGeometry.fromWkt('Point (-70.332 66.33)'))
f4 = QgsFeature(2)
f4.setAttributes([2, 200, 'Apple', 'Apple', '2'])
f4.setGeometry(QgsGeometry.fromWkt('Point (-68.2 70.8)'))
f5 = QgsFeature(4)
f5.setAttributes([4, 400, 'Honey', 'Honey', '4'])
f5.setGeometry(QgsGeometry.fromWkt('Point (-65.32 78.3)'))
assert cls.vl.dataProvider().addFeatures([f1, f2, f3, f4, f5])
cls.source = QgsVectorLayerCache(cls.vl, 100)
def reload(self, *args):
try:
# the table
self.layer = self.iface.activeLayer()
self.setWindowTitle(self.iface.activeLayer().name() +
":: Ursprünglich selektierte Objekte: {0}".
format(self.layer.selectedFeatureCount()))
self.vector_layer_cache = QgsVectorLayerCache(self.layer, 10000)
self.attribute_table_model = QgsAttributeTableModel(
self.vector_layer_cache)
self.attribute_table_model.loadLayer()
self.attribute_table_filter_model = QgsAttributeTableFilterModel(
self.canvas, self.attribute_table_model)
# filter
self.attribute_table_filter_model.setFilterMode(
QgsAttributeTableFilterModel.ShowFilteredList)
self.attribute_table_filter_model.setFilteredFeatures(
self.layer.selectedFeatureIds())
self.view.setModel(self.attribute_table_filter_model)
self.view.horizontalHeader().setSectionResizeMode(
QHeaderView.Stretch)
for f in self.layer.fields():
# if self.debug: self.info.log("editorWidgetSetup:",f.name(),f.editorWidgetSetup().type())
if f.editorWidgetSetup().type() == 'Hidden' and not self.debug:
self.view.horizontalHeader().setSectionHidden(
self.layer.fields().indexOf(f.name()), True)
# only follow selection on the map
# self.selectionManager = qgis.QgsVectorLayerSelectionManager(self.layer, self.attribute_table_filter_model)
# self.view.setFeatureSelectionManager(self.selectionManager)
self.layer.selectionChanged.connect(self._selectionChanged)
except Exception as e:
self.info.err(e)
def openAttributeDialog(self, layer):
self.layerCache = QgsVectorLayerCache(layer, layer.featureCount())
self.tableModel = QgsAttributeTableModel(self.layerCache)
self.tableModel.loadLayer()
self.tableFilterModel = QgsAttributeTableFilterModel(self.mapCanvas, self.tableModel, parent=self.tableModel)
self.tableFilterModel.setFilterMode(QgsAttributeTableFilterModel.ShowAll)
self.tableView.setModel(self.tableFilterModel)
def __init__(self, parent=None):
"""Constructor."""
super(ChartDockWidget, self).__init__(parent)
# Set up the user interface from Designer.
# After setupUI you can access any designer object by doing
# self.<objectname>, and you can use autoconnect slots - see
# http://qt-project.org/doc/qt-4.8/designer-using-a-ui-file.html
# #widgets-and-dialogs-with-auto-connect
self.setupUi(self)
project = QgsProject.instance()
self._layers.addItem("")
for layerid, layer in project.mapLayers().items():
self._layers.addItem(layer.sourceName(), layerid)
self._layers.currentIndexChanged.connect(self.__on_layer_changed)
self._axisX.currentIndexChanged.connect(self.__refresh_chart)
self._axisY.currentIndexChanged.connect(self.__refresh_chart)
chart = QChart()
chartView = QChartView(chart, self)
self._main.layout().addWidget(chartView)
series = QLineSeries()
series.setName("Line 1")
self._mapper = QVXYModelMapper(chartView)
self._mapper.setXColumn(0)
self._mapper.setYColumn(2)
self._mapper.setSeries(series)
layer = iface.activeLayer()
layer_cache = QgsVectorLayerCache(layer, 10000, chartView)
layer_cache.setFullCache(True)
model = QgsAttributeTableModel(layer_cache, chartView)
model.loadLayer()
self._mapper.setModel(model)
chart.addSeries(series)
def runReporting(self):
(res1, res2) = self.model.runReportingWithContext(self.dlg.context,self.dlg.feedback)
out_path = res1[FragScape_algs.EffectiveMeshSizeGlobalAlgorithm.OUTPUT]
out_global_meff = res2[FragScape_algs.EffectiveMeshSizeGlobalAlgorithm.OUTPUT_GLOBAL_MEFF]
# UI update
self.dlg.resultsGlobalRes.setText(str(out_global_meff))
self.loaded_layer = qgsUtils.loadVectorLayer(out_path,loadProject=True)
self.layer_cache = QgsVectorLayerCache(self.loaded_layer,24)
self.attribute_model = QgsAttributeTableModel(self.layer_cache)
self.attribute_model.loadLayer()
self.dlg.resultsView.setModel(self.attribute_model)
self.dlg.resultsView.show()
def testTransactionRollback(self):
"""Test issue https://github.com/qgis/QGIS/issues/48171#issuecomment-1132709901"""
d = QTemporaryDir()
path = d.path()
source_fields = QgsFields()
source_fields.append(QgsField('int', QVariant.Int))
vl = QgsMemoryProviderUtils.createMemoryLayer('test', source_fields)
f = QgsFeature()
f.setAttributes([1])
vl.dataProvider().addFeature(f)
tmpfile = os.path.join(path, 'testTransactionRollback.sqlite')
options = {
'driverName': 'SpatiaLite',
'layerName': 'test'
}
err = QgsVectorLayerExporter.exportLayer(vl, tmpfile, "ogr", vl.crs(), False, options)
self.assertEqual(err[0], QgsVectorLayerExporter.NoError,
'unexpected import error {0}'.format(err))
vl = QgsVectorLayer(
'dbname=\'{}\' table="test" () sql='.format(tmpfile), 'test', 'spatialite')
self.assertTrue(vl.isValid())
p = QgsProject.instance()
p.setTransactionMode(Qgis.TransactionMode.AutomaticGroups)
self.assertTrue(p.addMapLayer(vl))
cache = QgsVectorLayerCache(vl, 100)
am = QgsAttributeTableModel(cache)
am.loadLayer()
self.assertEqual(am.rowCount(), 1)
self.assertTrue(vl.startEditing())
vl.beginEditCommand('edit1')
f = QgsFeature()
f.setAttributes([2])
self.assertTrue(vl.addFeature(f))
self.assertEqual(am.rowCount(), 2)
self.assertEqual(len([f for f in vl.getFeatures()]), 2)
vl.endEditCommand()
self.assertTrue(vl.rollBack())
self.assertEqual(len([f for f in vl.getFeatures()]), 1)
self.assertEqual(am.rowCount(), 1)
def loadTable(self):
"""
Loads the attribute table. This is still not working properly. QGIS crashes.
"""
currLayer = self.iface.activeLayer()
if not currLayer:
return
if currLayer.type() != QgsMapLayer.VectorLayer:
return
cache = QgsVectorLayerCache(currLayer, 10)
model = QgsAttributeTableModel(cache)
model.loadLayer()
filterModel = QgsAttributeTableFilterModel(self.iface.mapCanvas(),
model)
self.tableView.setModel(model)
self.tableView.show()
def __init__(self, parent):
QDialog.__init__(self)
self.setupUi(self)
uri = QgsDataSourceUri()
uri.setConnection('localhost', '5432', 'etienne', 'postgres',
os.environ['APP_PASSWORD'])
uri.setDataSource('public', 'equipements', None)
self.layer = QgsVectorLayer(uri.uri(False), 'equipements', 'postgres')
self.layer_cache = QgsVectorLayerCache(self.layer, 120)
self.model = QgsAttributeTableModel(self.layer_cache)
self.model.loadLayer()
tbl_filter_model = QgsAttributeTableFilterModel(
QgsMapCanvas(), self.model)
self.attribute_table.setModel(tbl_filter_model)
self.attribute_table.resizeRowsToContents()
self.attribute_table.resizeColumnsToContents()
self.add_item.clicked.connect(self.add_new_item)
self.exec_()
def setUp(self):
self.layer = self.createLayer()
self.cache = QgsVectorLayerCache(self.layer, 100)
self.am = QgsAttributeTableModel(self.cache)
self.am.loadLayer()
def getSource(cls):
cache = QgsVectorLayerCache(cls.vl, 100)
return cache
# coding: utf-8
from PyQt4.QtGui import QDialog, QTableView
from qgis.core import QgsVectorLayerCache
from qgis.gui import (QgsAttributeTableModel, QgsAttributeTableView,
QgsAttributeTableFilterModel)
from qgis.utils import iface
new_dialog = QDialog()
new_dialog.resize(800, 600)
vector_layer_cache = QgsVectorLayerCache(iface.activeLayer(), 10000)
attribute_table_model = QgsAttributeTableModel(vector_layer_cache)
attribute_table_model.loadLayer()
attribute_table_filter_model = QgsAttributeTableFilterModel(
iface.mapCanvas(), attribute_table_model)
attribute_table_view = QgsAttributeTableView(new_dialog)
attribute_table_view.setModel(attribute_table_filter_model)
new_dialog.show()
# Or display the attribute_table_model with QTableView (pure QT solution)
table_view = QTableView()
table_view.setModel(attribute_table_model)
table_view.show()
# coding: utf-8
from PyQt4.QtGui import QDialog
from qgis.core import QgsVectorLayerCache
from qgis.gui import (QgsAttributeTableFilterModel, QgsAttributeTableModel,
QgsFeatureListModel, QgsFeatureListView,
QgsFeatureListViewDelegate)
from qgis.utils import iface
new_dialog = QDialog()
new_dialog.resize(270, 210)
layer = iface.activeLayer()
canvas = iface.mapCanvas()
feature_list_view = QgsFeatureListView(new_dialog)
vector_layer_cache = QgsVectorLayerCache(layer, 10000)
attribute_table_model = QgsAttributeTableModel(vector_layer_cache)
attribute_table_model.loadLayer()
attribute_table_filter_model = QgsAttributeTableFilterModel(
canvas, attribute_table_model)
feature_list_model = QgsFeatureListModel(attribute_table_filter_model)
feature_list_model.setDisplayExpression('"ADMIN"')
feature_list_view_delegate = QgsFeatureListViewDelegate(feature_list_model)
feature_list_view.setModel(feature_list_model)
# feature_list_view.setItemDelegate(feature_list_view_delegate) # Crash if uncommented. TODO: fix issue
new_dialog.show()
