Python QgsVectorLayer.deleteLater方法代码示例

# 需要导入模块: from qgis.core import QgsVectorLayer [as 别名]
# 或者: from qgis.core.QgsVectorLayer import deleteLater [as 别名]
    def reloadInputLayer(self):
        """ create the input layer and update available options """
        if self.mode != self.ASK_FOR_INPUT_MODE:
            return True

        self.deleteInputLayer()

        index = self.cboInputLayer.currentIndex()
        if index < 0:
            filename = self.cboInputLayer.currentText()
            if filename == "":
                return False

            layerName = QFileInfo(filename).completeBaseName()
            layer = QgsVectorLayer(filename, layerName, "ogr")
            if not layer.isValid() or layer.type() != QgsMapLayer.VectorLayer:
                layer.deleteLater()
                return False

            self.inLayer = layer
            self.inLayerMustBeDestroyed = True

        else:
            layerId = self.cboInputLayer.itemData(index)
            self.inLayer = QgsMapLayerRegistry.instance().mapLayer(layerId)
            self.inLayerMustBeDestroyed = False

        self.checkSupports()
        return True

# 需要导入模块: from qgis.core import QgsVectorLayer [as 别名]
# 或者: from qgis.core.QgsVectorLayer import deleteLater [as 别名]
    def _loadTablePreview(self, table, limit=False):
        """ if has geometry column load to map canvas """
        QApplication.setOverrideCursor(QCursor(Qt.WaitCursor))
        self.setRenderFlag(False)
        vl = None

        if table and table.geomType:
            # limit the query result if required
            if limit and table.rowCount > 1000:
                uniqueField = table.getValidQGisUniqueFields(True)
                if uniqueField is None:
                    self.parent.tabs.setCurrentWidget(self.parent.info)
                    self.parent.infoBar.pushMessage(
                        QApplication.translate("DBManagerPlugin", "Unable to find a valid unique field"),
                        QgsMessageBar.WARNING,
                        self.parent.iface.messageTimeout(),
                    )
                    return

                uri = table.database().uri()
                uri.setDataSource(
                    "", u"(SELECT * FROM %s LIMIT 1000)" % table.quotedName(), table.geomColumn, "", uniqueField.name
                )
                provider = table.database().dbplugin().providerName()
                vl = QgsVectorLayer(uri.uri(False), table.name, provider)
            else:
                vl = table.toMapLayer()

            if not vl.isValid():
                vl.deleteLater()
                vl = None

        # remove old layer (if any) and set new
        if self.currentLayer:
            QgsMapLayerRegistry.instance().removeMapLayers([self.currentLayer.id()])

        if vl:
            self.setLayerSet([QgsMapCanvasLayer(vl)])
            QgsMapLayerRegistry.instance().addMapLayers([vl], False)
            self.zoomToFullExtent()
        else:
            self.setLayerSet([])

        self.currentLayer = vl

        self.setRenderFlag(True)
        QApplication.restoreOverrideCursor()

# 需要导入模块: from qgis.core import QgsVectorLayer [as 别名]
# 或者: from qgis.core.QgsVectorLayer import deleteLater [as 别名]
    def _loadTablePreview(self, table, limit=False):
        """ if has geometry column load to map canvas """
        with OverrideCursor(Qt.WaitCursor):
            self.freeze()
            vl = None

            if table and table.geomType:
                # limit the query result if required
                if limit and table.rowCount > 1000:
                    uniqueField = table.getValidQgisUniqueFields(True)
                    if uniqueField is None:
                        self.parent.tabs.setCurrentWidget(self.parent.info)
                        self.parent.infoBar.pushMessage(
                            QApplication.translate("DBManagerPlugin", "Unable to find a valid unique field"),
                            Qgis.Warning, self.parent.iface.messageTimeout())
                        return

                    uri = table.database().uri()
                    uri.setDataSource("", u"(SELECT * FROM %s LIMIT 1000)" % table.quotedName(), table.geomColumn, "",
                                      uniqueField.name)
                    provider = table.database().dbplugin().providerName()
                    vl = QgsVectorLayer(uri.uri(False), table.name, provider)
                else:
                    vl = table.toMapLayer()

                if vl and not vl.isValid():
                    vl.deleteLater()
                    vl = None

            # remove old layer (if any) and set new
            if self.currentLayerId:
                if not QgsProject.instance().layerTreeRoot().findLayer(self.currentLayerId):
                    QgsProject.instance().removeMapLayers([self.currentLayerId])

            if vl and vl.isValid():
                self.setLayers([vl])
                QgsProject.instance().addMapLayers([vl], False)
                self.zoomToFullExtent()
                self.currentLayerId = vl.id()
            else:
                self.setLayers([])
                self.currentLayerId = None

            self.freeze(False)
            super().refresh()

# 需要导入模块: from qgis.core import QgsVectorLayer [as 别名]
# 或者: from qgis.core.QgsVectorLayer import deleteLater [as 别名]
	def addBasemapLayer(self):
		if self.basemapVl:
			return # already added

		current_dir = QFileInfo(__file__).absoluteDir()
		basemap = current_dir.absoluteFilePath( u"data/basemap/Countries.shp" )

		# load the basemap layer
		vl = QgsVectorLayer(basemap, QFileInfo(basemap).baseName(), "ogr")
		if not vl.isValid():
			vl.deleteLater()
			return

		# add the basemap layer to canvas
		LayerStyler.setBasemapStyle(vl)
		self.basemapVl = vl
		QObject.connect( self.basemapVl, SIGNAL("layerDeleted()"), self.basemapLayerDestroyed )
		Utils.addVectorLayer(vl)

# 需要导入模块: from qgis.core import QgsVectorLayer [as 别名]
# 或者: from qgis.core.QgsVectorLayer import deleteLater [as 别名]
	def run(self):
		# layer base name and dir path
		base_name = QFileInfo(self._fn).baseName()
		dir_path = QFileInfo(self._fn).absoluteDir()

		# create the uri for the delimitedtext provider
		from .settings_dlg import Settings
		csvUrl = QUrl.fromLocalFile( self._fn )
		csvUrl.setQueryItems( [
			( "delimiter", Settings.delimiter() ),
			( "delimiterType", "plain"),
			( "xField", Settings.longitudeField() ),
			( "yField", Settings.latitudeField() )
		] )

		# load the layer
		from qgis.core import QgsVectorLayer
		csvVl = QgsVectorLayer(csvUrl.toString(), base_name, "delimitedtext")
		if not csvVl.isValid():	# invalid layer
			csvVl.deleteLater()
			QMessageBox.warning( self.parent(), "Invalid layer", 
								u"Unable to load the layer %s" % self._fn )
			return (self.INVALID_INPUT, None)

		# check the layer geometry type
		from qgis.core import QGis
		if csvVl.geometryType() != QGis.Point:
			csvVl.deleteLater()
			QMessageBox.warning( self.parent(), "Invalid layer", 
								u"Unable to get data from the selected file. \nSetup Lat/Long field names and delimiter from the Settings dialog, \nthen try again." )
			return (self.INVALID_LATLON, None)

		# check whether the CSV file has to be imported to SL db
		if not Settings.importCsvToSl():
			return (self.OK, csvVl)

		# uri pointing to the new SL database
		from qgis.core import QgsDataSourceURI
		sqlite_path = dir_path.absoluteFilePath( u"%s.sqlite" % base_name )
		slUri = QgsDataSourceURI()
		slUri.setDatabase( sqlite_path )
		slUri.setDataSource( "", base_name, "GEOMETRY" )

		importer = Ogr2ogrImporter(csvVl, slUri, self.parent())
		#importer = QGisLayerImporter(csvVl, slUri, self.parent())
		ret = importer.start()

		# get the importer exit code
		if not ret:
			if importer.wasCanceled():
				ret = self.CANCELED
			else:
				ret = self.ERROR
				QMessageBox.warning( self.parent(), "Error", importer.errorMessage() )
		else:
			ret = self.OK

		# cleanup
		importer.deleteLater()
		importer = None

		csvVl.deleteLater()
		csvVl = None

		if ret != self.OK:
			return (ret, None)

		# load the layer from the SL database
		slVl = QgsVectorLayer(slUri.uri(), slUri.table(), "spatialite")
		if not slVl.isValid():	# invalid layer
			slVl.deleteLater()
			QMessageBox.warning( self.parent(),	"Invalid layer",
								u"Unable to load the layer %s" % slUri.database() )
			return (self.ERROR, None)

		# check the layer geometry type
		if slVl.geometryType() != QGis.Point:
			slVl.deleteLater()
			return (self.ERROR, None)

		return (self.OK, slVl)