def _follow_verify_email_link(page, email):
message = str(email.message())
prefix = '<p>Please go to <a href="'
i = str.find(message, prefix) + len(prefix)
suffix = '" rel="nofollow">'
j = str.find(message, suffix, i)
page.browser.get(message[i:j])
def _follow_change_email_link(page, email):
message = str(email.message())
prefix = "please go to "
i = str.find(message, prefix) + len(prefix)
suffix = " to verify"
j = str.find(message, suffix, i)
page.browser.get(message[i:j])
def _follow_duplicate_account_email_link(page, email):
message = str(email.message())
prefix = 'please login: <a href="'
i = str.find(message, prefix) + len(prefix)
suffix = '" rel="nofollow">'
j = str.find(message, suffix, i)
page.browser.get(message[i:j])
def _str_switch(str, substr1, substr2):
"""Switch the location in a string of two substrings"""
i1 = str.find(substr1)
i2 = str.find(substr2)
if i1 < 0 or i2 < 0:
return str
if i1 < i2:
return str[:i1] + substr2 + str[i1 + len(substr1):i2] + substr1 + str[i2 + len(substr2):]
if i1 == i2:
return str
if i1 > i2:
return str[:i2] + substr1 + str[i2 + len(substr2):i1] + substr2 + str[i1 + len(substr1):]
def outFile(self):
self.receiver_layer_lineEdit.clear()
self.shapefileName = QFileDialog.getSaveFileName(None,'Open file', on_Settings.getOneSetting('directory_last') , "Shapefile (*.shp);;All files (*)")
if self.shapefileName is None or self.shapefileName == "":
return
if str.find(self.shapefileName[0],".shp") == -1 and str.find(self.shapefileName[0],".SHP") == -1:
self.receiver_layer_lineEdit.setText( self.shapefileName[0] + ".shp")
else:
self.receiver_layer_lineEdit.setText( self.shapefileName[0])
on_Settings.setOneSetting('directory_last',os.path.dirname(self.receiver_layer_lineEdit.text()))
def outFile(self):
self.receiver_layer_lineEdit.clear()
self.shapefileName = QFileDialog.getSaveFileName(None,'Open file', on_Settings.getOneSetting('directory_last') , "Shapefile (*.shp);;All files (*)")
if self.shapefileName is None or self.shapefileName == "":
return
if str.find(self.shapefileName[0],".shp") == -1 and str.find(self.shapefileName[0],".SHP") == -1:
self.receiver_layer_lineEdit.setText( self.shapefileName[0] + ".shp")
else:
self.receiver_layer_lineEdit.setText( self.shapefileName[0])
on_Settings.setOneSetting('directory_last',os.path.dirname(self.receiver_layer_lineEdit.text()))
def outFile_save_settings(self):
self.save_settings_lineEdit.clear()
save_settings_path, __ = QFileDialog.getSaveFileName(None,'Open file', on_Settings.getOneSetting('directory_last') , "Settings (*.xml);;All files (*)")
if save_settings_path is None or save_settings_path == "":
return
if str.find(save_settings_path,".xml") == -1 and str.find(save_settings_path,".XML") == -1:
self.save_settings_lineEdit.setText( save_settings_path + ".xml")
else:
self.save_settings_lineEdit.setText( save_settings_path )
on_Settings.setOneSetting('directory_last',os.path.dirname(self.save_settings_lineEdit.text()))
def xyt_name_factory(filepath, wlen, smr, frac, original):
# Returns the filename that _xyt output should have.
# Will have the general behavior: filename_xyt00.format
# filepath ~ dirname/name.fits
# filename ~ dirname/name
# fnmatch_string ~ name + xyt_suffix + ?? + xyt_format
# Remove RHT-specific endings
filename = filename_from_path(filepath)
dirname = os.path.dirname(os.path.abspath(filepath))
fnmatch_string = filename + xyt_suffix + '?' * DIGITS + xyt_format
xyt_files = fnmatch.filter(os.listdir(dirname), fnmatch_string)
xyt_array = [None] * (10**DIGITS)
# Try to find a parameter match among existing files
left = str.find(fnmatch_string, '?')
for x in xyt_files:
abs_x = os.path.join(dirname, x)
if getXYT(
abs_x,
match_only={
'WLEN': wlen,
'SMR': smr,
'FRAC': frac,
'ORIGINAL': original
}
): #TODO ______________________________________#print 'Found _xyt file matching your input parameters!'
return os.path.normpath(abs_x)
else:
xyt_array[int(x[left:(left + DIGITS)])] = x
# Try to find the lowest-numbered name that is unoccupied
for i, y in enumerate(xyt_array):
if y is None:
# Print 'Found _xyt available for these parameters!'
int_string = str.zfill(str(i), DIGITS)[:DIGITS]
xyt_filename = filename + xyt_suffix + int_string + xyt_format
return os.path.normpath(os.path.join(dirname, xyt_filename))
# Failure: No match and no available output slots
xyt_filename = str.replace(fnmatch_string, '?', '0')
print(
'In xyt_filename(): No existing ouput matches the input parameters and no namespace is available'
)
print('Overwrite ' + xyt_filename + '?..')
choice = input(' [y]/n/' + '0' * (DIGITS - 1) + 'x')
if len(choice) == 0 or choice == 'y':
return os.path.normpath(os.path.join(dirname, xyt_filename))
elif choice != 'n':
int_string = str.zfill(str(int(choice)), DIGITS)[:DIGITS]
xyt_filename = filename + xyt_suffix + int_string + xyt_format
return os.path.normpath(os.path.join(dirname, xyt_filename))
else:
raise RuntimeError(
'In xyt_filename(): No existing ouput matches the input parameters and no namespace is available'
)
def outFile_save_settings(self):
self.save_settings_lineEdit.clear()
save_settings_path, __ = QFileDialog.getSaveFileName(
None, 'Open file', on_Settings.getOneSetting('directory_last'),
"Settings (*.xml);;All files (*)")
if save_settings_path is None or save_settings_path == "":
return
if str.find(save_settings_path, ".xml") == -1 and str.find(
save_settings_path, ".XML") == -1:
self.save_settings_lineEdit.setText(save_settings_path + ".xml")
else:
self.save_settings_lineEdit.setText(save_settings_path)
on_Settings.setOneSetting(
'directory_last',
os.path.dirname(self.save_settings_lineEdit.text()))
def outFile_diff_rays(self):
self.diff_rays_layer_lineEdit.clear()
shapefileName, __ = QFileDialog.getSaveFileName(
None, 'Open file', on_Settings.getOneSetting('directory_last'),
"Shapefile (*.shp);;All files (*)")
if shapefileName is None or shapefileName == "":
return
if str.find(shapefileName, ".shp") == -1 and str.find(
shapefileName, ".SHP") == -1:
self.diff_rays_layer_lineEdit.setText(shapefileName + ".shp")
else:
self.diff_rays_layer_lineEdit.setText(shapefileName)
removeLayer(shapefileName)
on_Settings.setOneSetting(
'directory_last',
os.path.dirname(self.diff_rays_layer_lineEdit.text()))
def cleanup_fault_string(self, str):
"""
Make a remote exception nicely readable by humans so it's not evident that is a remote
fault. Users should not have to understand tracebacks.
"""
if str.find(">:") != -1:
(first, rest) = str.split(">:", 1)
if rest.startswith("\"") or rest.startswith("\'"):
rest = rest[1:]
if rest.endswith("\"") or rest.endswith("\'"):
rest = rest[:-1]
return rest
else:
return str
def cleanup_fault_string(self, str):
"""
Make a remote exception nicely readable by humans so it's not evident that is a remote
fault. Users should not have to understand tracebacks.
"""
if str.find(">:") != -1:
(first, rest) = str.split(">:", 1)
if rest.startswith("\"") or rest.startswith("\'"):
rest = rest[1:]
if rest.endswith("\"") or rest.endswith("\'"):
rest = rest[:-1]
return rest
else:
return str
def test_statsfile(self):
"""Test presence of statistics file
"""
import os, string
statsfile = '.cache_stat' # Basefilename for cached statistics.
CD = checkdir(cachedir)
DIRLIST = os.listdir(CD)
SF = []
for FN in DIRLIST:
if system_tools.major_version == 2:
res = string.find(FN, statsfile) >= 0
elif system_tools.major_version == 3:
res = str.find(FN, statsfile) >= 0
else:
raise Exception('Unknown version of Python: %s' %
system_tools.version)
if res >= 0:
try:
fid = open(CD + FN, 'r')
fid.close()
except:
raise Exception('Statistics files cannot be opened')
def not_string(str):
if str.find('not', 0, 3) == -1: return ('not ' + str)
else: return str
def importieren(self, pfad = None, liste = None, ergaenzungsname = None, anzeigename_ergaenzen = False, nach_unten = False, force_gruppenname = None, force_scale = None, DBschema_erweitern = True):
# Der Username der verwendet werden soll
if len(auth_user_global) > 0: # Ist belegt
auth_user = auth_user_global[0]
else:
auth_user = None
self.iface.layerTreeView().setCurrentLayer(None) # None entspricht einem Null Pointer -> Auswahl wird entfernt -> nicht ausgewählt
# Wird in der Regel verwendet wenn
# Gemeindespezifische Daten geladen werden
# zwecks Übersichtlichkeit
self.anzeigename_aendern = anzeigename_ergaenzen
self.gruppen_erg_name = ergaenzungsname # oberste Gruppe/Layer wird mit diesem Namen ergänzt!
if pfad == "":
return
# Das Qgis Projektfile ist ein XML und wird
# hier eingelesen
try:
#pfad = 'd:/delme.qgs'
#xml = file(pfad).read()
#QtWidgets.QMessageBox.about(None, "Fehler", str(locale.getpreferredencoding()))
project_file = open(pfad,'r',-1,'UTF8')
xml = project_file.read()
d = QtXml.QDomDocument()
d.setContent(xml)
except IOError:
QtWidgets.QMessageBox.about(None, "Fehler", "QGIS Projektdatei " + pfad + " nicht gefunden!")
return
# Die gewünschten Tagelemente aus dem XML herauslesen
self.maps = d.elementsByTagName("maplayer")
self.legends = d.elementsByTagName("legendlayer")
self.gruppen = d.elementsByTagName("legendgroup")
self.lyr = None
self.joinlayerid = None
#Zuerst den aktuellen Pfad auf dem
#Qgis steht auslesen (kann z.B. ein lokaler Pfad sein
#von dem ein Projekt geladen wird
CurrentPath = QgsProject.instance().fileName()
#Dann auf den jeweiligen Pfad setzen, von dem geladen wird. Sonst kann kein Projekt
#mit absoluten Pfaden abgespeichert werden (für Layer die mit dem
#VogisMenü geladen werden)
QgsProject.instance().setFileName(pfad)
#falls es länger dauert, ein kurzes Infofenster
#für den Anwender
progressi = QtWidgets.QProgressDialog('Lade Daten','Abbrechen',0,self.maps.length())
progressi.setFixedSize(350,90)
btnCancel = QtWidgets.QPushButton()
btnCancel.setText('Abbrechen')
btnCancel.setFixedSize(70,30)
progressi.setCancelButton(btnCancel)
progressi.setWindowModality(1)
#Schleife geht alle Layer die in der Legende aufscheinen durch. Hier
#ist nämlich die reihenfolge festgelegt, wie sie in Qgis dargestellt werden
#Diese Schleife brauch ich nur für die richtige Reihenfolge
#der importierten Layer in Qgis
zaehler = 0 # der Zähler für die Anzahl der geladenen Layer
j = 0
#for j in range(self.legends.length(),-1,-1):
for j in range(self.legends.length()):
# Schleife geht alle Layer die in der maplayer tags aufscheinen durch
# dort ist nämlich die wirkliche Information für die Darstellung im
# Qgis. Also wird zuerst der Layer per ID in der Obigen
# Schleife ausgewählt und dann in dieser Schleife im maplayertag
# identifiziert
# self.lyr=None
for i in range(self.maps.length()):
# prüfen ob der jeweilige layer nicht schon geladen ist. um das zu tun
# müssen wir im vogis projektimport die identifikation über
# die layerid tag machen. berücksichtigt werden muß auch
# ob die layerid durch den ergaenzungsnamen erweitert wurde!!
quelli = self.maps.item(i).namedItem("id").firstChild().toText().data()
laden = True
lyr_tmp = None
for lyr_tmp in QgsProject.instance().mapLayers(): #alle bereits geladenen Layer durchgehen -> Dictionary
#QtWidgets.QMessageBox.about(None, "Fehler", str(lyr_tmp))
if (ergaenzungsname == None) and (lyr_tmp == quelli): #Treffer: der Layer ist schon geladen
laden = False
if (ergaenzungsname != None) and (lyr_tmp == quelli + ergaenzungsname): #Treffer: der Layer ist schon geladen
laden = False
#Die Layerid ist in den legend tags und maplayer tags gleich
#so kann ein layer genau identifiziert werden. ist laden zudem True
#gehts also weiter
if (self.maps.item(i).namedItem("id").firstChild().toText().data() == self.legends.item(j).namedItem("filegroup").namedItem("legendlayerfile").attributes().namedItem("layerid").nodeValue()) and laden:
#ACHTUNG: Wieder aktivieren!!!!!!!!!!
# wenn nur ein Teil der Layer eines Projekts geladen werden sollen. Die Liste enthält die
# Namen dieser Layer
if liste != None:
brake_val = True
for nd in range(len(liste)):
if liste[nd] == self.legends.item(j).attributes().namedItem("name").nodeValue():
brake_val = False
break
if brake_val:
continue # Nächster Layer, ist nicht auf der Liste
# prüfen, ob der jeweilige Layer eine oder mehrere Jointabelle(n) verwendet
self.joinlayerid = ''
for sj in range(self.maps.item(i).namedItem("vectorjoins").childNodes().length()):
# leider muss ich dann nochmals alles durchgehen....
for lj in range(self.maps.length()):
if (self.maps.item(lj).namedItem("id").firstChild().toText().data() == self.maps.item(i).namedItem("vectorjoins").childNodes().item(sj).attributes().namedItem('joinLayerId').nodeValue()):
self.joinlayerid = self.maps.item(i).namedItem("vectorjoins").childNodes().item(sj).attributes().namedItem('joinLayerId').nodeValue()
#ACHTUNG: unbedingt den nodeValue der ID ändern wenn Gemeindeweise
#geladen wird (DKM) Da in den Qgis Projekten der Gemeinden die jeweilig ID des Layers
#der Einfachheit halber ident ist, würde so qgis den Layer nicht importieren!!!
#So wie der Layername in der Darstellung geändert wird wird auch die ID des Nodes VOR
#dem Laden geändert, damit Qgis das dann so übernimmt!!
noddi = self.maps.item(i).namedItem("id")
if ergaenzungsname != None:
noddi.firstChild().setNodeValue(noddi.firstChild().nodeValue() + ergaenzungsname)
#Abhängig von der vogisini wird das Encoding
#aus der Projektdatei genommen oder CPG datei oder
#wird auf System gesetzt
#ist self.vogisEncoding == project dann werden die Einstellungen des Projekt verwendet
base_name = os.path.dirname(pfad) + '/' + os.path.basename(self.maps.item(i).namedItem("datasource").firstChild().nodeValue())
# Achtung, zwischen absolutem und relativem Pfad unterscheiden
if len(os.path.dirname(self.maps.item(i).namedItem("datasource").firstChild().nodeValue())) < 2: # relativer Pfad im QGIS Projekt!
base_name = os.path.dirname(pfad) + '/' + os.path.basename(self.maps.item(i).namedItem("datasource").firstChild().nodeValue())
else: # absoluter Pfad im QGIS Projekt!
base_name = self.maps.item(i).namedItem("datasource").firstChild().nodeValue()
if vogisEncoding_global[0] == 'menue': # entweder CPG datei oder System setzen
try: # gibts ein cpg datei
datei = open(os.path.splitext(base_name)[0] + '.cpg','r')
codierung_string = datei.read()
datei.close()
self.maps.item(i).namedItem("provider").attributes().namedItem('encoding').setNodeValue(codierung_string)
except IOError: # Es wird der Wert System zugewiesen
self.maps.item(i).namedItem("provider").attributes().namedItem('encoding').setNodeValue('System')
# unbedingt ALLES DESELEKTIEREN, sonst Probleme mit der Reihenfolge
self.iface.layerTreeView().setCurrentLayer(None) # None entspricht einem Null Pointer -> Auswahl wird entfernt -> nicht ausgewählt
nv_ds = ''
nv_provider = ''
nv_encoding = ''
#############################################################################
# Das Umschalten der Vektordaten auf die Geodatenbank - unter Bedingungen
# es darf kein Layer aus einer Geodatenbank hier verwurschtelt werden
#############################################################################
if self.maps.item(i).attributes().namedItem('type').nodeValue() == 'vector' and vogisDb_global[0] != 'filesystem geodaten' and self.maps.item(i).namedItem("datasource").firstChild().nodeValue().find('host') < 0:
tablename = self.maps.item(i).namedItem("datasource").firstChild().nodeValue()
sql = ''
rc=[]
db_ogr = ''
# prüfen ob der layer eine shape datenquelle ist
# und ob ein subset definiert ist
if tablename.find('.shp') > 0 and (tablename.lower().find('subset') > 0 or tablename.lower().find('SUBSET') > 0 or tablename.lower().find('Subset') > 0):
rc = textfilter_subset(self.maps.item(i).namedItem("datasource").firstChild().nodeValue())
tablename = rc[0]
sql = rc[1]
db_ogr = rc[0]
else:
tablename = os.path.basename(self.maps.item(i).namedItem("datasource").firstChild().nodeValue()).split('.shp')[0]
db_ogr = tablename
if ergaenzungsname != None and DBschema_erweitern:
tablename = str.lower('\"' + ergaenzungsname + '\".\"' + tablename + '\"')
else:
tablename = str.lower('\"vorarlberg".\"' + tablename + '\"')
# Sonderzeichen berücksichtigen!
tablename = tablename.replace(('ä'),'ae')
tablename = tablename.replace(('Ä'),'Ae')
tablename = tablename.replace(('ö'),'oe')
tablename = tablename.replace(('Ö'),'Oe')
tablename = tablename.replace(('ü'),'ue')
tablename = tablename.replace(('Ü'),'Ue')
tablename = tablename.replace(('ß'),'ss')
tablename = tablename.replace('. ','_')
################################################
# Geometriespalte bestimmen -- geht nur mit OGR
param_list = str.split(vogisDb_global[0])
host = ''
dbname=''
port=''
for param in param_list:
if str.find(param,'dbname') >= 0:
dbname = str.replace(param,'dbname=','')
elif str.find(param,'host=') >= 0:
host = str.replace(param,'host=','')
elif str.find(param,'port=') >= 0:
port = str.replace(param,'port=','')
try:
if auth_user == None:
outputdb = ogr.Open('pg: host=' + host + ' dbname=' + dbname + ' schemas=vorarlberg' + ' port=' + port)
else:
outputdb = ogr.Open('pg: host=' + host + ' dbname=' + dbname + ' schemas=vorarlberg' + ' port=' + port + ' user='******'the_geom'
##################################################
# Geometriespalte Ende
if self.maps.item(i).namedItem("datasource").firstChild().nodeValue().find('ogc_fid') > 0:
# Achtung, das Attribut user darf nicht zwingend immer nur klein sein -> Siehe Usermapping in der Doku
if auth_user == None:
dbpath = str.lower(vogisDb_global[0] + ' sslmode=disable table=' + tablename + ' (' + geom_column + ') sql') + sql
else:
dbpath = str.lower(vogisDb_global[0]) + ' user='******' sslmode=disable table=' + tablename + ' (' + geom_column + ') sql') + sql
else:
# Achtung, das Attribut user darf nicht zwingend immer nur klein sein -> Siehe Usermapping in der Doku
if auth_user == None:
dbpath = str.lower(vogisDb_global[0] + ' sslmode=disable key=ogc_fid table=' + tablename + ' (' + geom_column + ') sql') + sql
else:
dbpath = str.lower(vogisDb_global[0]) + ' user='******' sslmode=disable key=ogc_fid table=' + tablename + ' (' + geom_column + ') sql') + sql
nv_ds = self.maps.item(i).namedItem("datasource").firstChild().nodeValue()
nv_provider = self.maps.item(i).namedItem("provider").firstChild().nodeValue()
nv_encoding = self.maps.item(i).namedItem("provider").attributes().namedItem('encoding').nodeValue()
self.maps.item(i).namedItem("datasource").firstChild().setNodeValue(dbpath)
self.maps.item(i).namedItem("provider").firstChild().setNodeValue('postgres')
self.maps.item(i).namedItem("provider").attributes().namedItem('encoding').setNodeValue('UTF-8')
if os.path.abspath(os.path.dirname(__file__)) != path_global[0]:
return
# Layer einlesen!
proj_read = QgsProject.instance().readLayer(self.maps.item(i))
# Der Fortschrittsbalken
progressi.setValue(j)
progressi.forceShow()
if progressi.wasCanceled():
break
#QtGui.QMessageBox.about(None, "Achtung", str(proj_read))
if not proj_read and vogisDb_global[0] == 'filesystem geodaten': # hier wird der Layer geladen und gemäß den Eintragungen
# der DomNode auch gerendert und dargestellt
QtWidgets.QMessageBox.about(None, "Achtung", "Layer " + self.legends.item(j).attributes().namedItem("name").nodeValue() + " nicht gefunden!")
continue
elif not proj_read and vogisDb_global[0] != 'filesystem geodaten': # Probieren auf Filesystem umzuschalten
QtWidgets.QMessageBox.about(None, "Achtung", "Layer - " + self.legends.item(j).attributes().namedItem("name").nodeValue() + " - in der Datenbank nicht gefunden - es wird aufs Filesystem umgeschaltet")
self.maps.item(i).namedItem("datasource").firstChild().setNodeValue(nv_ds)
self.maps.item(i).namedItem("provider").firstChild().setNodeValue(nv_provider)
self.maps.item(i).namedItem("provider").attributes().namedItem(nv_encoding)
if not QgsProject.instance().readLayer(self.maps.item(i)): #Trotzdem nicht gefunden, wir geben auf
QtWidgets.QMessageBox.about(None, "Achtung", "Layer " + self.legends.item(j).attributes().namedItem("name").nodeValue() + " nicht gefunden!")
continue
# den Anzeigenamen im Qgis ebenfalls ändern
# dazu zuerst den richtigen Layer anhand der Layerid auswählen
# leginterface = self.iface.legendInterface()
#for lyr_tmp in leginterface.layers():
for lyr_tmp in QgsProject.instance().mapLayers(): #alle bereits geladenen Layer durchgehen -> Dictionary
if lyr_tmp == noddi.firstChild().nodeValue():
self.lyr = QgsProject.instance().mapLayers()[lyr_tmp]
if force_scale != None:
self.lyr.setMaximumScale(25000)
self.lyr.setScaleBasedVisibility(True)
#Abhängig von der vogisini wird das KBS
#aus der Projektdatei genommen oder aus dem *.prj File
if vogisKBS_global[0] == 'menue':
#Koordinatenbezugssystem aus dem prj file holen, wenn vorhanden,
#und von dort zuweisen (die Projekteinstellung überschreiben)
try:
datei = open(os.path.splitext(self.lyr.source())[0] + '.prj','r')
bezugssystem_string = datei.read()
#falls kein sauberer EPSG String, machen wir eine Zuweisung für unser 31254
if (re.search('MGI\D+Austria\D+GK\D+West',bezugssystem_string, re.I)) != None: #Arcgis macht keinen sauberen EPSG String
bezugssystem_crs = QgsCoordinateReferenceSystem()
bezugssystem_crs.createFromSrid(31254)
else:
bezugssystem_crs = QgsCoordinateReferenceSystem(bezugssystem_string)
datei.close()
self.lyr.setCrs(bezugssystem_crs)
except IOError:
pass
#dann in der Applikation registrieren
#QgsMapLayerRegistry.instance().addMapLayer(self.lyr)
# gejointe Tabellen brauchen eine Spezialbehandlung: Joininfo wird
# ausgelesen, dann der join gelöscht und erst wenn alles geladen wurde
# wieder neu erstellt. Sonst kann es Probleme geben! unterstütz
# werden beleibig viele layer mit beliebig vielen joins
# es handelt sich um einen layer mir midestens einem eingetragenen join
single_lyr_join = lyr_join() # eigenes struktur objekt instanzieren
if not self.joinlayerid == '': # checken ob für den layer mindestens ein join eingetragen ist
single_lyr_join.joinlayer = self.lyr
single_lyr_join.joininfo = self.lyr.vectorJoins()
self.joinliste.append(single_lyr_join) # eine liste mit joinlayern und deren joininfo führen
for rem_join in self.lyr.vectorJoins(): # für den joinlayer die joins entfernen - es können merhere sein
kasperle = rem_join.joinLayerId
self.lyr.removeJoin(str(rem_join.joinLayerId))
#Und nun noch den Layernamen für die Darstellung
#im Qgis ergänzen. Siehe oben, bei gemeindeweisem Laden
if (ergaenzungsname != None) and (self.lyr != None) and self.anzeigename_aendern: # noch ein boolean wegen der wasserwirtschaft!!
if not (self.lyr.name().find(ergaenzungsname) > -1): # ACHTUNG: Sonst wird bei wiederholtem klicken der Name nochmal rangehängt
if self.lyr.name().find("(a)") > -1:
aktname = str.strip((self.lyr.name().rstrip("(a)"))) + "-" + ergaenzungsname + " (a)"
self.lyr.setName(aktname)
else:
aktname = str.strip(self.lyr.name())+ "-" + ergaenzungsname
self.lyr.setName(aktname)
# abschließend schauen ob der aktiviert ist
if (self.legends.item(j).attributes().namedItem("checked").nodeValue() == "Qt::Unchecked") and not (self.lyr is None):
#leginterface.setLayerVisible(self.lyr,False)
lyr_tree = QgsProject.instance().layerTreeRoot().findLayer(self.lyr)
lyr_tree.setItemVisibilityChecked(False)
index = QgsProject.instance().layerTreeRoot()
zwetsch =QgsProject.instance().layerTreeRoot().findLayer(self.lyr.id())
dummy = zwetsch.clone()
# Die Layer die später geladen werden müssen
# auch weiter unte in der Legende sein Reihenfolge)
# das wird mit der Variable zaehler gesteuert
# QGIS höher 2.6
index_ins = index_zuweisen(self.legends.item(j).attributes().namedItem("name").nodeValue(),self.legends.item(j).parentNode())
index.insertChildNode(-1,dummy)
zaehler = zaehler + 1
zwetsch.parent().removeChildNode(zwetsch)
# sonst gibts probleme in der Reihenfolge
# wenn gruppen und layer im top level vermischt
if not (self.legends.item(j).parentNode().nodeName() == "legendgroup") and (force_gruppenname is None):
zwetsch =QgsProject.instance().layerTreeRoot().findLayer(self.lyr.id())
dummy = zwetsch.clone()
index.insertChildNode(index_ins,dummy)
zwetsch.parent().removeChildNode(zwetsch)
#abschließend schauen ob der Layer aufgeklappt ist
#und das flag setzen
if (self.legends.item(j).attributes().namedItem("open").nodeValue() == "false") and not (self.lyr is None):
dummy.setExpanded(False)
elif (self.legends.item(j).attributes().namedItem("open").nodeValue() == "true") and not (self.lyr is None):
dummy.setExpanded(True)
# hier könnte abgebrochen werden, wenn die layer einfach
# nur reingeladen werden OHNE in Gruppenlyer abgelegt zu werden
# continue
#######################################################
# hier beginnt der Programmteil der die Gruppenlayer
# behandelt - entweder wenn im Projektfile definiert
# oder einfach wenn es im Menü
# erwünscht wird
#######################################################
if (self.legends.item(j).parentNode().nodeName() == "legendgroup") or not (force_gruppenname is None):
self.gruppe_vorhanden = False
#ACHTUNG: Layername und direkt übergeordneter Gruppenname
#müssen sich unterscheiden, sonst kommts zu einem Fehler. Sollts
#dennoch mal vorkommen, wird es hier abgefangen
if self.legends.item(j).parentNode().attributes().namedItem("name").nodeValue() == self.legends.item(j).attributes().namedItem("name").nodeValue():
aktname = self.lyr.name()
self.lyr.setName(aktname+"_")
#prüfen ob die Gruppe schon angelegt ist
grp_name = self.legends.item(j).parentNode().attributes().namedItem("name").nodeValue() #Name der Gruppe aus dem QGS Projektfile
grp_obj = QgsProject.instance().layerTreeRoot().findGroup(grp_name)
if (isinstance(grp_obj,QgsLayerTreeGroup)) and (not (grp_obj is None)):
self.gruppe_vorhanden = True
grp_name = force_gruppenname #Name ist übergeben worden
grp_obj = QgsProject.instance().layerTreeRoot().findGroup(grp_name)
if (isinstance(grp_obj,QgsLayerTreeGroup)) and (not (grp_obj is None)):
self.gruppe_vorhanden = True
#########################################################
# Gruppenlayer aus Projektdatei
#########################################################
if self.legends.item(j).parentNode().attributes().namedItem("name").nodeValue() != "" and self.legends.item(j).parentNode().nodeName() == "legendgroup":
QgsLayerTreeRegistryBridge(QgsProject.instance().layerTreeRoot(),QgsProject.instance())
kind = self.legends.item(j).parentNode()
gruppen_hierarchie = pos_gruppe()
gruppen_liste = []
while (kind.nodeName() == "legendgroup"):
gruppen_hierarchie.name = kind.attributes().namedItem("name").nodeValue() # der name der dem layer unmittelbar übergeordnete Gruppe: Ebene
gruppen_hierarchie.index = index_zuweisen(kind.attributes().namedItem("name").nodeValue(),kind.parentNode()) # Index der Darstellungsreihenfolge der Gruppe in ihrer Hierarchie
gruppen_hierarchie.ex = kind.attributes().namedItem("open").nodeValue()
gruppen_hierarchie.ch = kind.attributes().namedItem("checked").nodeValue()
gruppen_liste.append(copy.deepcopy(gruppen_hierarchie)) # ACHTUNG: Referenz!!
kind = kind.parentNode()
# grp enthält das qtreewidgetitem Objekt der Gruppe!, in die der geladene
# Layer verschoben werden soll!
grp = sublayer(QgsProject.instance().layerTreeRoot(),gruppen_liste, self.gruppen_erg_name, nach_unten, anzeigename_ergaenzen)[0] #sollten es mehrere sein, immer nur die erste nehmen - siehe Erklärung beim Sub selbst
zwtsch = QgsProject.instance().layerTreeRoot().findLayer(self.lyr.id())
dummy = zwtsch.clone()
if not (isinstance(grp,QgsLayerTreeGroup)) or grp is None:
QtWidgets.QMessageBox.about(None, "ACHTUNG","Anlegen der Gruppe gescheitert")
break
index_layer = index_zuweisen(self.legends.item(j).attributes().namedItem("name").nodeValue(),self.legends.item(j).parentNode())
# QtGui.QMessageBox.about(None, "LayeriD", str(dummy.layerId()))
grp.insertChildNode(index_layer,dummy)
zwtsch.parent().removeChildNode(zwtsch) # zwilling entfernen!
##########################################################
# hier Endet der Teil der Gruppenlayer aus Projektdatei!!
#########################################################
letzterplatz = False #Flagvariable ermittelt ob die Gruppe ganz nach unten gehört
#die gruppe in die der layer eingebettet ist kommt nicht aus
#einem projekt, sondern wird erzwungen. hier gibts allerdings
#nur eine ebene (was das ganze einfacher macht)
if (not force_gruppenname is None):
# gruppe anlegen
gruppen_hierarchie = pos_gruppe()
gruppen_hierarchie.name = force_gruppenname
# grp = sublayer(QgsProject.instance().layerTreeRoot(),leginterface,[gruppen_hierarchie])[0]
grp = sublayer(QgsProject.instance().layerTreeRoot(),[gruppen_hierarchie])[0]
zwtsch = QgsProject.instance().layerTreeRoot().findLayer(self.lyr.id()) #der geladene layer
dummy = zwtsch.clone()
# wiviele layer sind in der gruppe bereits vorhanden?
# baum = QgsLayerTreeModel(grp)
# anzahl_top_level_eintraege = baum.rowCount()
baum = grp.findLayers()
anzahl_top_level_eintraege = len(baum)
baum = None # Sonst Absturz bei grp.parent().removeChildNode(grp) da baum auf ein Nichts refenrenziert!
# den neuen ganz hinten einsetzen
grp.insertChildNode(anzahl_top_level_eintraege,dummy)
zwtsch.parent().removeChildNode(zwtsch)
grp.setExpanded(False)
if nach_unten: # ganz nach unten mit der gefüllten Gruppe, wenn das Flag gesetzt ist
if not self.gruppe_vorhanden:
dummy = grp.clone()
QgsProject.instance().layerTreeRoot().insertChildNode(-1,dummy)
grp.parent().removeChildNode(grp)
else: # die Layer werden NICHT in einen self.gruppenlayer geladen
# sollen aber nach unten verschoben werden
if nach_unten:
# wiviele layer sind in der gruppe bereits vorhanden?
baum = QgsLayerTreeModel(QgsProject.instance().layerTreeRoot())
anzahl_top_level_eintraege = baum.rowCount()
baum = None # Sonst Absturz bei grp.parent().removeChildNode(grp) da baum auf ein Nichts refenrenziert!
zwtsch = QgsProject.instance().layerTreeRoot().findLayer(self.lyr.id()) #der geladene layer
dummy = zwtsch.clone()
# den neuen ganz hinten einsetzen
QgsProject.instance().layerTreeRoot().insertChildNode(anzahl_top_level_eintraege,dummy)
zwtsch.parent().removeChildNode(zwtsch)
# abschließend schauen ob der Layer aufgeklappt ist
# und das flag setzen - beim Verschieben in die Gruppenlayer
# verändert sich das nämlich manchmal...
if (self.legends.item(j).attributes().namedItem("open").nodeValue() == "false") and not (self.lyr is None):
dummy.setExpanded(False)
elif (self.legends.item(j).attributes().namedItem("open").nodeValue() == "true") and not (self.lyr is None):
dummy.setExpanded(True)
# der nachfolgende Code erzwingt eine Aktualisierung
# der Legende und des MapWindow
# Ansonsten kanns im Mapwindow Darstellungsprobleme geben! Wieso??
if not self.lyr is None:
anzeigename = self.lyr.name()
self.lyr.setName(anzeigename+" ")
self.lyr.setName(anzeigename)
else:
QtWidgets.QMessageBox.about(None, "Achtung", "Layer " + self.legends.item(j).attributes().namedItem("name").nodeValue() + " nicht gefunden!")
# unbedingt ALLES DEselektieren, sonst Probleme mit Reihenfolge
self.iface.layerTreeView().setCurrentLayer(None) # None entspricht einem Null Pointer -> Auswahl wird entfernt -> nicht ausgewählt
#Unbedingt zurücksetzen sonst kanns beim wiederholten
#laden des gleichen Projektfiles einen Fehler geben:
#wenn nämlich die Schleife erneut beginnt, nicht lädt und self.lyr
#beim vorherigen laden steht!
self.lyr = None
# und weiter in der Schleife!
# UNBEDINGT am Schluss QGis wieder auf den usprünglichen
# Pfad zurücksetzen
QgsProject.instance().setFileName(CurrentPath)
#ACHTUNG: Aus irgendeinem Grund gibts Probleme mit den Gruppenlayer: Wenn innerhalb der so angelegten Gruppen
# ein Layer ausgewählt wird, gibts beim Laden danach einen Fehler. Es MUSS deshalb der oberste Eintrag
# der Legende vor allem Laden als Aktueller Layer gesetzt werden!!!
#Objekte besser löschen
self.legends = None
self.legendTree = None
self.maps = None
self.legends = None
self.gruppen = None
######################################################################
# Abschlussprüfung: sind alle da
#prüfen ob alle Layer der Liste geladen wurden
#das ist notwendig, da ja beim Projektladen alles passen kann aber
#ein Layer nicht vorhanden ist
######################################################################
fehler = 0
layerzaehler = 0
# Weg mit dem Fortschrittsbalken
# self.info.close()
if liste != None: #wenn nur ein Teil der Layer eines Projekts geladen wurde. Die Liste enthält die
#Namen dieser Layer
for nd in range(len(liste)):
for lyr_tmp_id in QgsProject.instance().mapLayers(): #alle bereits geladenen Layer durchgehen -> Dictionary
lyr_tmp = QgsProject.instance().mapLayer(lyr_tmp_id)
# Unbedingt die optionale Änderung des
# Anzeigenamens (z.B. DKM) mitberücksichtigen!)
if (ergaenzungsname != None) and self.anzeigename_aendern:
if liste[nd] + "-" + ergaenzungsname == lyr_tmp.name():
layerzaehler = layerzaehler +1
elif liste[nd].rstrip(" (a)") + "-" + ergaenzungsname + ' (a)' == lyr_tmp.name():
layerzaehler = layerzaehler +1
else:
if liste[nd] == lyr_tmp.name():
layerzaehler = layerzaehler +1
# ACHTUNG: Wurden nicht alle in der Liste (fürs importieren übergebne Layerliste mit Layernamen) angeführten Layer
# anhand des Layernamensim Projekt gefunden gibts
# hier noch eine Fehlermeldung
if not liste is None:
if len(liste) > layerzaehler: #Ints! Dann wurde was nicht geladen
QtWidgets.QMessageBox.about(None, "Achtung", "Nicht alle Layer aus " + pfad + " konnte(n) geladen werden!!")
# gejointe Relationen wiederherstellen
# aber erst ganz am Schluss!!
for singlejoin in self.joinliste:
for singlejoininfo in singlejoin.joininfo:
singlejoin.joinlayer.addJoin(singlejoininfo)
def _extract_uuid(text):
text = text[text.find("@key="):-1].replace("@key=", "")
if text.startswith("uuid:"):
text = text.replace("uuid:", "")
return text
def _extract_uuid(text):
text = text[text.find("@key="):-1].replace("@key=", "")
if text.startswith("uuid:"):
text = text.replace("uuid:", "")
return text
