def exportXMLToFile(self):
''' NO DOCUMENTATION '''
assert self.has_selected_item()
# Ask the users where they want to save the file
start_dir = ''
opus_home = os.environ.get('OPUS_HOME')
if opus_home:
start_dir_test = os.path.join(opus_home, 'project_configs')
if start_dir_test:
start_dir = start_dir_test
configDialog = QFileDialog()
filter_str = QString("*.xml")
fd = configDialog.getSaveFileName(self.manager.base_widget,
QString("Save As..."),
QString(start_dir), filter_str)
# Check for cancel
if len(fd) == 0:
return
fileNameInfo = QFileInfo(QString(fd))
fileName = fileNameInfo.fileName().trimmed()
fileNamePath = fileNameInfo.absolutePath().trimmed()
saveName = os.path.join(str(fileNamePath), str(fileName))
# proper root node for XmlConfiguration
root_node = Element('opus_project')
import copy
root_node.append(copy.deepcopy(self.selected_item().node))
# Write out the file
ElementTree(root_node).write(saveName)
def loadSymbologyFile(self):
""" Load a QML file to set the layer style """
settings = QSettings()
ultimaRutaQml = settings.value( 'Paths/qml', QVariant('.') ).toString()
symPath = QFileDialog.getOpenFileName(self, "Open a style file (.qml)",
ultimaRutaQml, "QGIS Layer Style File (*.qml)")
if isfile(symPath):
layer = self.currentItem().canvasLayer.layer()
res = layer.loadNamedStyle(symPath)
if res[1]:
self.refreshLayerSymbology(self.currentItem().canvasLayer.layer())
self.showMessage(self, 'Load style',
'New style has been applied to the layer ' +
self.currentItem().text(0) + '.', QMessageBox.Information )
# Immediately refresh layer
if hasattr(layer, "setCacheImage"):
layer.setCacheImage(None)
layer.triggerRepaint()
else:
self.showMessage( self, 'Load style',
'Error loading style file. Please check if match the layer ' +
self.currentItem().text(0) + '.', QMessageBox.Warning )
symInfo = QFileInfo(symPath)
settings.setValue('Paths/qml', QVariant( symInfo.absolutePath()))
def _export_composition_as_image(self, composition, file_path):
"""
Export the composition as a raster image.
"""
num_pages = composition.numPages()
for p in range(num_pages):
img = composition.printPageAsRaster(p)
if img.isNull():
msg = QApplication.translate("DocumentGenerator",
u"Memory allocation error. Please try "
u"a lower resolution or a smaller paper size.")
raise Exception(msg)
if p == 0:
state = img.save(file_path)
else:
fi = QFileInfo(file_path)
file_path = u"{0}/{1}_{2}.{3}".format(fi.absolutePath(),
fi.baseName(),
(p+1), fi.suffix())
state = img.save(file_path)
if not state:
msg = QApplication.translate("DocumentGenerator",
u"Error creating {0}.".format(file_path))
raise Exception(msg)
def on_upload_document(self):
'''
Slot raised when the user clicks
to upload a supporting document.
'''
document_str = QApplication.translate(
"SupportingDocuments",
"Specify the Document File Location"
)
documents = self.select_file_dialog(document_str)
cbo_index = self.doc_type_cbo.currentIndex()
doc_id = self.doc_type_cbo.itemData(cbo_index)
for doc in documents:
self.supporting_doc_manager.insertDocumentFromFile(
doc,
doc_id,
self.social_tenure,
self.current_party_count
)
# Set last path
if len(documents) > 0:
doc = documents[0]
fi = QFileInfo(doc)
dir_path = fi.absolutePath()
set_last_document_path(dir_path)
model_objs = self.supporting_doc_manager.model_objects()
self.onUploadDocument.emit(model_objs)
def on_mEndMarkerToolButton_clicked(self):
if self.timeStart != 0:
self.timeEnd = time.time()
print self.timeEnd
if self.timeEnd - self.timeStart <= 2:
self.timeStart = 0
return
s = QSettings()
openDir = QString()
if (not self.mEndMarkerLineEdit.text().isEmpty()):
fi = QFileInfo(self.mEndMarkerLineEdit.text())
openDir = fi.dir().absolutePath()
if (openDir.isEmpty()):
openDir = s.value("/UI/lastComposerMarkerDir",
QDir.homePath()).toString()
svgFileName = QFileDialog.getOpenFileName(
self, QString("End marker svg file"), openDir)
if (not svgFileName.isNull()):
fileInfo = QFileInfo(svgFileName)
s.setValue("/UI/lastComposerMarkerDir", fileInfo.absolutePath())
self.mArrow.beginCommand(QString("Arrow end marker"))
self.mEndMarkerLineEdit.setText(svgFileName)
self.mArrow.endCommand()
self.timeStart = time.time()
def on_upload_document(self):
'''
Slot raised when the user clicks
to upload a supporting document.
'''
document_str = QApplication.translate(
"SupportingDocuments", "Specify the Document File Location")
documents = self.select_file_dialog(document_str)
cbo_index = self.doc_type_cbo.currentIndex()
doc_id = self.doc_type_cbo.itemData(cbo_index)
for doc in documents:
self.supporting_doc_manager.insertDocumentFromFile(
doc, doc_id, self.social_tenure, self.current_party_count)
# Set last path
if len(documents) > 0:
doc = documents[0]
fi = QFileInfo(doc)
dir_path = fi.absolutePath()
set_last_document_path(dir_path)
model_objs = self.supporting_doc_manager.model_objects()
self.onUploadDocument.emit(model_objs)
def exportXMLToFile(self):
""" NO DOCUMENTATION """
assert self.has_selected_item()
# Ask the users where they want to save the file
start_dir = ""
opus_home = os.environ.get("OPUS_HOME")
if opus_home:
start_dir_test = os.path.join(opus_home, "project_configs")
if start_dir_test:
start_dir = start_dir_test
configDialog = QFileDialog()
filter_str = QString("*.xml")
fd = configDialog.getSaveFileName(
self.manager.base_widget, QString("Save As..."), QString(start_dir), filter_str
)
# Check for cancel
if len(fd) == 0:
return
fileNameInfo = QFileInfo(QString(fd))
fileName = fileNameInfo.fileName().trimmed()
fileNamePath = fileNameInfo.absolutePath().trimmed()
saveName = os.path.join(str(fileNamePath), str(fileName))
# proper root node for XmlConfiguration
root_node = Element("opus_project")
import copy
root_node.append(copy.deepcopy(self.selected_item().node))
# Write out the file
ElementTree(root_node).write(saveName)
def _export_composition_as_image(self, composition, file_path):
"""
Export the composition as a raster image.
"""
num_pages = composition.numPages()
for p in range(num_pages):
img = composition.printPageAsRaster(p)
if img.isNull():
msg = QApplication.translate(
"DocumentGenerator",
u"Memory allocation error. Please try "
u"a lower resolution or a smaller paper size.")
raise Exception(msg)
if p == 0:
state = img.save(file_path)
else:
fi = QFileInfo(file_path)
file_path = u"{0}/{1}_{2}.{3}".format(fi.absolutePath(),
fi.baseName(), (p + 1),
fi.suffix())
state = img.save(file_path)
if not state:
msg = QApplication.translate(
"DocumentGenerator",
u"Error creating {0}.".format(file_path))
raise Exception(msg)
def maskFromLayers(rasterLayer, domainLayer, outputLayer, thresholds):
"""Description: Processes a raster image into a vector polygon ocean/land mask.
Make sure to save the shapefile, as it will be deleted otherwise!
Input: QgsRasterLayer rasterLayer - layer that contains the raster image to process
QgsVectorLayer domainLayer - layer that contains a polygon specifying the bounds of the raster image to process
QgsVectorLayer outputLayer - layer to save vector layer in. Warning: not supported yet.
Output: QgsRasterLayer, QgsVectorLayer - objects referencing the new mask layers
"""
# Get basic file name information on geotiff, raster image, masked raster subset image, and masked vector subset shp file
fileSource = rasterLayer.source()
fileInfo = QFileInfo(fileSource)
filePath = fileInfo.absolutePath()
fileName = fileInfo.baseName()
fileQASource = filePath + os.path.sep + fileName[:fileName.rfind('_B')] + '_BQA.TIFF'
maskName = fileName + '_masked'
maskPath = filePath + os.path.sep + maskName + '.tif'
polyMaskName = fileName + '_masked_polygon'
polyMaskPath = filePath + os.path.sep + polyMaskName + '.shp'
maskIceName = fileName + '_masked_ice'
maskIcePath = filePath + os.path.sep + maskIceName + '.tif'
maskCloudName = fileName + '_masked_cloud'
maskCloudPath = filePath + os.path.sep + maskCloudName + '.tif'
print fileSource
# Load geotiff and get domain layer/bounding box of area to mask
geotiff = gdal.Open(fileSource)
feature = domainLayer.getFeatures().next()
domain = feature.geometry().boundingBox()
rasterCRS = rasterLayer.crs().authid()
domainCRS = domainLayer.crs().authid()
bounds = geotiffWorldToPixelCoords(geotiff, domain, rasterCRS, domainCRS)
print domain.toString(), bounds.toString()
# Generate QA masks
#masker = LandsatMasker(fileQASource, collection=1)
# algorithm has high confidence that this condition exists
# (67-100 percent confidence)
#conf = LandsatConfidence.high
# Get mask indicating cloud pixels with high confidence
#mask = masker.get_cloud_mask(conf)
# save the result
#masker.save_tif(mask, 'result.tif')
# Execute masking algorithms
filteredImage = filterImage(geotiff, bounds, thresholds[0], thresholds[1])
mask = processEdges(filteredImage)
# Save results to files and layers
arrayToRaster(mask, geotiff, bounds, maskPath)
#rasterLayer = iface.addRasterLayer(maskPath, maskName)
#vectorLayer = vectorizeRaster(maskPath, polyMaskName)
rasterLayer = QgsRasterLayer(maskPath, maskName)
vectorLayer = vectorizeRaster(maskPath, polyMaskName)
return rasterLayer, vectorLayer
def on_gen(self):
'''生成工程'''
if not self.currentConfig:
return
#获取工程名及有效路径
project_name = self.et_project_name.text()
project_location = self.et_project_location.text()
qdir = QDir(project_location)
if not qdir.exists():
if not qdir.mkpath(project_location):
QMessageBox.warning(self, '警告', '路径无效！')
return
project_location = qdir.absolutePath()
if not project_location.endsWith(
'/') and not project_location.endsWith('\\'):
project_location += os.sep
project_location.replace('\\', '/')
if project_name.isEmpty() or project_location.isEmpty():
QMessageBox.warning(self, '警告', '项目名称或路径不能为空！')
return
self.currentConfig.project_name = app.QString2str(project_name)
self.currentConfig.project_location = app.QString2str(project_location)
content = self.currentConfig.toJson()
fileInfo = QFileInfo(self.path)
if not self.path.isEmpty():
path = app.QString2str(self.path)
with open(path, 'w+') as f:
f.write(content)
item = self.lw.currentItem()
item.setData(QtCore.Qt.UserRole, content)
template_name = self.currentConfig.template_source
template_dir = app.g_pwd + os.sep + 'templates' + os.sep + template_name.encode(
'utf-8')
with open(template_dir + os.sep + 'config.json', 'r') as f:
self.currentConfig.config_content = f.read()
ret_json = app.render(self.currentConfig.config_content,
config=self.currentConfig)
self.currentConfig.config = json.loads(ret_json)
for file in self.currentConfig.config['files']:
sourcepath = template_dir + os.sep + file['source'].encode('utf-8')
targetdir = self.currentConfig.project_location + self.currentConfig.project_name
targetpath = targetdir + os.sep + file['target']
fi = QFileInfo(targetpath)
qdir = fi.absoluteDir()
if not qdir.exists():
qdir.mkpath(fi.absolutePath())
with open(sourcepath, 'r') as f:
content = f.read()
content = app.render(content, config=self.currentConfig) #渲染文件
with open(targetpath, 'w+') as f:
f.write(content.encode('utf-8'))
QMessageBox.information(self, '提示', '生成成功！')
def calculate_PCD(red,nir,pcdPath):
# Obtain file information and create the layers
redInfo=QFileInfo(red)
nirInfo=QFileInfo(nir)
redBaseName=redInfo.baseName()
nirBaseName=nirInfo.baseName()
folderPath = redInfo.absolutePath()
redReflectancePath = folderPath + "/red_reflectance.tif"
nirReflectancePath = folderPath + "/nir_reflectance.tif"
redLayer = QgsRasterLayer(red,redBaseName)
if not redLayer.isValid():
print "Error importing red band to calculate reflectances"
nirLayer = QgsRasterLayer(nir,nirBaseName)
if not nirLayer.isValid():
print "Error importing NIR band to calculate reflectances"
# The images are transformed into reflectances by dividing by 32768
entries=[]
redReflectance = QgsRasterCalculatorEntry()
redReflectance.ref = "red_band@1"
redReflectance.raster=redLayer
redReflectance.bandNumber = 1
entries.append(redReflectance)
# Converts the DN raster into a reflectance raster
calc=QgsRasterCalculator('float(' + redReflectance.ref + ')/32768', redReflectancePath,"GTiff",redLayer.extent(),redLayer.width(),redLayer.height(), entries)
calc.processCalculation()
nirReflectance = QgsRasterCalculatorEntry()
nirReflectance.ref = "nir_band@1"
nirReflectance.raster=nirLayer
nirReflectance.bandNumber = 1
entries.append(nirReflectance)
# Converts the DN raster into a reflectance raster
calc=QgsRasterCalculator('float(' + nirReflectance.ref + ')/32768', nirReflectancePath,"GTiff",nirLayer.extent(),nirLayer.width(),nirLayer.height(), entries)
calc.processCalculation()
# Calculate the PCD index
calc=QgsRasterCalculator("float(" + nirReflectance.ref + ")/float(" + redReflectance.ref + ")", pcdPath,"GTiff",nirLayer.extent(),nirLayer.width(),nirLayer.height(), entries)
calc.processCalculation()
print "PCD calculated"
def load(self):
settings = QSettings()
workpath = settings.value("workPath").toString() + "/"
datapath = settings.value("dataPath").toString() + "/"
if (platform.system() != "Linux"):
workpath = workpath.replace("/","\\")
datapath = datapath.replace("/","\\")
filename = QtGui.QFileDialog.getOpenFileName(self, "Open MUSIC Output File", datapath,self.tr("Text Files (*.txt)"))
if(filename != ""):
finfo = QFileInfo(filename)
self.ui.le_r.setText(QFileInfo(filename).fileName())
settings.setValue("dataPath",finfo.absolutePath())
if(os.path.exists(workpath + finfo.fileName())):
selectedpath = str(finfo.absolutePath() + "/")
if(platform.system() != "Linux"):
selectedpath = selectedpath.replace("/","\\")
if(selectedpath != str(workpath)):
os.remove(str(workpath) + str(finfo.fileName()))
copyfile(filename, str(workpath) + str(finfo.fileName()))
else:
copyfile(filename,str(workpath) + str(finfo.fileName()))
self.loadTable(str(workpath) + str(finfo.fileName()))
def newFile(self, bookPath):
if not bookPath.isNull(): # this was successful File>Open
finf = QFileInfo(bookPath)
self.pngPath = finf.absolutePath().append(u"/pngs/")
finf = QFileInfo(self.pngPath)
if finf.exists() and finf.isDir(): # looking good
self.ready = True
self.newPosition()
else:
# We could inform the user we couldn't find a pngs folder,
# but you know -- the user is probably already aware of that.
self.clear() # just put up the gray default image
else: # It was a File>New
self.clear()
def render(self, fileName):
if self.m_mainFrame.contentsSize() == '':
return False
fileInfo = QFileInfo(fileName)
path = QDir()
path.mkpath(fileInfo.absolutePath())
if fileName.lower().endswith('.pdf'):
return self.renderPdf(fileName)
image = self.renderImage()
return image.save(fileName)
def __workingDirectory(path_):
"""
Private function to determine working directory for the file dialog.
@param path_ path of the intended working directory (string or QString)
@return calculated working directory (QString)
"""
path = QString(path_)
if not path.isEmpty():
info = QFileInfo(path)
if info.exists() and info.isDir():
return info.absoluteFilePath()
return info.absolutePath()
return QDir.currentPath()
def render(self, fileName):
if self.m_mainFrame.contentsSize() == '':
return False
fileInfo = QFileInfo(fileName)
path = QDir()
path.mkpath(fileInfo.absolutePath())
if fileName.lower().endswith('.pdf'):
return self.renderPdf(fileName)
image = self.renderImage()
return image.save(fileName)
def load(self):
settings = QSettings()
workpath = settings.value("workPath").toString() + "/"
datapath = settings.value("dataPath").toString() + "/"
if (platform.system() != "Linux"):
workpath = workpath.replace("/", "\\")
datapath = datapath.replace("/", "\\")
filename = QtGui.QFileDialog.getOpenFileName(
self, "Open MUSIC Output File", datapath,
self.tr("Text Files (*.txt)"))
if (filename != ""):
finfo = QFileInfo(filename)
self.ui.le_r.setText(QFileInfo(filename).fileName())
settings.setValue("dataPath", finfo.absolutePath())
if (os.path.exists(workpath + finfo.fileName())):
selectedpath = str(finfo.absolutePath() + "/")
if (platform.system() != "Linux"):
selectedpath = selectedpath.replace("/", "\\")
if (selectedpath != str(workpath)):
os.remove(str(workpath) + str(finfo.fileName()))
copyfile(filename, str(workpath) + str(finfo.fileName()))
else:
copyfile(filename, str(workpath) + str(finfo.fileName()))
self.loadTable(str(workpath) + str(finfo.fileName()))
def _run_loading_vfk_layer(self, filePath):
"""Calls methods for loading a VFK layer.
Disables loading widgets until the loading is finished.
Args:
filePath (str): A full path to the file.
"""
try:
self.set_value_loadVfkProgressBar.emit(0)
fileInfo = QFileInfo(filePath)
dbPath = QDir(fileInfo.absolutePath())\
.filePath(fileInfo.completeBaseName() + '.db')
layerCode = self.dW.parLayerCode
vfkDriverName = 'VFK'
layerName = fileInfo.completeBaseName() + '|' + layerCode
self._create_db_file(filePath, dbPath, layerCode, vfkDriverName)
self._open_database(dbPath)
# SpatiaLite fix - start
if not self.dW.fixedSqliteDriver:
dbPath = self._create_spatialite_db_file(dbPath)
# SpatiaLite fix - end
self._load_vfk_layer(dbPath, layerName, layerCode, vfkDriverName)
self.loadVfkProgressBar.setMaximum(1)
self.set_value_loadVfkProgressBar.emit(1)
self.set_text_statusbar.emit(u'Data byla úspešně načtena.', 0,
False)
except self.dW.puError:
QgsApplication.processEvents()
except:
QgsApplication.processEvents()
self.dW.display_error_messages(
self, u'Error loading VFK file "{}".'.format(filePath),
u'Chyba při načítání VFK souboru.',
u'Chyba při načítání VFK souboru "{}".'.format(filePath))
finally:
QgsApplication.processEvents()
self._enable_load_widgets(True)
def loadShapefile(self, path, preserveSqlFile=False):
fileInfo = QFileInfo(path)
if not self.existsTable(fileInfo.baseName()):
sqlFilePath = str(fileInfo.absolutePath()) + "/" + str(
fileInfo.baseName()) + ".sql"
system("shp2pgsql -c " + path + " > " + sqlFilePath)
cursor = self._con.cursor()
cursor.execute(open(sqlFilePath, 'r').read())
if not preserveSqlFile:
system("rm -f " + sqlFilePath)
GPrint("Shapefile " + fileInfo.baseName() +
".shp successfully loaded in database " + str(self))
else:
GPrint(fileInfo.baseName() + " exists in " + str(self), "EE")
def _on_add_supporting_document(self):
#Slot raised when the user select to add a supporting document
if self.count == 0:
return
select = self.tr('Select')
supporting_docs_str = 'Supporting Documents'
title = u'{0} {1} {2}'.format(
select,
self.current_document_type(),
supporting_docs_str
)
filter_str = u'{0} (*.jpg *.jpeg *.png *.bmp *.tiff *.svg)'.format(
supporting_docs_str
)
#Get last path for supporting documents
last_path = last_document_path()
if last_path is None:
last_path = '/home'
else:
dir = QDir(last_path)
if not dir.exists():
last_path = '/home'
source_docs = QFileDialog.getOpenFileNames(
self, title, last_path, filter_str
)
doc_type_id = self._cbo_doc_type.itemData(self._cbo_doc_type.currentIndex())
parent_entity = self._entity_supporting_doc.parent_entity
for doc in source_docs:
self.source_document_manager.insertDocumentFromFile(
doc,
doc_type_id,
parent_entity
)
#Set last path
if len(source_docs) > 0:
doc = source_docs[0]
fi = QFileInfo(doc)
dir_path = fi.absolutePath()
set_last_document_path(dir_path)
def action_writeGCode_triggered(self):
if not len(self.trafoPoints) in {3, 4}:
QMessageBox.warning(self, "not enough points", "Please select at least 3 transformation points.")
return
T=bilinearTrafo(self.trafoPoints, self.trafoMachinePoints)
paths={}
for dia in self.fitHoles:
toolNr=self.drills[dia]
paths[toolNr]=findPath(T.transform(self.fitHoles[dia]))
fi=QFileInfo(self.currentFile)
filename=fi.absolutePath() + "/" + fi.completeBaseName() + ".ngc"
writeGCode(paths, filename, self.feedrate, self.drillDepth, self.drillSpacing)
QMessageBox.information(self, "G-Code", "Finished!")
def on_gen(self):
'''生成工程'''
if not self.currentConfig:
return
#获取工程名及有效路径
project_name = self.et_project_name.text()
project_location = self.et_project_location.text()
qdir = QDir(project_location)
if not qdir.exists():
if not qdir.mkpath(project_location):
QMessageBox.warning(self, '警告', '路径无效！')
return
project_location = qdir.absolutePath()
if not project_location.endsWith('/') and not project_location.endsWith('\\'):
project_location += os.sep
if project_name.isEmpty() or project_location.isEmpty():
QMessageBox.warning(self, '警告', '项目名称或路径不能为空！')
return
self.currentConfig.project_name = app.QString2str(project_name)
self.currentConfig.project_location = app.QString2str(project_location)
template_name = self.currentConfig.template_source
template_dir = app.g_pwd + os.sep + 'templates' + os.sep + template_name
with open(template_dir + os.sep + 'config.json', 'r') as f:
self.currentConfig.config_content = f.read()
ret_json = app.render(self.currentConfig.config_content, config=self.currentConfig)
self.currentConfig.config = json.loads(ret_json)
for file in self.currentConfig.config['files']:
sourcepath = template_dir + os.sep + file['source']
targetdir = self.currentConfig.project_location + self.currentConfig.project_name
targetpath = targetdir + os.sep + file['target']
fi = QFileInfo(targetpath)
qdir = fi.absoluteDir()
if not qdir.exists():
qdir.mkpath(fi.absolutePath())
with open(sourcepath, 'r') as f:
content = f.read()
content = app.render(content, config=self.currentConfig) #渲染文件
with open(targetpath, 'w+') as f:
f.write(content.encode('utf-8'))
QMessageBox.information(self,'提示','生成成功！')
def _create_spatialite_db_file(self, dbPath):
"""Creates a SpatiaLite database file.
Args:
dbPath (str): A full path to the database.
Returns:
dbPath (str): A full path to the SpatiaLite database.
"""
dbInfo = QFileInfo(dbPath)
sdbPath = QDir(dbInfo.absolutePath())\
.filePath(dbInfo.completeBaseName() + '.sdb')
sdbInfo = QFileInfo(sdbPath)
if not sdbInfo.isFile():
self.set_text_statusbar.emit(
u'Importuji data do SpatiaLite databáze...', 0, False)
QgsApplication.processEvents()
sqliteDriver = ogr.GetDriverByName('SQLite')
spatialiteDataSource = sqliteDriver.CreateDataSource(
sdbPath, ['SPATIALITE=YES'])
sqliteDataSource = ogr.Open(dbPath)
for layerCode in (
self.dW.parLayerCode, ) + self.dW.vertexLayerCodes:
originalLayer = sqliteDataSource.GetLayerByName(layerCode)
copiedLayer = spatialiteDataSource.CopyLayer(
originalLayer, layerCode, ['LAUNDER=NO'])
sqliteDataSource.Destroy()
spatialiteDataSource.Destroy()
QgsApplication.processEvents()
return sdbPath
def exportXMLToFile(self, inherited=True):
''' NO DOCUMENTATION '''
# Ask the users where they want to save the file
start_dir = paths.get_project_configs_path()
configDialog = QFileDialog()
filter_str = QString("*.xml")
fd = configDialog.getSaveFileName(self.manager.base_widget,
QString("Save As..."),
QString(start_dir), filter_str)
# Check for cancel
if len(fd) == 0:
return
fileNameInfo = QFileInfo(QString(fd))
fileName = fileNameInfo.fileName().trimmed()
fileNamePath = fileNameInfo.absolutePath().trimmed()
saveName = os.path.join(str(fileNamePath), str(fileName))
root_node = self.get_clean_copy_of_selected_node(inherited)
ElementTree(root_node).write(saveName)
def open_file_dialog(self, title, filters, existence):
"""Opens a file dialog.
Args:
title (str): A title of the file dialog.
filters (str): Available filter(s) of the file dialog.
existence (bool):
True when the file has to exist
(QFileDialog.getOpenFileNameAndFilter).
False when the file does not have to exist
(QFileDialog.getSaveFileNameAndFilter).
Returns:
str: A path to the selected file.
"""
sender = self.sender().objectName()
lastUsedFilePath = self._get_settings(sender + '-' + 'lastUsedFilePath')
lastUsedFilter = self._get_settings(sender + '-' + 'lastUsedFilter')
if existence:
filePath, usedFilter = QFileDialog.getOpenFileNameAndFilter(
self, title, lastUsedFilePath, filters, lastUsedFilter)
else:
filePath, usedFilter = QFileDialog.getSaveFileNameAndFilter(
self, title, lastUsedFilePath, filters, lastUsedFilter)
fileInfo = QFileInfo(filePath)
if platform.system() == u'Linux' and fileInfo.suffix() != u'shp':
filePath = QDir(fileInfo.absolutePath())\
.filePath(fileInfo.completeBaseName() + u'.shp')
if filePath and usedFilter:
self._set_settings(sender + '-' + 'lastUsedFilePath', filePath)
self._set_settings(sender + '-' + 'lastUsedFilter', usedFilter)
return filePath
def render(self, fileName):
fileInfo = QFileInfo(fileName)
path = QDir()
path.mkpath(fileInfo.absolutePath())
if fileName.lower().endswith('.pdf'):
return self.renderPdf(fileName)
viewportSize = QSize(self.m_page.viewportSize())
pageSize = QSize(self.m_page.mainFrame().contentsSize())
bufferSize = QSize()
if not self.m_clipRect.isEmpty():
bufferSize = self.m_clipRect.size()
else:
bufferSize = self.m_page.mainFrame().contentsSize()
if pageSize == '':
return False
image = QImage(bufferSize, QImage.Format_ARGB32)
image.fill(qRgba(255, 255, 255, 0))
p = QPainter(image)
p.setRenderHint(QPainter.Antialiasing, True)
p.setRenderHint(QPainter.TextAntialiasing, True)
p.setRenderHint(QPainter.SmoothPixmapTransform, True)
self.m_page.setViewportSize(pageSize)
if not self.m_clipRect.isEmpty():
p.translate(-self.m_clipRect.left(), -self.m_clipRect.top())
self.m_page.mainFrame().render(p, QRegion(self.m_clipRect))
else:
self.m_page.mainFrame().render(p)
p.end()
self.m_page.setViewportSize(viewportSize)
return image.save(fileName)
def render(self, fileName):
fileInfo = QFileInfo(fileName)
path = QDir()
path.mkpath(fileInfo.absolutePath())
if fileName.lower().endswith('.pdf'):
return self.renderPdf(fileName)
viewportSize = QSize(self.m_page.viewportSize())
pageSize = QSize(self.m_page.mainFrame().contentsSize())
bufferSize = QSize()
if not self.m_clipRect.isEmpty():
bufferSize = self.m_clipRect.size()
else:
bufferSize = self.m_page.mainFrame().contentsSize()
if pageSize == '':
return False
image = QImage(bufferSize, QImage.Format_ARGB32)
image.fill(qRgba(255, 255, 255, 0))
p = QPainter(image)
p.setRenderHint(QPainter.Antialiasing, True)
p.setRenderHint(QPainter.TextAntialiasing, True)
p.setRenderHint(QPainter.SmoothPixmapTransform, True)
self.m_page.setViewportSize(pageSize)
if not self.m_clipRect.isEmpty():
p.translate(-self.m_clipRect.left(), -self.m_clipRect.top())
self.m_page.mainFrame().render(p, QRegion(self.m_clipRect))
else:
self.m_page.mainFrame().render(p)
p.end()
self.m_page.setViewportSize(viewportSize)
return image.save(fileName)
def _unzip_bpej_zip(self, bpejZipFilePath, bpejCsvFileName):
"""Unzips BPEJ ZIP file into the same directory.
Args:
bpejZipFilePath (str): A full path to the BPEJ ZIP file.
bpejCsvFileName (str): A name of the BPEJ CSV file.
"""
fileInfo = QFileInfo(bpejZipFilePath)
bpejDir = fileInfo.absolutePath()
bpejZip = zipfile.ZipFile(bpejZipFilePath, 'r')
bpejZipContent = bpejZip.namelist()
if len(bpejZipContent) != 1:
bpejZip.close()
raise self.dW.puError(
self.dW, self.pW,
u'The structure of the BPEJ ZIP file has changed. '
u'The BPEJ ZIP file contains more than one file.',
u'Struktura stahovaného BPEJ ZIP souboru se změnila.')
bpejZipFirstMember = bpejZipContent[0]
bpejZip.extract(bpejZipFirstMember, bpejDir)
bpejZip.close()
if bpejZipFirstMember != bpejCsvFileName:
bpejDir = QDir(bpejDir)
bpejZipFirstMemberFilePath = bpejDir.filePath(bpejZipFirstMember)
bpejCsvFilePath = bpejDir.filePath(bpejCsvFileName)
os.rename(bpejZipFirstMemberFilePath, bpejCsvFilePath)
def loadSymbologyFile( self ):
""" Load a QML file to set the layer style """
settings = QSettings()
ultimaRutaQml = settings.value( 'Paths/qml', QVariant('.') ).toString()
symPath = QFileDialog.getOpenFileName(self, "Open a style file (.qml)",
ultimaRutaQml, "QGIS Layer Style File (*.qml)")
if isfile( symPath ):
res = self.currentItem().canvasLayer.layer().loadNamedStyle( symPath )
if res[ 1 ]:
self.refreshLayerSymbology( self.currentItem().canvasLayer.layer() )
self.showMessage( self, 'Load style',
'The style file has been succesfully applied to the layer ' +
self.currentItem().text( 0 ) + '.', QMessageBox.Information )
else:
self.showMessage( self, 'Load style',
'It was not possible to load the style file. Make sure the file ' \
'matches the structure of the layer ' + self.currentItem().text( 0 ) + '.',
QMessageBox.Warning )
symInfo = QFileInfo( symPath )
settings.setValue( 'Paths/qml', QVariant( symInfo.absolutePath() ) )
def saveSymbologyFile(self):
""" Save a QML file to set the layer style """
settings = QSettings()
ultimaRutaQml = settings.value( 'Paths/qml', QVariant('.') ).toString()
symPath = QFileDialog.getSaveFileName( self, "Save layer properties as a style file",
ultimaRutaQml, "QGIS Layer Style File (*.qml)" )
if symPath:
symInfo = QFileInfo( symPath )
settings.setValue( 'Paths/qml', QVariant( symInfo.absolutePath() ) )
if not symPath.toUpper().endsWith( '.QML' ):
symPath += '.qml'
res = self.currentItem().canvasLayer.layer().saveNamedStyle( symPath )
if res[ 1 ]:
self.refreshLayerSymbology( self.currentItem().canvasLayer.layer() )
self.showMessage( self, 'Save style file',
'The style file has been saved succesfully.',
QMessageBox.Information )
else:
self.showMessage( self, 'Save style file',
res[ 0 ], QMessageBox.Warning )
def saveSymbologyFile( self ):
""" Save a QML file to set the layer style """
settings = QSettings()
ultimaRutaQml = settings.value( 'Paths/qml', QVariant('.') ).toString()
symPath = QFileDialog.getSaveFileName( self, "Save layer properties as a style file",
ultimaRutaQml, "QGIS Layer Style File (*.qml)" )
if symPath:
symInfo = QFileInfo( symPath )
settings.setValue( 'Paths/qml', QVariant( symInfo.absolutePath() ) )
if not symPath.toUpper().endsWith( '.QML' ):
symPath += '.qml'
res = self.currentItem().canvasLayer.layer().saveNamedStyle( symPath )
if res[ 1 ]:
self.refreshLayerSymbology( self.currentItem().canvasLayer.layer() )
self.showMessage( self, 'Save style file',
'The style file has been saved succesfully.',
QMessageBox.Information )
else:
self.showMessage( self, 'Save style file',
res[ 0 ], QMessageBox.Warning )
class GeoPackage(DataStore):
"""
GeoPackage DataStore
.. versionadded:: 4.0
"""
def __init__(self, uri):
"""
Constructor for the GeoPackage DataStore.
:param uri: A filepath which doesn't exist
:type uri: QFileInfo, str
.. versionadded:: 4.0
"""
super(GeoPackage, self).__init__(uri)
self.vector_driver = ogr.GetDriverByName('GPKG')
self.raster_driver = gdal.GetDriverByName('GPKG')
if isinstance(uri, QFileInfo):
self._uri = uri
elif isinstance(uri, basestring):
self._uri = QFileInfo(uri)
else:
raise ErrorDataStore('Unknown type')
if self.uri.exists():
raster_datasource = gdal.Open(self.uri.absoluteFilePath())
if raster_datasource is None:
# Let's try if it's a vector one.
vector_datasource = self.vector_driver.Open(
self.uri.absoluteFilePath())
if vector_datasource is None:
msg = 'The file is not a geopackage or it doesn\'t ' \
'contain any layers.'
raise ErrorDataStore(msg)
else:
path = self.uri.absoluteFilePath()
datasource = self.vector_driver.CreateDataSource(path)
del datasource
def is_writable(self):
"""Check if the folder is writable.
:return: If it's writable or not.
:rtype: bool
.. versionadded:: 4.0
"""
# Fixme, need to check DB permissions ?
return self._uri.absolutePath().isWritable()
def supports_rasters(self):
"""Check if we can support raster in the geopackage.
:return: If it's writable or not.
:rtype: bool
.. versionadded:: 4.0
"""
if int(gdal.VersionInfo('VERSION_NUM')) < 2000000:
return False
else:
return True
def _vector_layers(self):
"""Return a list of vector layers available.
:return: List of vector layers available in the geopackage.
:rtype: list
.. versionadded:: 4.0
"""
layers = []
vector_datasource = self.vector_driver.Open(
self.uri.absoluteFilePath())
if vector_datasource:
for i in range(vector_datasource.GetLayerCount()):
layers.append(vector_datasource.GetLayer(i).GetName())
return layers
def _raster_layers(self):
"""Return a list of raster layers available.
:return: List of raster layers available in the geopackage.
:rtype: list
.. versionadded:: 4.0
"""
layers = []
raster_datasource = gdal.Open(self.uri.absoluteFilePath())
if raster_datasource:
subdatasets = raster_datasource.GetSubDatasets()
if len(subdatasets) == 0:
metadata = raster_datasource.GetMetadata()
layers.append(metadata['IDENTIFIER'])
else:
for subdataset in subdatasets:
layers.append(subdataset[0].split(':')[2])
return layers
def layers(self):
"""Return a list of layers available.
:return: List of layers available in the datastore.
:rtype: list
.. versionadded:: 4.0
"""
return self._vector_layers() + self._raster_layers()
def layer_uri(self, layer_name):
"""Get layer URI.
For a vector layer :
/path/to/the/geopackage.gpkg|layername=my_vector_layer
For a raster :
GPKG:/path/to/the/geopackage.gpkg:my_raster_layer
:param layer_name: The name of the layer to fetch.
:type layer_name: str
:return: The URI to the layer.
:rtype: str
.. versionadded:: 4.0
"""
for layer in self._vector_layers():
if layer == layer_name:
uri = u'{}|layername={}'.format(
self.uri.absoluteFilePath(), layer_name)
return uri
else:
for layer in self._raster_layers():
if layer == layer_name:
uri = u'GPKG:{}:{}'.format(
self.uri.absoluteFilePath(), layer_name)
return uri
else:
return None
def _add_vector_layer(self, vector_layer, layer_name):
"""Add a vector layer to the geopackage.
:param vector_layer: The layer to add.
:type vector_layer: QgsVectorLayer
:param layer_name: The name of the layer in the datastore.
:type layer_name: str
:returns: A two-tuple. The first element will be True if we could add
the layer to the datastore. The second element will be the layer
name which has been used or the error message.
:rtype: (bool, str)
.. versionadded:: 4.0
"""
# Fixme
# if not self.is_writable():
# return False, 'The destination is not writable.'
geometry = QGIS_OGR_GEOMETRY_MAP[vector_layer.wkbType()]
spatial_reference = osr.SpatialReference()
qgis_spatial_reference = vector_layer.crs().authid()
spatial_reference.ImportFromEPSG(
int(qgis_spatial_reference.split(':')[1]))
vector_datasource = self.vector_driver.Open(
self.uri.absoluteFilePath(), True)
vector_datasource.CreateLayer(layer_name, spatial_reference, geometry)
uri = u'{}|layerid=0'.format(self.uri.absoluteFilePath())
vector_layer = QgsVectorLayer(uri, layer_name, u'ogr')
data_provider = vector_layer.dataProvider()
for feature in vector_layer.getFeatures():
data_provider.addFeatures([feature])
return True, layer_name
def _add_raster_layer(self, raster_layer, layer_name):
"""Add a raster layer to the folder.
:param raster_layer: The layer to add.
:type raster_layer: QgsRasterLayer
:param layer_name: The name of the layer in the datastore.
:type layer_name: str
:returns: A two-tuple. The first element will be True if we could add
the layer to the datastore. The second element will be the layer
name which has been used or the error message.
:rtype: (bool, str)
.. versionadded:: 4.0
"""
source = gdal.Open(raster_layer.source())
array = source.GetRasterBand(1).ReadAsArray()
x_size = source.RasterXSize
y_size = source.RasterYSize
output = self.raster_driver.Create(
self.uri.absoluteFilePath(),
x_size,
y_size,
1,
gdal.GDT_Byte,
['APPEND_SUBDATASET=YES', 'RASTER_TABLE=%s' % layer_name]
)
output.SetGeoTransform(source.GetGeoTransform())
output.SetProjection(source.GetProjection())
output.GetRasterBand(1).WriteArray(array)
# Once we're done, close properly the dataset
output = None
source = None
return True, layer_name
def _add_tabular_layer(self, tabular_layer, layer_name):
"""Add a tabular layer to the geopackage.
:param tabular_layer: The layer to add.
:type tabular_layer: QgsVectorLayer
:param layer_name: The name of the layer in the datastore.
:type layer_name: str
:returns: A two-tuple. The first element will be True if we could add
the layer to the datastore. The second element will be the layer
name which has been used or the error message.
:rtype: (bool, str)
.. versionadded:: 4.0
"""
return self._add_vector_layer(tabular_layer, layer_name)
def select_output_file(self):
prjfi = QFileInfo(QgsProject.instance().fileName())
filename = QFileDialog.getSaveFileName(self.dlg, "Select output file ", prjfi.absolutePath(), '*.shp')
self.dlg.outputPath.setText(filename)
def importXMLFromFile(self):
""" NO DOCUMENTATION """
assert self.has_selected_item()
# print "importXMLFromFile"
# First, prompt the user for the filename to read in
start_dir = ""
opus_home = os.environ.get("OPUS_HOME")
if opus_home:
start_dir_test = os.path.join(opus_home, "project_configs")
if start_dir_test:
start_dir = start_dir_test
configDialog = QFileDialog()
filter_str = QString("*.xml")
fd = configDialog.getOpenFileName(
self.manager.base_widget, "Please select an xml file to import...", start_dir, filter_str
)
# Check for cancel
if len(fd) == 0:
return
fileName = QString(fd)
fileNameInfo = QFileInfo(QString(fd))
fileNameInfoBaseName = fileNameInfo.completeBaseName()
fileNameInfoName = fileNameInfo.fileName().trimmed()
fileNameInfoPath = fileNameInfo.absolutePath().trimmed()
# Pass that in to create a new XMLConfiguration
xml_config = XMLConfiguration(str(fileNameInfoName), str(fileNameInfoPath))
xml_node = xml_config.full_tree.getroot()
if len(xml_node) == 0:
raise ValueError("Loading node from XML file failed. " "No node definition found")
xml_node = xml_node[0]
parent_node = self.selected_item().node
allowed_parent_tags = {
"tool": ["tool_group"],
"class_module": ["tool"],
"path_to_tool_modules": ["tool_library"],
"tool_library": ["data_manager"],
"tool_group": ["tool_library"],
"params": ["tool"],
"param": ["params"],
"tool_config": ["tool_set"],
"tool_set": ["tool_sets"],
"tool_sets": ["data_manager"],
}
if parent_node.tag not in allowed_parent_tags[xml_node.tag]:
MessageBox.error(
mainwindow=self.view,
text="Invalid Xml insert",
detailed_text=(
'Xml insert of node of type "%s" failed. '
'Invalid type of parent node is "%s" - needs to be one of %s'
% (xml_node.tag, parent_node.tag, str(allowed_parent_tags[xml_node.tag]))
),
)
return
# Insert it into the parent node from where the user clicked
name = xml_node.get("name") if xml_node.get("name") is not None else ""
if self.model.insertRow(0, self.selected_index(), xml_node) is False:
MessageBox.error(
mainwindow=self.view,
text="Xml Insert Failed",
detailed_text=(
'Xml insert of node with name "%s" failed - '
"most likely because there is already a node with that name." % name
),
)
return
class GeoPackage(DataStore):
"""
GeoPackage DataStore
.. versionadded:: 4.0
"""
def __init__(self, uri):
"""
Constructor for the GeoPackage DataStore.
:param uri: A filepath which doesn't exist
:type uri: QFileInfo, str
.. versionadded:: 4.0
"""
super(GeoPackage, self).__init__(uri)
self.vector_driver = ogr.GetDriverByName('GPKG')
self.raster_driver = gdal.GetDriverByName('GPKG')
if isinstance(uri, QFileInfo):
self._uri = uri
elif isinstance(uri, basestring):
self._uri = QFileInfo(uri)
else:
raise ErrorDataStore('Unknown type')
if self.uri.exists():
raster_datasource = gdal.Open(self.uri.absoluteFilePath())
if raster_datasource is None:
# Let's try if it's a vector one.
vector_datasource = self.vector_driver.Open(
self.uri.absoluteFilePath())
if vector_datasource is None:
msg = 'The file is not a geopackage or it doesn\'t ' \
'contain any layers.'
raise ErrorDataStore(msg)
else:
path = self.uri.absoluteFilePath()
# We need this variable to be created. The delete will create it.
datasource = self.vector_driver.CreateDataSource(path) # NOQA
del datasource
@property
def uri_path(self):
"""Return the URI of the datastore as a path. It's not a layer URI.
:return: The URI.
:rtype: str
.. versionadded:: 4.0
"""
return self.uri.absolutePath()
def is_writable(self):
"""Check if the folder is writable.
:return: If it's writable or not.
:rtype: bool
.. versionadded:: 4.0
"""
# Fixme, need to check DB permissions ?
return self._uri.absolutePath().isWritable()
def supports_rasters(self):
"""Check if we can support raster in the geopackage.
:return: If it's writable or not.
:rtype: bool
.. versionadded:: 4.0
"""
if int(gdal.VersionInfo('VERSION_NUM')) < 2000000:
return False
else:
return True
def _vector_layers(self):
"""Return a list of vector layers available.
:return: List of vector layers available in the geopackage.
:rtype: list
.. versionadded:: 4.0
"""
layers = []
vector_datasource = self.vector_driver.Open(
self.uri.absoluteFilePath())
if vector_datasource:
for i in range(vector_datasource.GetLayerCount()):
layers.append(vector_datasource.GetLayer(i).GetName())
return layers
def _raster_layers(self):
"""Return a list of raster layers available.
:return: List of raster layers available in the geopackage.
:rtype: list
.. versionadded:: 4.0
"""
layers = []
raster_datasource = gdal.Open(self.uri.absoluteFilePath())
if raster_datasource:
subdatasets = raster_datasource.GetSubDatasets()
if len(subdatasets) == 0:
metadata = raster_datasource.GetMetadata()
layers.append(metadata['IDENTIFIER'])
else:
for subdataset in subdatasets:
layers.append(subdataset[0].split(':')[2])
return layers
def layers(self):
"""Return a list of layers available.
:return: List of layers available in the datastore.
:rtype: list
.. versionadded:: 4.0
"""
return self._vector_layers() + self._raster_layers()
def layer_uri(self, layer_name):
"""Get layer URI.
For a vector layer :
/path/to/the/geopackage.gpkg|layername=my_vector_layer
For a raster :
GPKG:/path/to/the/geopackage.gpkg:my_raster_layer
:param layer_name: The name of the layer to fetch.
:type layer_name: str
:return: The URI to the layer.
:rtype: str
.. versionadded:: 4.0
"""
for layer in self._vector_layers():
if layer == layer_name:
uri = u'{}|layername={}'.format(
self.uri.absoluteFilePath(), layer_name)
return uri
else:
for layer in self._raster_layers():
if layer == layer_name:
uri = u'GPKG:{}:{}'.format(
self.uri.absoluteFilePath(), layer_name)
return uri
else:
return None
def _add_vector_layer(self, vector_layer, layer_name):
"""Add a vector layer to the geopackage.
:param vector_layer: The layer to add.
:type vector_layer: QgsVectorLayer
:param layer_name: The name of the layer in the datastore.
:type layer_name: str
:returns: A two-tuple. The first element will be True if we could add
the layer to the datastore. The second element will be the layer
name which has been used or the error message.
:rtype: (bool, str)
.. versionadded:: 4.0
"""
# Fixme
# if not self.is_writable():
# return False, 'The destination is not writable.'
geometry = QGIS_OGR_GEOMETRY_MAP[vector_layer.wkbType()]
spatial_reference = osr.SpatialReference()
qgis_spatial_reference = vector_layer.crs().authid()
spatial_reference.ImportFromEPSG(
int(qgis_spatial_reference.split(':')[1]))
vector_datasource = self.vector_driver.Open(
self.uri.absoluteFilePath(), True)
vector_datasource.CreateLayer(layer_name, spatial_reference, geometry)
uri = u'{}|layerid=0'.format(self.uri.absoluteFilePath())
vector_layer = QgsVectorLayer(uri, layer_name, u'ogr')
data_provider = vector_layer.dataProvider()
for feature in vector_layer.getFeatures():
data_provider.addFeatures([feature])
return True, layer_name
def _add_raster_layer(self, raster_layer, layer_name):
"""Add a raster layer to the folder.
:param raster_layer: The layer to add.
:type raster_layer: QgsRasterLayer
:param layer_name: The name of the layer in the datastore.
:type layer_name: str
:returns: A two-tuple. The first element will be True if we could add
the layer to the datastore. The second element will be the layer
name which has been used or the error message.
:rtype: (bool, str)
.. versionadded:: 4.0
"""
source = gdal.Open(raster_layer.source())
array = source.GetRasterBand(1).ReadAsArray()
x_size = source.RasterXSize
y_size = source.RasterYSize
output = self.raster_driver.Create(
self.uri.absoluteFilePath(),
x_size,
y_size,
1,
gdal.GDT_Byte,
['APPEND_SUBDATASET=YES', 'RASTER_TABLE=%s' % layer_name]
)
output.SetGeoTransform(source.GetGeoTransform())
output.SetProjection(source.GetProjection())
output.GetRasterBand(1).WriteArray(array)
# Once we're done, close properly the dataset
output = None
source = None
return True, layer_name
def _add_tabular_layer(self, tabular_layer, layer_name):
"""Add a tabular layer to the geopackage.
:param tabular_layer: The layer to add.
:type tabular_layer: QgsVectorLayer
:param layer_name: The name of the layer in the datastore.
:type layer_name: str
:returns: A two-tuple. The first element will be True if we could add
the layer to the datastore. The second element will be the layer
name which has been used or the error message.
:rtype: (bool, str)
.. versionadded:: 4.0
"""
return self._add_vector_layer(tabular_layer, layer_name)
QSettings)
from PyQt4.QtGui import (QApplication, QPlainTextEdit, QFileDialog,
QMainWindow)
import pqIMC
app = QApplication(sys.argv) # create an app
IMC = pqIMC.tricorder() # create inter-module communicator
pqMsgs.IMC = IMC
IMC.bookType = QString(u"html")
M = QMainWindow()
pqMsgs.makeBarIn(M.statusBar())
utname = QFileDialog.getOpenFileName(M, "UNIT TEST DATA FOR FLOW", ".")
utfile = QFile(utname)
if not utfile.open(QIODevice.ReadOnly):
raise IOError, unicode(utfile.errorString())
utinfo = QFileInfo(utfile)
IMC.bookDirPath = utinfo.absolutePath()
utstream = QTextStream(utfile)
utstream.setCodec("UTF-8")
utqs = utstream.readAll()
IMC.editWidget = QPlainTextEdit()
IMC.editWidget.setPlainText(utqs)
IMC.editWidget.show()
W = htmlPreview()
M.setCentralWidget(W)
M.show()
W.docWillChange()
W.docHasChanged()
#t = unicode(W.getSimpleText())
#print(t)
#W.doneWithText()
app.exec_()
def importXMLFromFile(self):
''' NO DOCUMENTATION '''
assert self.has_selected_item()
# print "importXMLFromFile"
# First, prompt the user for the filename to read in
start_dir = ''
opus_home = os.environ.get('OPUS_HOME')
if opus_home:
start_dir_test = os.path.join(opus_home, 'project_configs')
if start_dir_test:
start_dir = start_dir_test
configDialog = QFileDialog()
filter_str = QString("*.xml")
fd = configDialog.getOpenFileName(
self.manager.base_widget, "Please select an xml file to import...",
start_dir, filter_str)
# Check for cancel
if len(fd) == 0:
return
fileName = QString(fd)
fileNameInfo = QFileInfo(QString(fd))
fileNameInfoBaseName = fileNameInfo.completeBaseName()
fileNameInfoName = fileNameInfo.fileName().trimmed()
fileNameInfoPath = fileNameInfo.absolutePath().trimmed()
# Pass that in to create a new XMLConfiguration
xml_config = XMLConfiguration(str(fileNameInfoName),
str(fileNameInfoPath))
xml_node = xml_config.full_tree.getroot()
if len(xml_node) == 0:
raise ValueError('Loading node from XML file failed. '
'No node definition found')
xml_node = xml_node[0]
parent_node = self.selected_item().node
allowed_parent_tags = {"tool": ["tool_group"], \
"class_module": ["tool"], \
"path_to_tool_modules": ["tool_library"], \
"tool_library": ["data_manager"], \
"tool_group": ["tool_library"], \
"params": ["tool"], \
"param": ["params"], \
"tool_config": ["tool_set"], \
"tool_set": ["tool_sets"], \
"tool_sets": ["data_manager"]}
if parent_node.tag not in allowed_parent_tags[xml_node.tag]:
MessageBox.error(
mainwindow=self.view,
text='Invalid Xml insert',
detailed_text=
('Xml insert of node of type "%s" failed. '
'Invalid type of parent node is "%s" - needs to be one of %s'
% (xml_node.tag, parent_node.tag,
str(allowed_parent_tags[xml_node.tag]))))
return
# Insert it into the parent node from where the user clicked
name = xml_node.get('name') if xml_node.get('name') is not None else ''
if self.model.insertRow(0, self.selected_index(), xml_node) is False:
MessageBox.error(
mainwindow=self.view,
text='Xml Insert Failed',
detailed_text=
('Xml insert of node with name "%s" failed - '
'most likely because there is already a node with that name.'
% name))
return
from PyQt4.QtCore import (Qt,QFile,QIODevice,QFileInfo,QTextStream,QSettings)
from PyQt4.QtGui import (QApplication,QPlainTextEdit,QFileDialog,QMainWindow)
import pqIMC
app = QApplication(sys.argv) # create an app
IMC = pqIMC.tricorder() # create inter-module communicator
pqMsgs.IMC = IMC
IMC.bookType = QString(u"html")
M = QMainWindow()
pqMsgs.makeBarIn(M.statusBar())
utname = QFileDialog.getOpenFileName(M,
"UNIT TEST DATA FOR FLOW", ".")
utfile = QFile(utname)
if not utfile.open(QIODevice.ReadOnly):
raise IOError, unicode(utfile.errorString())
utinfo = QFileInfo(utfile)
IMC.bookDirPath = utinfo.absolutePath()
utstream = QTextStream(utfile)
utstream.setCodec("UTF-8")
utqs = utstream.readAll()
IMC.editWidget = QPlainTextEdit()
IMC.editWidget.setPlainText(utqs)
IMC.editWidget.show()
W = htmlPreview()
M.setCentralWidget(W)
M.show()
W.docWillChange()
W.docHasChanged()
#t = unicode(W.getSimpleText())
#print(t)
#W.doneWithText()
app.exec_()
