def inlezen(self):
targetLayerName = self.import_laag.currentText()
targetLayer = UC.getlayer_byname(targetLayerName)
sourceLayerName = 'tempImport'
sourceLayer = UC.getlayer_byname(sourceLayerName)
features = []
for feature in sourceLayer.getFeatures():
features.append(feature)
UC.write_layer(targetLayer, features, False, False)
MSG.showMsgBox('importsuccesfull')
QC.QgsProject.instance().removeMapLayers([sourceLayer.id()])
def ask_user_for_feature(self, idLayer, allFeatures):
"""if more features are identified ask user which one to choose"""
targetFeature = None
query = "SELECT identifier, type_layer_name FROM {} WHERE child_layer = '{}'".format(self.whichConfig, idLayer.name())
attrs = UC.read_settings(query, False)
sortList = []
for feat in allFeatures:
if len(attrs) > 1:
typeValue = feat[attrs[0]]
if isinstance(typeValue, (int, float)):
req = '"id" = {}'.format(typeValue)
request = QC.QgsFeatureRequest().setFilterExpression(req)
type_layer = UC.getlayer_byname(attrs[1])
tempFeature = next(type_layer.getFeatures(request))
sortList.append([feat["id"], tempFeature["naam"]])
else:
sortList.append([feat["id"], typeValue])
elif attrs:
sortList.append([feat["id"], feat[attrs[0]]])
else:
sortList = None
if sortList:
AskFeatureDialog.askList = sortList
chosen, dummy = AskFeatureDialog.askFeature()
for feat in allFeatures:
if feat["id"] == int(chosen):
targetFeature = feat
return targetFeature
def create_kaartblad(self, withGrid):
gridUUID = uuid.uuid4()
geom = self.rubberBand.asGeometry()
geom.convertToMultiType()
layerName = PC.OBJECT["gridlayername"]
layer = UC.getlayer_byname(layerName)
targetFeature = QC.QgsFeature()
targetFields = layer.fields()
targetFeature.initAttributes(targetFields.count())
targetFeature.setFields(targetFields)
targetFeature.setGeometry(geom)
targetFeature["type"] = 'Kaartblad'
if self.scale_25000.isChecked():
targetFeature["scale"] = GH.DEFAULTSCALE
else:
targetFeature["scale"] = self.scale_custom.value()
targetFeature["papersize"] = self.format_combo.currentText()
if self.orient_landscape.isChecked():
targetFeature["orientation"] = 'landscape'
else:
targetFeature["orientation"] = 'portrait'
targetFeature["uuid"] = str(gridUUID)
foreignKey = CH.get_foreign_key_ob(layerName)
targetFeature[foreignKey] = self.objectId
UC.write_layer(layer, targetFeature)
bbox = geom.boundingBox()
dist = self.distance_grid.value()
if withGrid:
self.create_grid(gridUUID, dist, bbox, 'Kaartblad')
self.canvas.scene().removeItem(self.rubberBand)
def get_identified_terrein(self, ilayer, ifeature):
"""Return of identified layer and feature and get related object"""
#the identified layer must be "Object" or "Object terrein"
drawLayer = UC.getlayer_byname(OBJECT["objectlayername"])
if ilayer is None:
self.run_new_object('wordt gekoppeld in de database', 'BGT',
'wordt gekoppeld in de database')
elif ilayer.name() == bagpand_layername() and "PDOK" in ilayer.name():
objectId = str(ifeature["identificatie"])
bron = "BAG"
bron_tabel = "Pand"
self.run_new_object(objectId, bron, bron_tabel)
elif ilayer.name() == bagpand_layername():
objectId = str(ifeature["identificatie"])
bron = ifeature["bron"]
bron_tabel = ifeature["bron_tbl"]
self.run_new_object(objectId, bron, bron_tabel)
elif ilayer.name() == OBJECT["objectlayername"]:
objectId = ifeature["id"]
formeleNaam = ifeature["formelenaam"]
self.run_object(formeleNaam, objectId)
elif ilayer.name() == OBJECT["terreinlayername"]:
objectId = ifeature["object_id"]
request = QC.QgsFeatureRequest().setFilterExpression('"id" = ' +
str(objectId))
ifeature = next(drawLayer.getFeatures(request))
formeleNaam = ifeature["formelenaam"]
self.run_object(formeleNaam, objectId)
#if another layer is identified there is no object that can be determined, so a message is send to the user
else:
MSG.showMsgBox('noidentifiedobject')
self.identifyTool.geomIdentified.disconnect()
def stop_moveTool(self):
"""na de actie verschuiven/bewerken moeten de betreffende lagen opgeslagen worden en bewerken moet worden uitgezet"""
for lyrName in self.moveLayerNames:
moveLayer = UC.getlayer_byname(lyrName)
moveLayer.commitChanges()
moveLayer.reload()
self.activatePan()
def run_move_point(self):
"""om te verschuiven/roteren moeten de betreffende lagen op bewerken worden gezet"""
for lyrName in self.moveLayerNames:
moveLayer = UC.getlayer_byname(lyrName)
moveLayer.startEditing()
self.parent.moveTool.onMoved = self.stop_moveTool
self.canvas.setMapTool(self.parent.moveTool)
def run(self):
"""run the plugin, if project is not OIV object, deactivate plugin when clicked on icon"""
project = QC.QgsProject.instance()
projectTest = str(
QC.QgsExpressionContextUtils.projectScope(project).variable(
'project_title'))
try:
layer = UC.getlayer_byname('applicatie')
request = QC.QgsFeatureRequest().setFilterExpression('"id" = 1')
dbVersion = next(layer.getFeatures(request))["db_versie"]
except:
dbVersion = 0
if 'Objecten' not in projectTest:
self.toolbar.setEnabled(False)
self.action.setEnabled(False)
elif PLUGIN["compatibleDbVersion"]["max"] < dbVersion < PLUGIN[
"compatibleDbVersion"]["min"]:
MSG.showMsgBox('invaliddatabaseversion')
self.toolbar.setEnabled(False)
self.action.setEnabled(False)
else:
# always start from floor 1
self.basewidget = OB.oivBaseWidget(self)
subString = "bouwlaag = 1"
UG.set_layer_substring(subString)
index = self.projCombo.findText('1', PQtC.Qt.MatchFixedString)
if index >= 0:
self.projCombo.setCurrentIndex(index)
self.iface.addDockWidget(QT.getWidgetType(), self.basewidget)
self.basewidget.show()
self.toolbar.setEnabled(False)
self.projCombo.setEnabled(False)
self.checkVisibility = True
def import_bouwlaag(self, bouwlaagFeature):
"""after the checks the import of the floor can start"""
childFeature = QC.QgsFeature()
layerName = 'Bouwlagen'
layer = UC.getlayer_byname(layerName)
# get necessary attributes from config file
foreignKey = CH.get_foreign_key_bl(layerName)
# construct QgsFeature to save
childFeature.setGeometry(bouwlaagFeature.geometry())
fields = layer.fields()
childFeature.initAttributes(fields.count())
childFeature.setFields(fields)
childFeature[foreignKey] = str(self.object_id.text())
childFeature["bouwlaag"] = int(self.bouwlaag.text())
newFeatureId = UC.write_layer(layer, childFeature)
self.bouwlaag_id.setText(str(newFeatureId))
self.iface.actionPan().trigger()
self.label2.setVisible(False)
self.selectId.setVisible(False)
self.label3.setVisible(True)
self.label4.setVisible(True)
self.label5a.setVisible(True)
self.label5b.setVisible(True)
self.import_laag.setVisible(True)
self.check.setVisible(True)
self.type.setVisible(True)
def draw_feature(self, points, _dummy):
"""create the floor feature and save to the floors layer"""
minBouwlaag = int(self.bouwlaag_min.text())
maxBouwlaag = int(self.bouwlaag_max.text())
childFeature = QC.QgsFeature()
layerName = PC.PAND["bouwlaaglayername"]
layer = UC.getlayer_byname(layerName)
foreignKey = CH.get_foreign_key_bl(layerName)
# construct QgsFeature to save
for i in range(minBouwlaag, maxBouwlaag + 1):
if i != 0:
childFeature.setGeometry(QC.QgsGeometry.fromPolygonXY([points
]))
fields = layer.fields()
childFeature.initAttributes(fields.count())
childFeature.setFields(fields)
childFeature[foreignKey] = self.objectId
childFeature["bouwlaag"] = i
UC.write_layer(layer, childFeature)
# block the signals of changing the comboBox to add the new floor
self.bouwlaag.blockSignals(True)
self.bouwlaag.clear()
if i not in self.bouwlaagList:
self.bouwlaagList.append(i)
self.bouwlaagList.sort()
self.bouwlagen_to_combobox()
self.bouwlaag.blockSignals(False)
self.iface.actionPan().trigger()
# set all layers substring to the right floor
sub_string = "bouwlaag = " + str(minBouwlaag)
UG.set_layer_substring(sub_string)
if maxBouwlaag != minBouwlaag:
MSG.showMsgBox('bouwlaagcreated')
def inlezen(self):
"""import the file after all settings wehere made"""
importAttr = self.type.currentText()
invalidCount = 0
for importType in self.mappingDict:
if self.mappingDict[importType]["targetType"] != 'niet importeren':
checkConv = False
expr = QC.QgsExpression('"{}"= \'{}\''.format(
importAttr, importType))
featureIt = self.importLayer.getFeatures(
QC.QgsFeatureRequest(expr))
targetFeature = QC.QgsFeature()
targetLayerName = self.mappingDict[importType]["layerName"]
if 'Labels' in targetLayerName:
LabelDialog.attributes = [
self.type.itemText(i) for i in range(self.type.count())
]
LabelDialog.importType = importType
labelField, dummy = LabelDialog.getLabelAtrribute()
targetLayer = UC.getlayer_byname(targetLayerName)
targetFields = targetLayer.fields()
targetFeature.initAttributes(targetFields.count())
targetFeature.setFields(targetFields)
if self.mappingDict[importType][
"convType"] != self.layerImportType:
checkConv = True
query = "SELECT foreign_key, identifier, input_label FROM config_object WHERE child_layer = '{}'".format(
targetLayerName)
attrs = UC.read_settings(query, False)[0]
targetFeature[
attrs[1]] = self.mappingDict[importType]["targetType"]
targetFeature[attrs[0]] = self.object_id.text()
targetLayer.startEditing()
for feat in featureIt:
geom = None
if not checkConv:
geom = EF.getfeature_geometry(feat.geometry(),
self.layerImportType)
if 'Labels' in targetLayerName:
if feat[labelField]:
targetFeature[attrs[2]] = feat[labelField]
else:
targetFeature[attrs[2]] = 'geen label'
if geom:
targetFeature.setGeometry(geom)
invalidCheck = UC.write_layer(targetLayer,
targetFeature, True)
if invalidCheck == 'invalid':
invalidCount += 1
targetLayer.commitChanges()
if invalidCount > 0:
MSG.showMsgBox('importpartiallysuccesfull',
'{}'.format(invalidCount))
else:
MSG.showMsgBox('importsuccesfull')
QC.QgsProject.instance().removeMapLayers([self.importLayer.id()])
def run_tekenen(self):
'''place new object (i-tje)'''
if self.bron.text() == 'BAG':
runLayer = PC.OBJECT["objectlayername"]
else:
runLayer = PC.OBJECT["objectbgtlayername"]
self.drawLayer = UC.getlayer_byname(runLayer)
self.canvas.setMapTool(self.parent.pinTool)
self.parent.pinTool.canvasClicked.connect(self.place_feature)
def run_bag_overnemen(self):
"""copy polygon of bag feature"""
UG.set_lengte_oppervlakte_visibility(self, False, False, False, False)
layerName = PC.bagpand_layername()
ilayer = UC.getlayer_byname(layerName)
request = QC.QgsFeatureRequest().setFilterExpression(
'"identificatie" = ' + "'{}'".format(self.objectId))
ifeature = next(ilayer.getFeatures(request))
self.copy_bag_bouwlaag(ilayer, ifeature)
def copy_selected_layers(self, ifeature, newFeatureId, bouwlaag):
"""copy related selected features"""
bouwlaagID = ifeature["id"]
for var in vars(self):
typeVar = type(vars(self)[var])
if typeVar == PQtW.QCheckBox:
if vars(self)[var].isChecked():
copyLayer = UC.getlayer_byname(vars(self)[var].text())
self.copy_layers(bouwlaagID, newFeatureId, copyLayer,
bouwlaag)
def run_terrein_toevoegen(self):
objectId = self.object_id.text()
possibleSnapFeatures = UC.get_possible_snapFeatures_object(self.snapLayerNames, objectId)
self.drawTool.parent = self
self.drawTool.layer = UC.getlayer_byname(PC.OBJECT["terreinlayername"])
UG.set_lengte_oppervlakte_visibility(self, True, True, True, True)
self.drawTool.possibleSnapFeatures = possibleSnapFeatures
self.drawTool.canvas = self.canvas
self.drawTool.onGeometryAdded = self.place_object_terrein
self.drawTool.captureMode = 2
self.canvas.setMapTool(self.drawTool)
def run_objectgegevens_bewerken(self):
"""select bouwlaag on canvas to edit the atrribute form"""
objectId = self.object_id.text()
request = QC.QgsFeatureRequest().setFilterExpression('"id" = ' + str(objectId))
tempLayer = UC.getlayer_byname(PC.OBJECT["objectlayername"])
objectFeatIt = tempLayer.getFeatures(request)
try:
objectFeature = next(objectFeatIt)
self.edit_attribute(tempLayer, objectFeature)
except StopIteration:
MSG.showMsgBox('no_objectid')
def run_bouwlaag_bewerken(self):
runLayer = PC.PAND["bouwlaaglayername"]
ilayer = UC.getlayer_byname(runLayer)
objectId = self.pand_id.text()
foreignKey = CH.get_foreign_key_bl(runLayer)
request = QC.QgsFeatureRequest().setFilterExpression(foreignKey +
" = '" +
str(objectId) +
"'")
ifeature = next(ilayer.getFeatures(request))
self.run_edit_bouwlagen(ilayer, ifeature)
def set_layer_substring(subString):
"""set layer subset according (you can check the subset under properties of the layer)"""
layersInEditMode = []
layerNames = CH.get_chidlayers_bl()
for layerName in layerNames:
layer = UC.getlayer_byname(layerName[0])
if layer.isModified():
saveChanges = MSG.showMsgBox('unsavedchanges', layerName[0])
if saveChanges:
layer.commitChanges()
else:
layer.rollBack()
elif layer.isEditable():
layersInEditMode.append(layer)
layer.commitChanges()
for layerName in layerNames:
lyr = UC.getlayer_byname(layerName[0])
lyr.setSubsetString(subString)
if lyr in layersInEditMode:
lyr.startEditing()
return "succes"
def place_object_terrein(self, points, _dummy):
"""save drawn terrain"""
layer = UC.getlayer_byname(PC.OBJECT["terreinlayername"])
if points:
parentId, childFeature = UC.construct_feature('Polygon', PC.OBJECT["objectlayername"], points, self.object_id.text(), self.iface)
if parentId is not None:
buttonCheck = UC.get_attributes(parentId, childFeature, None, None, layer, PC.OBJECT["configtable"])
if buttonCheck != 'Cancel':
UC.write_layer(layer, childFeature)
layer.commitChanges()
layer.triggerRepaint()
self.activatePan()
def run_bouwlaag_tekenen(self):
"""draw a floor with the basic functionality of QGIS"""
drawTool = self.parent.drawTool
possibleSnapFeatures = UC.get_possible_snapFeatures_bouwlaag(
self.snapLayerNames, self.objectId)
layer = UC.getlayer_byname(PC.PAND["bouwlaaglayername"])
drawTool.layer = layer
drawTool.possibleSnapFeatures = possibleSnapFeatures
drawTool.canvas = self.canvas
drawTool.onGeometryAdded = self.draw_feature
drawTool.captureMode = 2
self.canvas.setMapTool(drawTool)
UG.set_lengte_oppervlakte_visibility(self, True, True, True, True)
drawTool.parent = self
def copy_bag_bouwlaag(self, ilayer, ifeature):
"""copy the floor drom the BAG features"""
if ilayer.name() == PC.PAND["bouwlaaglayername"] or ilayer.name(
) == PC.bagpand_layername():
childFeature = QC.QgsFeature()
layerName = PC.PAND["bouwlaaglayername"]
# get active floor from dockwidget
minBouwlaag = int(self.bouwlaag_min.text())
maxBouwlaag = int(self.bouwlaag_max.text())
layer = UC.getlayer_byname(layerName)
# get necessary attributes from config file
foreignKey = CH.get_foreign_key_bl(layerName)
# construct QgsFeature to save
for i in range(minBouwlaag, maxBouwlaag + 1):
if i != 0:
childFeature.setGeometry(ifeature.geometry())
fields = layer.fields()
childFeature.initAttributes(fields.count())
childFeature.setFields(fields)
childFeature[foreignKey] = self.objectId
childFeature["bouwlaag"] = i
newFeatureId = UC.write_layer(layer, childFeature)
# copy also the selected layers
if ilayer.name() == PC.PAND["bouwlaaglayername"]:
self.copy_selected_layers(ifeature, newFeatureId, i)
# block the signals of changing the comboBox to add the new floor
self.bouwlaag.blockSignals(True)
self.bouwlaag.clear()
if i not in self.bouwlaagList:
self.bouwlaagList.append(i)
self.bouwlaagList.sort()
self.bouwlagen_to_combobox()
self.bouwlaag.blockSignals(False)
self.iface.actionPan().trigger()
# set all layers substring to the right floor
sub_string = "bouwlaag = " + str(minBouwlaag)
UG.set_layer_substring(sub_string)
try:
self.parent.selectTool.geomSelected.disconnect()
except: # pylint: disable=bare-except
pass
if maxBouwlaag >= minBouwlaag:
MSG.showMsgBox('bouwlaagcreated')
else:
MSG.showMsgBox('nobouwlaagselected')
try:
self.parent.selectTool.geomSelected.disconnect()
except: # pylint: disable=bare-except
pass
self.parent.selectTool.geomSelected.connect(self.copy_bag_bouwlaag)
def edit_attribute(self, ilayer, ifeature):
"""open het formulier van een feature in een dockwidget, zodat de attributen kunnen worden bewerkt"""
stackWidget = SW.oivStackWidget()
self.iface.addDockWidget(QT.getWidgetType(), stackWidget)
stackWidget.parentWidget = self
stackWidget.open_feature_form(ilayer, ifeature)
self.close()
layerNames = PC.OBJECT["nogeotables"]
for name in layerNames:
layer = UC.getlayer_byname(name)
layer.updateExtents()
stackWidget.show()
try:
self.selectTool.geomSelected.disconnect(self.edit_attribute)
except: # pylint: disable=bare-except
pass
def read_types(self):
types = {}
actionList, dummy, dummy = UG.get_actions('config_object')
for lst in actionList:
tempList = []
for action in lst:
layerName = action[0]
layer = UC.getlayer_byname(layerName)
layerType = UC.check_layer_type(layer)
tempList.append(action[1])
tempList.append("niet importeren")
if layerType in types:
types[layerType].update({layerName: tempList})
else:
types.update({layerType: {layerName: tempList}})
return types
def run_tekenen(self, _dummy, runLayer, feature_id):
"""activate the right draw action"""
#welke pictogram is aangeklikt en wat is de bijbehorende tekenlaag
snapLayerNames = []
self.identifier = feature_id
self.drawLayer = UC.getlayer_byname(runLayer)
self.drawLayerType = UC.check_layer_type(self.drawLayer)
self.parentLayerName = CH.get_parentlayer_bl(runLayer)
objectId = self.pand_id.text()
#aan welke lagen kan worden gesnapt?
baglayerName = PC.bagpand_layername()
snapLayerNames = DW.BLSNAPLAYERS
if baglayerName not in snapLayerNames:
snapLayerNames.append(baglayerName)
possibleSnapFeatures = UC.get_possible_snapFeatures_bouwlaag(
snapLayerNames, objectId)
if self.drawLayerType == "Point":
pointTool = self.parent.pointTool
pointTool.snapPt = None
pointTool.snapping = False
pointTool.startRotate = False
pointTool.possibleSnapFeatures = possibleSnapFeatures
if self.identifier in DW.BLSNAPSYMBOLS:
pointTool.snapping = True
pointTool.layer = self.drawLayer
self.canvas.setMapTool(pointTool)
UG.set_lengte_oppervlakte_visibility(self, False, False, False,
False)
pointTool.onGeometryAdded = self.place_feature
else:
drawTool = self.parent.drawTool
if self.drawLayerType == "LineString":
drawTool.captureMode = 1
UG.set_lengte_oppervlakte_visibility(self, True, True, False,
True)
else:
drawTool.captureMode = 2
UG.set_lengte_oppervlakte_visibility(self, True, True, True,
True)
drawTool.layer = self.drawLayer
drawTool.possibleSnapFeatures = possibleSnapFeatures
drawTool.canvas = self.canvas
drawTool.onGeometryAdded = self.place_feature
self.canvas.setMapTool(drawTool)
drawTool.parent = self
def initUI(self):
"""fill the lineedits with values"""
#Get the related BAG attributes from BAG API
ilayer = UC.getlayer_byname(PC.bagpand_layername())
foreignKey = 'identificatie'
objectId = self.pand_id.text()
request = QC.QgsFeatureRequest().setFilterExpression(foreignKey +
" = '" +
objectId + "'")
tempFeature = next(ilayer.getFeatures(request))
bagGebruiksdoel = str(tempFeature['gebruiksdoel'])
if self.adres_1.text() == "":
bagAdres1, bagAdres2, bagGebruiksdoel = QB.ask_bag_adress(
objectId, bagGebruiksdoel)
self.adres_1.setText(bagAdres1)
self.adres_2.setText(bagAdres2)
self.gebruiksdoel.setText(bagGebruiksdoel)
self.bouwlagen_to_combobox(objectId, None)
def create_grid(self,
gridUUID=None,
dist=None,
extent=None,
gridType='Grid'):
if not gridUUID:
gridUUID = uuid.uuid4()
if not dist and not extent:
extent = self.canvas.extent()
dist = self.distance.value()
layerName = PC.OBJECT["gridlayername"]
layer = UC.getlayer_byname(layerName)
targetFeature = QC.QgsFeature()
targetFields = layer.fields()
targetFeature.initAttributes(targetFields.count())
targetFeature.setFields(targetFields)
foreignKey = CH.get_foreign_key_ob(layerName)
xmin, dummy, ymin, dummy, xIt, yIt = self.calculate_extent(
dist, extent, gridType)
objectId = self.objectId
targetFeature[foreignKey] = objectId
targetFeature["type"] = 'Grid'
for x in range(0, xIt):
for y in range(0, yIt):
yLabel = str(y + 1)
if xIt < 26:
xLabel = chr(x + 97).upper()
elif xIt >= 26:
xLabel = chr(int(math.floor(x / 26)) +
97).upper() + chr(x % 26 + 97).upper()
geom = self.calculate_geometry(dist, xmin, ymin, x, y,
gridType)
targetFeature['vaknummer'] = xLabel + yLabel
if x != 0:
yLabel = ''
if y != 0:
xLabel = ''
targetFeature.setGeometry(geom)
targetFeature['y_as_label'] = yLabel
targetFeature['x_as_label'] = xLabel
targetFeature['afstand'] = dist
targetFeature["uuid"] = str(gridUUID)
UC.write_layer(layer, targetFeature)
MSG.showMsgBox('gridcreated')
def place_feature(self, point):
childFeature = QC.QgsFeature()
objectLayer = UC.getlayer_byname(PC.OBJECT["objectlayername"])
# set geometry from the point clicked on the canvas
childFeature.setGeometry(QC.QgsGeometry.fromPointXY(point))
foreignKey = self.identificatienummer.text()
buttonCheck, formeleNaam = self.get_attributes(foreignKey,
childFeature)
# return of new created feature id
if buttonCheck != 'Cancel':
UC.write_layer(self.drawLayer, childFeature)
objectLayer.reload()
self.close_objectnieuw_show_base()
else:
self.iface.actionPan().trigger()
try:
self.parent.pinTool.canvasClicked.disconnect()
except:
pass
def run_delete_object(self):
"""delete repressief object"""
ilayer = UC.getlayer_byname(PC.OBJECT["objectlayername"])
objectId = self.object_id.text()
request = QC.QgsFeatureRequest().setFilterExpression('"id" = ' + str(objectId))
ifeature = next(ilayer.getFeatures(request))
ilayer.startEditing()
ilayer.selectByIds([ifeature.id()])
reply = MSG.showMsgBox('deleteobject')
if not reply:
#als "nee" deselecteer alle geselecteerde features
ilayer.selectByIds([])
elif reply:
#als "ja" -> verwijder de feature op basis van het unieke feature id
ilayer.deleteFeature(ifeature.id())
ilayer.commitChanges()
reply = MSG.showMsgBox('deletedobject')
UC.refresh_layers(self.iface)
self.close_repressief_object_show_base()
def run_delete(self):
layerName = PC.PAND["bouwlaaglayername"]
ilayer = UC.getlayer_byname(layerName)
objectId = self.pand_id.text()
request = QC.QgsFeatureRequest().setFilterExpression(
'"pand_id" = ' + "'{}'".format(objectId))
ifeature = next(ilayer.getFeatures(request))
ilayer.selectByIds([ifeature.id()])
reply = MSG.showMsgBox('deleteobject')
if not reply:
#als "nee" deselecteer alle geselecteerde features
ilayer.deselect(ifeature.id())
elif reply:
#als "ja" -> verwijder de feature op basis van het unieke feature id
ilayer.startEditing()
ilayer.deleteFeature(ifeature.id())
ilayer.commitChanges()
reply = MSG.showMsgBox('deletedobject')
UC.refresh_layers(self.iface)
#set actieve bouwlaag to 1 and fill combobox
self.bouwlagen_to_combobox(ifeature.id(), 1)
def bouwlagen_to_combobox(self, objectId, actieveBouwlaag):
"""fill combobox with existing floors"""
runLayer = PC.PAND["bouwlaaglayername"]
tempLayer = UC.getlayer_byname(runLayer)
objectId = self.pand_id.text()
foreignKey = CH.get_foreign_key_bl(runLayer)
tempLayer.setSubsetString('')
#request all existing floors of object feature
request = QC.QgsFeatureRequest().setFilterExpression(foreignKey +
" = '" +
str(objectId) +
"'")
tempFeatureIt = tempLayer.getFeatures(request)
#create unique list of existing floors and sort it from small to big
bouwlaagList = [it["bouwlaag"] for it in tempFeatureIt]
self.sortedList = UC.create_unique_sorted_list(bouwlaagList)
#block signal of combobox to add existing floors
self.comboBox.blockSignals(True)
self.comboBox.clear()
for bouwlaag in reversed(self.sortedList):
self.comboBox.addItem(str(bouwlaag))
#if there are existing floors "tekenen" can be enabled
if self.sortedList:
self.tekenen.setEnabled(True)
if actieveBouwlaag is None:
actieveBouwlaag = min(reversed(self.sortedList), key=abs)
else:
self.tekenen.setEnabled(False)
actieveBouwlaag = 1
self.comboBox.blockSignals(False)
#set substring of childlayers
subString = "bouwlaag = " + str(actieveBouwlaag)
UG.set_layer_substring(subString)
index = self.comboBox.findText(str(actieveBouwlaag),
PQtC.Qt.MatchFixedString)
if index >= 0:
self.comboBox.setCurrentIndex(index)
self.iface.actionPan().trigger()
def run_tekenen(self, _dummy, runLayer, featureId):
#welke pictogram is aangeklikt en wat is de bijbehorende tekenlaag
self.identifier = featureId
self.drawLayer = UC.getlayer_byname(runLayer)
self.drawLayerType = UC.check_layer_type(self.drawLayer)
self.parentLayerName = CH.get_parentlayer_ob(runLayer)
objectId = self.object_id.text()
possibleSnapFeatures = UC.get_possible_snapFeatures_object(
DH.ROSNAPLAYERS, objectId)
if self.drawLayerType == "Point":
pointTool = self.parent.pointTool
pointTool.snapPt = None
pointTool.snapping = False
pointTool.startRotate = False
pointTool.possibleSnapFeatures = possibleSnapFeatures
if self.identifier in DH.ROSNAPSYMBOLS:
pointTool.snapping = True
pointTool.layer = self.drawLayer
self.canvas.setMapTool(pointTool)
UG.set_lengte_oppervlakte_visibility(self, False, False, False,
False)
pointTool.onGeometryAdded = self.place_feature
else:
drawTool = self.parent.drawTool
if self.drawLayerType == "LineString":
drawTool.captureMode = 1
UG.set_lengte_oppervlakte_visibility(self, True, True, False,
True)
else:
drawTool.captureMode = 2
UG.set_lengte_oppervlakte_visibility(self, True, True, True,
True)
drawTool.layer = self.drawLayer
drawTool.possibleSnapFeatures = possibleSnapFeatures
drawTool.canvas = self.canvas
drawTool.onGeometryAdded = self.place_feature
self.canvas.setMapTool(drawTool)
drawTool.parent = self
