def keyPressEvent(self, event):
key = event.key()
mod = event.modifiers()
if key == Qt.Key_Up and self.history:
self.history_i = min(self.history_i+1, len(self.history)-1)
self.lineInput.setText(self.history[self.history_i])
elif key == Qt.Key_Down and self.history:
self.history_i = max(self.history_i-1, -1)
if self.history_i >= 0:
self.lineInput.setText(self.history[self.history_i])
else:
self.lineInput.setText('')
elif key == Qt.Key_Enter or key == Qt.Key_Return:
if mod & Qt.ShiftModifier:
self.complete()
else:
self.run()
elif key == Qt.Key_Escape:
txt, r = QInputDialog.getItem(self, QCoreApplication.translate("QPyShell", "Command line history"),
QCoreApplication.translate("QPyShell", "Please select a history item:"),
self.history, 0, False)
if r and txt:
self.lineInput.setText(txt)
elif self.standalone and key == Qt.Key_Print:
self.printContents()
elif self.standalone and key == Qt.Key_Q and (mod & Qt.ControlModifier):
self.close()
else:
QWidget.keyPressEvent(self, event)
def load(self):
self.initTranslations()
cfg = SimuVis4.Globals.config
cfgsec = self.name.lower()
if not cfg.has_section(cfgsec):
cfg.add_section(cfgsec)
cfg.set_def(cfgsec, 'set_default_backend', 'yes')
cfg.set_def(cfgsec, 'zoom_step_factor', '0.189207115002721')
cfg.set_def(cfgsec, 'mouse_wheel_step', '15')
glb = SimuVis4.Globals
import matplotlib
if matplotlib.__version__ < mplMinVersion or matplotlib.__version__ > mplMaxVersion:
SimuVis4.Globals.logger.error(unicode(QCoreApplication.translate('MatPlot', 'MatPlot: need matplotlib version between %s and %s, but found %s')) % \
(mplMinVersion, mplMaxVersion, matplotlib.__version__))
return False
self.matplotlib = matplotlib
if cfg.getboolean(cfgsec, 'set_default_backend'):
try:
sys.path.append(os.path.split(__file__)[0])
matplotlib.use('module://backend_sv4agg')
except:
pass
import backend_sv4agg
self.backend_sv4agg = backend_sv4agg
dpath = matplotlib.rcParams['datapath']
tmp = os.path.join(dpath, 'images')
if os.path.isdir(tmp):
dpath = tmp
winIcon = QIcon(os.path.join(dpath, 'matplotlib.png'))
testAction = QAction(winIcon,
QCoreApplication.translate('MatPlot', '&MatPlot/PyLab Test'), SimuVis4.Globals.mainWin)
testAction.setStatusTip(QCoreApplication.translate('MatPlot', 'Show a matplotlib/pylab test window'))
QWidget.connect(testAction, SIGNAL("triggered()"), self.test)
SimuVis4.Globals.mainWin.plugInMenu.addAction(testAction)
return True
def __init__(self, layers):
"""
Constructor
"""
QDialog.__init__(self)
self.__layers = layers
self.setWindowTitle(QCoreApplication.translate("VDLTools", "Edition Confirmation"))
self.__layout = QGridLayout()
titleLabel = QLabel(QCoreApplication.translate("VDLTools", "Do you really want to edit these layers ?"))
self.__layout.addWidget(titleLabel, 0, 0, 1, 2)
pos = 1
for layer in self.__layers:
label = QLabel(" - " + layer.name())
self.__layout.addWidget(label, pos, 0, 1, 2)
pos += 1
self.__cancelButton = QPushButton(QCoreApplication.translate("VDLTools", "Cancel"))
self.__cancelButton.setMinimumHeight(20)
self.__cancelButton.setMinimumWidth(100)
pos = len(self.__layers) + 1
self.__layout.addWidget(self.__cancelButton, pos, 0)
self.__okButton = QPushButton(QCoreApplication.translate("VDLTools", "OK"))
self.__okButton.setMinimumHeight(20)
self.__okButton.setMinimumWidth(100)
self.__layout.addWidget(self.__okButton, pos, 1)
self.setLayout(self.__layout)
def saveIntersectionResult(self, report, intersectedPoint):
# save the intersection result (point) and its report
# check first
while True:
if not self.settings.value("advancedIntersectionWritePoint"):
break # if we do not place any point, skip
layerid = self.settings.value("advancedIntersectionLayer")
message = QCoreApplication.translate("IntersectIt",
"To place the intersection solution,"
" you must select a layer in the settings.")
status, intLayer = self.checkLayerExists(layerid, message)
if status == 2:
continue
if status == 3:
return
if self.settings.value("advancedIntersectionWriteReport"):
reportField = self.settings.value("reportField")
message = QCoreApplication.translate("IntersectIt",
"To save the intersection report, please select a field for it.")
status = self.checkFieldExists(intLayer, reportField, message)
if status == 2:
continue
if status == 3:
return
break
# save the intersection results
if self.settings.value("advancedIntersectionWritePoint"):
f = QgsFeature()
f.setGeometry(QgsGeometry().fromPoint(intersectedPoint))
if self.settings.value("advancedIntersectionWriteReport"):
irep = intLayer.dataProvider().fieldNameIndex(reportField)
f.addAttribute(irep, report)
intLayer.dataProvider().addFeatures([f])
intLayer.updateExtents()
self.mapCanvas.refresh()
def saveAsScriptFile(self, index=None):
tabWidget = self.tabEditorWidget.currentWidget()
if not index:
index = self.tabEditorWidget.currentIndex()
if not tabWidget.path:
fileName = self.tabEditorWidget.tabText(index) + '.py'
folder = self.settings.value("pythonConsole/lastDirPath", QDir.home())
pathFileName = os.path.join(folder, fileName)
fileNone = True
else:
pathFileName = tabWidget.path
fileNone = False
saveAsFileTr = QCoreApplication.translate("PythonConsole", "Save File As")
filename = QFileDialog.getSaveFileName(self,
saveAsFileTr,
pathFileName, "Script file (*.py)")
if filename:
try:
tabWidget.save(filename)
except (IOError, OSError) as error:
msgText = QCoreApplication.translate('PythonConsole',
'The file <b>{0}</b> could not be saved. Error: {1}').format(tabWidget.path,
error.strerror)
self.callWidgetMessageBarEditor(msgText, 2, False)
if fileNone:
tabWidget.path = None
else:
tabWidget.path = pathFileName
return
if not fileNone:
self.updateTabListScript(pathFileName, action='remove')
def __init__(self):
"""
Constructor
"""
QDialog.__init__(self)
self.setWindowTitle(QCoreApplication.translate("VDLTools", "Display Attributes Confirmation"))
self.resize(300, 100)
self.__layout = QGridLayout()
self.__confirmLabel = QLabel(
QCoreApplication.translate("VDLTools",
"Do you want to display the attributes tables for the selected features ?"))
self.__layout.addWidget(self.__confirmLabel, 0, 0, 1, 2)
self.__okButton = QPushButton(QCoreApplication.translate("VDLTools", "Yes"))
self.__okButton.setMinimumHeight(20)
self.__okButton.setMinimumWidth(100)
self.__cancelButton = QPushButton(QCoreApplication.translate("VDLTools", "No"))
self.__cancelButton.setMinimumHeight(20)
self.__cancelButton.setMinimumWidth(100)
self.__layout.addWidget(self.__okButton, 1, 0)
self.__layout.addWidget(self.__cancelButton, 1, 1)
self.setLayout(self.__layout)
def saveContents(self, fileName=None):
if not fileName:
fileTypes = {'Text':('txt',), 'HTML':('htm', 'html')}
filters = ';;'.join(['%s (%s)' % (k, ' '.join(['*.'+e for e in v])) for k, v in fileTypes.items()])
dlg = QFileDialog(self,
QCoreApplication.translate('QPyShell', 'Select name of file to save'),
os.getcwd(), filters)
dlg.setFileMode(QFileDialog.AnyFile)
dlg.setAcceptMode(QFileDialog.AcceptSave)
if dlg.exec_() != QDialog.Accepted:
return
tmp = unicode(dlg.selectedFilter())
fileType = tmp[:tmp.find('(')-1]
dlg.setDefaultSuffix(fileTypes[fileType][0])
files = dlg.selectedFiles()
if not files:
return
fileName = unicode(files[0])
if fileType == 'Text':
txt = self.outputBrowser.toPlainText()
elif fileType == 'HTML':
txt = self.outputBrowser.toHtml()
else:
raise IOError('Unknown FileType: %s' % fileType)
try:
open(fileName, 'w').write(txt)
except IOError:
QMessageBox.critical(self,
QCoreApplication.translate('QPyShell', 'Could not save file!'),
QCoreApplication.translate('QPyShell', 'Writing failed! Make sure you have write permissions!'))
def initGui(self):
# Actions
self.action_convert = QAction(QIcon(path.join(_current_path, 'convert.png')),
QCoreApplication.translate('RuGeocoder', 'Convert CSV to SHP'),
self.iface.mainWindow())
QObject.connect(self.action_convert, SIGNAL("triggered()"), self.run_convert)
self.action_batch_geocoding = QAction(QIcon(path.join(_current_path, 'icon.png')),
QCoreApplication.translate('RuGeocoder', 'Batch geocoding'),
self.iface.mainWindow())
QObject.connect(self.action_batch_geocoding, SIGNAL('triggered()'), self.run_batch)
self.action_quick_geocoding = self.__quick_tlb.toggleViewAction()
self.action_quick_geocoding.setIcon(QIcon(path.join(_current_path, 'edit-find-project.png')))
self.action_quick_geocoding.setText(QCoreApplication.translate('RuGeocoder', '&Quick geocoding toolbox'))
# Add toolbar button and menu item
self.toolbar.addAction(self.action_convert)
self.iface.addPluginToWebMenu(self.menu_name, self.action_convert)
self.toolbar.addAction(self.action_batch_geocoding)
self.iface.addPluginToWebMenu(self.menu_name, self.action_batch_geocoding)
self.toolbar.addSeparator()
self.toolbar.addAction(self.action_quick_geocoding)
self.iface.addPluginToWebMenu(self.menu_name, self.action_quick_geocoding)
def itemAction(self, mi,):
# FIXME: use a MIME-Handler here
i = self.model.itemFromIndex(mi)
t, nc = i.ncItem
QMessageBox.information(self,
QCoreApplication.translate('NetCDF3', 'netCDF3: Item clicked'),
QCoreApplication.translate('NetCDF3', 'You clicked an item in the netCDF3-browser'))
def load(self):
self.initTranslations()
cfg = SimuVis4.Globals.config
cfgsec = self.name.lower()
if not cfg.has_section(cfgsec):
cfg.add_section(cfgsec)
cfg.set_def(cfgsec, 'show_config_warning', 'yes')
glb = SimuVis4.Globals
import matplotlib
if matplotlib.__version__ < mplMinVersion or matplotlib.__version__ > mplMaxVersion:
SimuVis4.Globals.logger.error(unicode(QCoreApplication.translate('MatPlot', 'MatPlot: need matplotlib version between %s and %s, but found %s')) % \
(mplMinVersion, mplMaxVersion, matplotlib.__version__))
return False
self.matplotlib = matplotlib
try:
matplotlib.use('SV4Agg')
except:
if cfg.getboolean(cfgsec, 'show_config_warning'):
QTimer().singleShot(8000, showConfigWarning)
import backend_sv4agg
self.backend_sv4agg = backend_sv4agg
dpath = matplotlib.rcParams['datapath']
tmp = os.path.join(dpath, 'images')
if os.path.isdir(tmp):
dpath = tmp
winIcon = QIcon(os.path.join(dpath, 'matplotlib.png'))
testAction = QAction(winIcon,
QCoreApplication.translate('MatPlot', '&MatPlot Test'), SimuVis4.Globals.mainWin)
testAction.setStatusTip(QCoreApplication.translate('MatPlot', 'Show a matplotlib test window'))
QWidget.connect(testAction, SIGNAL("triggered()"), self.test)
SimuVis4.Globals.mainWin.plugInMenu.addAction(testAction)
return True
def run(self):
'''
Runs the widget
'''
project = PagLuxembourg.main.current_project
if not project.isPagProject():
return
# Map layers in the TOC
maplayers = QgsMapLayerRegistry.instance().mapLayers()
# Iterates through XSD types
for type in PagLuxembourg.main.xsd_schema.types:
if type.geometry_type is None:
continue
uri = project.getTypeUri(type)
found = False
# Check whether a layer with type data source exists in the map
for k,v in maplayers.iteritems():
if project.compareURIs(v.source(), uri):
found = True
layer = v
break
if not found:
continue
self.stylizeLayer(layer, type)
PagLuxembourg.main.qgis_interface.messageBar().pushSuccess(QCoreApplication.translate('StylizeProject','Success'),
QCoreApplication.translate('StylizeProject','The layers styling is finished.'))
def defineCharacteristicsFromFile(self):
lines = open(self.descriptionFile)
line = lines.readline().strip("\n").strip()
self.name = line
self.i18n_name = QCoreApplication.translate("TAUDEMAlgorithm", line)
line = lines.readline().strip("\n").strip()
self.cmdName = line
line = lines.readline().strip("\n").strip()
self.group = line
self.i18n_group = QCoreApplication.translate("TAUDEMAlgorithm", line)
line = lines.readline().strip("\n").strip()
while line != "":
try:
line = line.strip("\n").strip()
if line.startswith("Parameter"):
param = getParameterFromString(line)
self.addParameter(param)
else:
self.addOutput(getOutputFromString(line))
line = lines.readline().strip("\n").strip()
except Exception as e:
ProcessingLog.addToLog(
ProcessingLog.LOG_ERROR,
self.tr("Could not load TauDEM algorithm: %s\n%s" % (self.descriptionFile, line)),
)
raise e
lines.close()
def removeDir(path):
result = ""
if not QFile(path).exists():
result = QCoreApplication.translate("QgsPluginInstaller", "Nothing to remove! Plugin directory doesn't exist:") + "\n" + path
elif QFile(path).remove(): # if it is only link, just remove it without resolving.
pass
else:
fltr = QDir.Dirs | QDir.Files | QDir.Hidden
iterator = QDirIterator(path, fltr, QDirIterator.Subdirectories)
while iterator.hasNext():
item = iterator.next()
if QFile(item).remove():
pass
fltr = QDir.Dirs | QDir.Hidden
iterator = QDirIterator(path, fltr, QDirIterator.Subdirectories)
while iterator.hasNext():
item = iterator.next()
if QDir().rmpath(item):
pass
if QFile(path).exists():
result = QCoreApplication.translate("QgsPluginInstaller", "Failed to remove the directory:") + "\n" + path + "\n" + QCoreApplication.translate("QgsPluginInstaller", "Check permissions or remove it manually")
# restore plugin directory if removed by QDir().rmpath()
pluginDir = qgis.utils.home_plugin_path
if not QDir(pluginDir).exists():
QDir().mkpath(pluginDir)
return result
def __init__(self, message):
"""
Constructor
"""
QDialog.__init__(self)
self.setWindowTitle(QCoreApplication.translate("VDLTools", "Edition Confirmation"))
self.resize(300, 100)
self.__layout = QGridLayout()
self.__confirmLabel = QLabel(message)
self.__layout.addWidget(self.__confirmLabel, 0, 0, 1, 2)
self.__okButton = QPushButton(QCoreApplication.translate("VDLTools", "Yes"))
self.__okButton.setMinimumHeight(20)
self.__okButton.setMinimumWidth(300)
self.__cancelButton = QPushButton(QCoreApplication.translate("VDLTools", "No"))
self.__cancelButton.setMinimumHeight(20)
self.__cancelButton.setMinimumWidth(100)
self.__layout.addWidget(self.__okButton, 1, 0)
self.__layout.addWidget(self.__cancelButton, 1, 1)
self.setLayout(self.__layout)
def test(self):
if not self.winManager:
return
from PyQt4.QtGui import QGraphicsScene, QGraphicsItem, QGraphicsLineItem
from PyQt4.QtCore import QRectF, QLineF
w = self.winManager.newWindow()
scene = QGraphicsScene(w.graphicsView)
scene.addItem(Items.Grid())
scene.addItem(Items.Axes())
line = scene.addLine(QLineF(0, 0, 0, 0))
cross = Items.NodeCross(movable=True)
cross.addEdge(line, 1)
scene.addItem(cross)
help = scene.addText(QCoreApplication.translate('Graphics', 'Press "h" for help!'))
help.moveBy(-50, 80)
text = Items.NodeText(QCoreApplication.translate('Graphics', 'Drag Me!'))
text.setFlag(QGraphicsItem.ItemIsMovable, True)
text.setFlag(QGraphicsItem.ItemIsSelectable, True)
text.addEdge(line, 2)
scene.addItem(text)
w.graphicsView.setScene(scene)
def switchToolMode( self ):
self.setCommandViewerEnabled( not self.batchCheck.isChecked() )
self.progressBar.setVisible( self.batchCheck.isChecked() )
self.inSelector.setType( self.inSelector.FILE if self.batchCheck.isChecked() else self.inSelector.FILE_LAYER )
self.outSelector.clear()
if self.batchCheck.isChecked():
self.inFileLabel = self.label.text()
self.outFileLabel = self.label_2.text()
self.label.setText( QCoreApplication.translate( "GdalTools", "&Input directory" ) )
self.label_2.setText( QCoreApplication.translate( "GdalTools", "&Output directory" ) )
QObject.disconnect( self.inSelector, SIGNAL( "selectClicked()" ), self.fillInputFile )
QObject.disconnect( self.outSelector, SIGNAL( "selectClicked()" ), self.fillOutputFileEdit )
QObject.connect( self.inSelector, SIGNAL( "selectClicked()" ), self.fillInputDir )
QObject.connect( self.outSelector, SIGNAL( "selectClicked()" ), self.fillOutputDir )
else:
self.label.setText( self.inFileLabel )
self.label_2.setText( self.outFileLabel )
QObject.disconnect( self.inSelector, SIGNAL( "selectClicked()" ), self.fillInputDir )
QObject.disconnect( self.outSelector, SIGNAL( "selectClicked()" ), self.fillOutputDir )
QObject.connect( self.inSelector, SIGNAL( "selectClicked()" ), self.fillInputFile )
QObject.connect( self.outSelector, SIGNAL( "selectClicked()" ), self.fillOutputFileEdit )
def __onOk(self):
"""
When the Ok button in Show Settings Dialog is pushed
"""
values = self.__showDlg.levelVal().split(',')
for v in values:
if not v.isdigit():
QMessageBox.information(
None, QCoreApplication.translate("VDLTools", "Error"),
QCoreApplication.translate("VDLTools", "Point code attribute has to be numbers separated by comma")
)
return
self.__showDlg.accept()
self.linesLayer = self.__showDlg.linesLayer()
self.pointsLayer = self.__showDlg.pointsLayer()
self.configTable = self.__showDlg.configTable()
self.uriDb = self.__showDlg.uriDb()
self.ctlDb = self.__showDlg.ctlDb()
self.schemaDb = self.__showDlg.schemaDb()
self.mntUrl = self.__showDlg.mntUrl()
self.refLayers = self.__showDlg.refLayers()
self.adjLayers = self.__showDlg.adjLayers()
self.levelAtt = self.__showDlg.levelAtt()
self.levelVals = self.__showDlg.levelVal()
self.drawdownLayer = self.__showDlg.drawdownLayer()
self.pipeDiam = self.__showDlg.pipeDiam()
self.changedSignal.emit()
def __checkSituations(self):
"""
To check if point with no elevation on line, and one or more elevation from other layers,
and if there are different elevations at the same point
"""
situations = []
differences = []
for p in range(len(self.__points)):
pt = self.__points[p]
num_lines = len(self.__selectedIds)
zz = []
for i in range(num_lines):
if pt['z'][i] is not None:
zz.append(i)
if len(zz) == 0:
self.__iface.messageBar().pushMessage(
QCoreApplication.translate("VDLTools", "No line z ?!?"), level=QgsMessageBar.WARNING)
elif len(zz) == 1:
z0 = pt['z'][zz[0]]
for i in range(num_lines, len(pt['z'])):
if pt['z'][i] is None:
continue
if abs(pt['z'][i]-z0) > self.ALT_TOLERANCE:
situations.append({'point': p, 'layer': (i-num_lines+1), 'vertex': z0})
elif len(zz) == 2:
z0 = pt['z'][zz[0]]
if abs(pt['z'][zz[1]] - z0) > self.ALT_TOLERANCE:
differences.append({'point': p, 'v1': z0, 'v2': pt['z'][zz[1]]})
else:
for i in range(num_lines, len(pt['z'])):
if pt['z'][i] is None:
continue
if abs(pt['z'][i]-z0) > self.ALT_TOLERANCE:
situations.append({'point': p, 'layer': (i-num_lines+1), 'vertex': z0})
else:
self.__iface.messageBar().pushMessage(
QCoreApplication.translate("VDLTools", "More than 2 lines z ?!?"), level=QgsMessageBar.WARNING)
if (len(situations) > 0) or (len(differences) > 0):
self.__setMessageDialog(situations, differences, self.__getNames())
self.__rubberSit.reset()
self.__rubberDif.reset()
for situation in situations:
pt = self.__points[situation['point']]
point = QgsPoint(pt['x'], pt['y'])
if self.__rubberSit.numberOfVertices() == 0:
self.__rubberSit.setToGeometry(QgsGeometry().fromPoint(point), None)
else:
self.__rubberSit.addPoint(point)
for difference in differences:
pt = self.__points[difference['point']]
point = QgsPoint(pt['x'], pt['y'])
if self.__rubberDif.numberOfVertices() == 0:
self.__rubberDif.setToGeometry(QgsGeometry().fromPoint(point), None)
else:
self.__rubberDif.addPoint(point)
self.__msgDlg.show()
else:
self.__checkZeros()
def defineCharacteristicsFromFile(self):
lines = open(self.descriptionFile)
line = lines.readline().strip('\n').strip()
self.name = line
if '|' in self.name:
tokens = self.name.split('|')
self.name = tokens[0]
self.i18n_name = QCoreApplication.translate("SAGAAlgorithm", unicode(self.name))
self.cmdname = tokens[1]
else:
self.cmdname = self.name
self.i18n_name = QCoreApplication.translate("SAGAAlgorithm", unicode(self.name))
self.name = self.name[0].upper() + self.name[1:].lower()
line = lines.readline().strip('\n').strip()
self.undecoratedGroup = line
self.group = SagaGroupNameDecorator.getDecoratedName(self.undecoratedGroup)
self.i18n_group = QCoreApplication.translate("SAGAAlgorithm", self.group)
line = lines.readline().strip('\n').strip()
while line != '':
if line.startswith('Hardcoded'):
self.hardcodedStrings.append(line[len('Harcoded|') + 1:])
elif line.startswith('Parameter'):
self.addParameter(getParameterFromString(line))
elif line.startswith('AllowUnmatching'):
self.allowUnmatchingGridExtents = True
elif line.startswith('Extent'):
# An extent parameter that wraps 4 SAGA numerical parameters
self.extentParamNames = line[6:].strip().split(' ')
self.addParameter(ParameterExtent(self.OUTPUT_EXTENT,
'Output extent', '0,1,0,1'))
else:
self.addOutput(getOutputFromString(line))
line = lines.readline().strip('\n').strip()
lines.close()
def load(self):
self.initTranslations()
import vtk, VtkWidget, VtkWindow, Objects, Helpers
self.vtk = vtk
self.VtkWidget = VtkWidget
self.VtkWindow = VtkWindow
self.Objects = Objects
self.Helpers = Helpers
xpm = QPixmap()
xpm.loadFromData(self.getFile('3dwin.xpm').read())
winIcon = QIcon(xpm)
self.winManager = SubWinManager(glb.mainWin.workSpace, self.VtkWindow.VtkWindow,
QCoreApplication.translate('VtkWindow', "Vtk Window"), winIcon)
testAction = QAction(winIcon,
QCoreApplication.translate('VtkWindow', '&VtkWindow Test'), glb.mainWin)
testAction.setStatusTip(QCoreApplication.translate('VtkWindow', 'Show a new Vtk test window'))
QWidget.connect(testAction, SIGNAL("triggered()"), self.test)
glb.mainWin.plugInMenu.addAction(testAction)
ftActions = glb.fileTypeActions
ftActions.addType('application/x-3ds', '.3ds')
ftActions.addAction(self.show3DS, ('application/x-3ds',),
QCoreApplication.translate('VtkWindow', 'Open in VtkWindow'), 5)
ftActions.addType('application/x-vrml', '.wrl')
ftActions.addAction(self.showVRML, ('application/x-vrml',),
QCoreApplication.translate('VtkWindow', 'Open in VtkWindow'), 5)
return True
def __init__(self, parent):
QDialog.__init__(self, parent)
self.setWindowTitle(QCoreApplication.translate("SettingsDialogPythonConsole", "Settings Python Console"))
self.parent = parent
self.setupUi(self)
self.listPath = []
self.lineEdit.setReadOnly(True)
self.restoreSettings()
self.initialCheck()
self.addAPIpath.setIcon(QIcon(":/images/themes/default/symbologyAdd.png"))
self.addAPIpath.setToolTip(QCoreApplication.translate("PythonConsole", "Add API path"))
self.removeAPIpath.setIcon(QIcon(":/images/themes/default/symbologyRemove.png"))
self.removeAPIpath.setToolTip(QCoreApplication.translate("PythonConsole", "Remove API path"))
self.preloadAPI.stateChanged.connect(self.initialCheck)
self.addAPIpath.clicked.connect(self.loadAPIFile)
self.removeAPIpath.clicked.connect(self.removeAPI)
self.compileAPIs.clicked.connect(self._prepareAPI)
self.resetFontColor.setIcon(QIcon(":/images/themes/default/console/iconResetColorConsole.png"))
self.resetFontColor.setIconSize(QSize(18, 18))
self.resetFontColorEditor.setIcon(QIcon(":/images/themes/default/console/iconResetColorConsole.png"))
self.resetFontColorEditor.setIconSize(QSize(18, 18))
self.resetFontColor.clicked.connect(self._resetFontColor)
self.resetFontColorEditor.clicked.connect(self._resetFontColorEditor)
def run(self):
if QSettings().value("addressLookup/mode") == 3 and self.internet_on() == True: # Nur Hintergrundkarte laden
self.addBingAerial()
self.canvas.refresh()
self.canvas.mapCanvasRefreshed.connect(self.zoomStandard)
elif QSettings().value("addressLookup/mode") == 1 and self.internet_on() == True: # Gesamte Prozedur
self.addBingAerial()
chk = self.check_settings()
try:
from geopy.geocoders.osm import Nominatim
except:
QMessageBox.information(self.iface.mainWindow(),QCoreApplication.translate('GeoCoding', "Geopy konnte nicht importiert werden."), "Geopy konnte nicht importiert werden.")
if len(chk) :
QMessageBox.information(self.iface.mainWindow(),QCoreApplication.translate('GeoCoding', "GeoCoding plugin error"), chk)
self.zoomToPoint(self.defaultPoint, 2200000)
return
#Import geopy
try:
geocoder = Nominatim()
except AttributeError, e:
QMessageBox.information(self.iface.mainWindow(), QCoreApplication.translate('GeoCoding', "GeoCoding plugin error"), QCoreApplication.translate('GeoCoding', "Couldn't import Python module 'geopy.geocoders' for communication with geocoders. The problem is most probably caused by other plugins shipping with obsolete geopy versions. Please try to uninstall all other Python plugins and retry.<br>Message: %s" % e))
self.zoomToPoint(self.defaultPoint, 2200000)
return
except ImportError, e:
QMessageBox.information(self.iface.mainWindow(), QCoreApplication.translate('GeoCoding', "GeoCoding plugin error"), QCoreApplication.translate('GeoCoding', "Couldn't import Python module 'geopy' for communication with geocoders. Without it you won't be able to run GeoCoding plugin. Please report this error on the <a href=\"https://github.com/elpaso/qgis-geocoding/issues\">bug tracker</a>.<br>Message: %s" % e))
self.zoomToPoint(self.defaultPoint, 2200000)
return
def __init__(self):
"""
Constructor
"""
QDialog.__init__(self)
self.setWindowTitle(QCoreApplication.translate("VDLTools", "Move/Copy Confirmation"))
self.resize(300, 100)
self.__layout = QGridLayout()
self.__confirmLabel = QLabel(
QCoreApplication.translate("VDLTools", "Would you like to move or to copy this feature ?"))
self.__layout.addWidget(self.__confirmLabel, 0, 0, 1, 3)
self.__moveButton = QPushButton(QCoreApplication.translate("VDLTools", "Move"))
self.__moveButton.setMinimumHeight(20)
self.__moveButton.setMinimumWidth(100)
self.__copyButton = QPushButton(QCoreApplication.translate("VDLTools", "Copy"))
self.__copyButton.setMinimumHeight(20)
self.__copyButton.setMinimumWidth(100)
self.__cancelButton = QPushButton(QCoreApplication.translate("VDLTools", "Cancel"))
self.__cancelButton.setMinimumHeight(20)
self.__cancelButton.setMinimumWidth(100)
self.__layout.addWidget(self.__moveButton, 1, 0)
self.__layout.addWidget(self.__copyButton, 1, 1)
self.__layout.addWidget(self.__cancelButton, 1, 2)
self.setLayout(self.__layout)
def startServerPlugin(packageName):
""" initialize the plugin """
global server_plugins, server_active_plugins, serverIface
if packageName in server_active_plugins:
return False
if packageName not in sys.modules:
return False
package = sys.modules[packageName]
errMsg = QCoreApplication.translate("Python", "Couldn't load server plugin %s") % packageName
# create an instance of the plugin
try:
server_plugins[packageName] = package.serverClassFactory(serverIface)
except:
_unloadPluginModules(packageName)
msg = (
QCoreApplication.translate("Python", "%s due to an error when calling its serverClassFactory() method")
% errMsg
)
showException(sys.exc_info()[0], sys.exc_info()[1], sys.exc_info()[2], msg)
return False
# add to active plugins
server_active_plugins.append(packageName)
return True
def loadFile(self):
mnFileName = unicode(self.mnFileNameInput.text())
if not mnFileName:
QMessageBox.warning(glb.mainWin,
QCoreApplication.translate('SmileKit', 'No filename specified'),
QCoreApplication.translate('SmileKit', 'Please enter a filename in the input box!'))
return
progressDlg = QProgressDialog(glb.mainWin)
progressDlg.setRange(0, 100)
progressDlg.setLabelText('Reading File...')
progressDlg.show()
a = glb.application
def progFunc(p):
progressDlg.setValue(p)
if a.hasPendingEvents():
a.processEvents()
r = readMnFile(mnFileName, progress=progFunc)
self.data = r
progressDlg.close()
self.locationFrame.setEnabled(1)
self.statisticsFrame.setEnabled(1)
if ncOk:
self.ncFileFrame.setEnabled(1)
self.statisticsButton.setCheckState(Qt.Unchecked)
self.locNameInput.setText(r['name'])
c = unicode(QCoreApplication.translate('SmileKit', "created %s from %s by Meteo2Nc.py (v%d)"))
self.locCommentInput.setText(c % (time.ctime(), mnFileName, version))
self.locLatitudeInput.setValue(r['latitude'])
self.locLongitudeInput.setValue(r['longitude'])
self.locHeightInput.setValue(r['height'])
self.locTimeZoneInput.setValue(r['timezone'])
path, tmp = os.path.split(mnFileName)
ncFileName = os.path.join(path, makeFileName(r['name'])+'_weather.nc')
self.ncFileNameInput.setText(ncFileName)
def collectVersions(self):
csw = Misc.Switcher(0, "#ffffff", "#eeeeee")
buf = ['<table><tr bgcolor="#dddddd"><th>Component/Library</th><th>Version</th></tr>']
buf.append('<tr bgcolor="%s"><td>SimuVis4</td><td>%s</td></tr>' % (csw(), Globals.version_string))
buf.append('<tr bgcolor="%s"><td>Python</td><td>%s | %s</td></tr>' % \
(csw(), '.'.join([str(i) for i in sys.version_info]), sys.version))
buf.append('<tr bgcolor="%s"><td>PyQt</td><td>%s | %s</td></tr>' % (csw(), PYQT_VERSION_STR, PYQT_VERSION))
buf.append('<tr bgcolor="%s"><td>Qt</td><td>%s</td></tr>' % (csw(), qVersion()))
if sys.modules.has_key('vtk'):
v = sys.modules['vtk'].vtkVersion.GetVTKVersion()
vl = sys.modules['vtk'].vtkVersion.GetVTKSourceVersion()
buf.append('<tr bgcolor="%s"><td>Vtk</td><td>%s | %s</td></tr>' % (csw(), v, vl))
if sys.modules.has_key('OpenGL'):
v = sys.modules['OpenGL'].__version__
buf.append('<tr bgcolor="%s"><td>PyOpenGL</td><td>%s</td></tr>' % (csw(), v))
for p in Globals.mainWin.plugInManager.plugIns.values():
buf.append('<tr bgcolor="%s"><td>PlugIn: %s</td><td>%s</td></tr>' % (csw(), p.name, p.version))
if sys.platform == 'linux2':
n = QCoreApplication.translate('AboutDlg', 'Operating System')
d = getLinuxDistro()
k = os.popen('uname -o -s -r', 'r').readlines()[0]
buf.append('<tr bgcolor="%s"><td>%s</td><td>%s (%s)</td></tr>' % (csw(), n, d, k))
if sys.platform == 'win32':
n = QCoreApplication.translate('AboutDlg', 'Operating System')
v, vs = getWindowsVersion()
buf.append('<tr bgcolor="%s"><td>%s</td><td>%s</td></tr>' % (csw(), n, vs))
buf.append('</table>')
self.VersionView.setHtml('\n'.join(buf))
def __init__(self, parent):
SubWindow.__init__(self, parent)
icon = QIcon(QPixmap(os.path.join(Globals.config['main:system_picture_path'], 'logwin.xpm')))
self.setWindowIcon(icon)
self.setWindowTitle(QCoreApplication.translate('LogWindow', 'Log Messages'))
self.setMinimumSize(500, 100)
self.logView = LogViewWidget(self)
self.setWidget(self.logView)
tmp = Globals.logLevels.items()
tmp.sort(lambda a,b: cmp(a[1], b[1]))
self.levels = [l[0] for l in tmp]
self.logView.ThresholdSelector.addItems(self.levels)
self.handler = TextBrowserHandler()
self.handler.setBrowser(self.logView.TextArea, self)
try:
i = self.levels.index(Globals.config['main:log_threshold'])
self.logView.ThresholdSelector.setCurrentIndex(i)
self.setThreshold(i)
except:
self.logView.ThresholdSelector.setCurrentIndex(0)
self.setThreshold(0)
self.connect(self.logView.SaveButton, SIGNAL("pressed()"), self.saveWindow)
self.connect(self.logView.ThresholdSelector, SIGNAL("activated(int)"), self.setThreshold)
self.hideOnClose = True
self.toggleVisibleAction.setIcon(icon)
self.toggleVisibleAction.setText(QCoreApplication.translate('LogWindow', '&Log window'))
self.toggleVisibleAction.setShortcut(QCoreApplication.translate('LogWindow', 'Ctrl+L'))
self.toggleVisibleAction.setStatusTip(QCoreApplication.translate('LogWindow', 'Log window'))
def saveWindow(self, fileName=None, fileType=None):
if not fileName:
fileTypes = {'Text':('txt',), 'HTML':('htm', 'html')}
filters = ';;'.join(['%s (%s)' % (k, ' '.join(['*.'+e for e in v])) for k, v in fileTypes.items()])
dlg = QFileDialog(self,
QCoreApplication.translate('LogWindow', 'Select name of file to save'),
Globals.defaultFolder or '', filters)
dlg.setFileMode(QFileDialog.AnyFile)
dlg.setAcceptMode(QFileDialog.AcceptSave)
if dlg.exec_() != QDialog.Accepted:
return
tmp = str(dlg.selectedFilter())
fileType = tmp[:tmp.find('(')-1]
dlg.setDefaultSuffix(fileTypes[fileType][0])
files = dlg.selectedFiles()
if not files:
return
fileName = unicode(files[0])
Globals.defaultFolder, tmp = os.path.split(fileName)
if fileType == 'Text':
txt = self.logView.TextArea.toPlainText()
elif fileType == 'HTML':
txt = self.logView.TextArea.toHtml()
else:
raise Errors.IOError('Unknown FileType: %s' % fileType)
try:
open(fileName, 'w').write(txt)
except IOError:
QMessageBox.critical(self,
QCoreApplication.translate('LogWindow', 'Could not save file!'),
QCoreApplication.translate('LogWindow', 'Writing failed! Make sure you have write permissions!'))
def initGui(self):
"""startup"""
# run
run_icon = QIcon('%s/%s' % (self.context.ppath,
'images/MetaSearch.png'))
self.action_run = QAction(run_icon, 'MetaSearch',
self.iface.mainWindow())
self.action_run.setWhatsThis(QCoreApplication.translate('MetaSearch',
'MetaSearch plugin'))
self.action_run.setStatusTip(QCoreApplication.translate('MetaSearch',
'Search Metadata Catalogues'))
self.action_run.triggered.connect(self.run)
self.iface.addToolBarIcon(self.action_run)
self.iface.addPluginToWebMenu(self.web_menu, self.action_run)
# help
help_icon = QIcon('%s/%s' % (self.context.ppath, 'images/help.png'))
self.action_help = QAction(help_icon, 'Help', self.iface.mainWindow())
self.action_help.setWhatsThis(QCoreApplication.translate('MetaSearch',
'MetaSearch plugin help'))
self.action_help.setStatusTip(QCoreApplication.translate('MetaSearch',
'Get Help on MetaSearch'))
self.action_help.triggered.connect(self.help)
self.iface.addPluginToWebMenu(self.web_menu, self.action_help)
# prefab the dialog but not open it yet
self.dialog = MetaSearchDialog(self.iface)
def startPlugin(packageName):
""" initialize the plugin """
global plugins, active_plugins, iface
if packageName in active_plugins: return False
package = sys.modules[packageName]
errMsg = QCoreApplication.translate("Python", "Couldn't load plugin %1" ).arg(packageName)
# create an instance of the plugin
try:
plugins[packageName] = package.classFactory(iface)
except:
_unloadPluginModules(packageName)
msg = QCoreApplication.translate("Python", "%1 due an error when calling its classFactory() method").arg(errMsg)
showException(sys.exc_type, sys.exc_value, sys.exc_traceback, msg)
return False
# initGui
try:
plugins[packageName].initGui()
except:
del plugins[packageName]
_unloadPluginModules(packageName)
msg = QCoreApplication.translate("Python", "%1 due an error when calling its initGui() method" ).arg( errMsg )
showException(sys.exc_type, sys.exc_value, sys.exc_traceback, msg)
return False
# add to active plugins
active_plugins.append(packageName)
return True
def tr(text):
"""We define a tr() alias here since the utilities implementation below
is not a class and does not inherit from QObject.
.. note:: see http://tinyurl.com/pyqt-differences
:param text: String to be translated
:type text: str, unicode
:returns: Translated version of the given string if available, otherwise
the original string.
:rtype: str, unicode
"""
# Ensure it's in unicode
text = get_unicode(text)
# noinspection PyCallByClass,PyTypeChecker,PyArgumentList
return QCoreApplication.translate('@default', text)
def saveDialog(parent, filtering="Shapefiles (*.shp *.SHP)"):
settings = QSettings()
dirName = settings.value("/UI/lastShapefileDir")
encode = settings.value("/UI/encoding")
fileDialog = QgsEncodingFileDialog(
parent, QCoreApplication.translate("fTools", "Save output shapefile"),
dirName, filtering, encode)
fileDialog.setDefaultSuffix("shp")
fileDialog.setFileMode(QFileDialog.AnyFile)
fileDialog.setAcceptMode(QFileDialog.AcceptSave)
fileDialog.setConfirmOverwrite(True)
if not fileDialog.exec_() == QDialog.Accepted:
return None, None
files = fileDialog.selectedFiles()
settings.setValue("/UI/lastShapefileDir",
QFileInfo(unicode(files[0])).absolutePath())
return (unicode(files[0]), unicode(fileDialog.encoding()))
def unloadPlugin(packageName):
""" unload and delete plugin! """
global plugins, active_plugins
if not plugins.has_key(packageName): return False
if packageName not in active_plugins: return False
try:
plugins[packageName].unload()
del plugins[packageName]
active_plugins.remove(packageName)
_unloadPluginModules(packageName)
return True
except Exception, e:
msg = QCoreApplication.translate("Python", "Error while unloading plugin %1").arg(packageName)
showException(sys.exc_type, sys.exc_value, sys.exc_traceback, msg)
return False
def sql_load_fr_db(sql, dbconnection=None):
try:
if not isinstance(dbconnection, DbConnectionManager):
dbconnection = DbConnectionManager()
result = dbconnection.execute_and_fetchall(sql)
except Exception as e:
textstring = utils.returnunicode(
QCoreApplication.translate(
u'sql_load_fr_db',
u"""DB error!\n SQL causing this error:%s\nMsg:\n%s""")) % (
utils.returnunicode(sql), utils.returnunicode(str(e)))
utils.MessagebarAndLog.warning(bar_msg=utils.sql_failed_msg(),
log_msg=textstring,
duration=4)
return False, []
else:
return True, result
def switchToolMode(self):
self.setCommandViewerEnabled(not self.batchCheck.isChecked())
self.progressBar.setVisible(self.batchCheck.isChecked())
self.recurseCheck.setVisible(self.batchCheck.isChecked())
self.inSelector.clear()
if self.batchCheck.isChecked():
self.inFileLabel = self.label.text()
self.label.setText(QCoreApplication.translate("GdalTools", "&Input directory"))
QObject.disconnect(self.inSelector, SIGNAL("selectClicked()"), self.fillInputFileEdit)
QObject.connect(self.inSelector, SIGNAL("selectClicked()"), self.fillInputDir)
else:
self.label.setText(self.inFileLabel)
QObject.connect(self.inSelector, SIGNAL("selectClicked()"), self.fillInputFileEdit)
QObject.disconnect(self.inSelector, SIGNAL("selectClicked()"), self.fillInputDir)
def __init__(self, iface):
"""
Constructor
:param iface: interface
"""
QgsMapTool.__init__(self, iface.mapCanvas())
self.__iface = iface
self.__canvas = iface.mapCanvas()
self.__icon_path = ':/plugins/VDLTools/icons/intersect_icon.png'
self.__text = QCoreApplication.translate("VDLTools",
"From intersection")
self.setCursor(Qt.ArrowCursor)
self.__lineLayerID = None
self.__pointLayerID = None
self.__counter = 0
self.__rubber = None
self.__ownSettings = None
self.__isEditing = 0
def contextMenuEvent(self, e):
menu = QMenu(self)
iconRun = QgsApplication.getThemeIcon("console/iconRunConsole.png")
iconClear = QgsApplication.getThemeIcon("console/iconClearConsole.png")
iconHideTool = QgsApplication.getThemeIcon("console/iconHideToolConsole.png")
iconSettings = QgsApplication.getThemeIcon("console/iconSettingsConsole.png")
menu.addAction(iconHideTool,
QCoreApplication.translate("PythonConsole", "Hide/Show Toolbar"),
self.hideToolBar)
menu.addSeparator()
showEditorAction = menu.addAction(
QCoreApplication.translate("PythonConsole", "Show Editor"),
self.showEditor)
menu.addSeparator()
runAction = menu.addAction(iconRun,
QCoreApplication.translate("PythonConsole", "Enter Selected"),
self.enteredSelected,
QKeySequence(Qt.CTRL + Qt.Key_E))
clearAction = menu.addAction(iconClear,
QCoreApplication.translate("PythonConsole", "Clear console"),
self.clearConsole)
menu.addSeparator()
copyAction = menu.addAction(
QCoreApplication.translate("PythonConsole", "Copy"),
self.copy, QKeySequence.Copy)
menu.addSeparator()
selectAllAction = menu.addAction(
QCoreApplication.translate("PythonConsole", "Select All"),
self.selectAll, QKeySequence.SelectAll)
menu.addSeparator()
menu.addAction(iconSettings,
QCoreApplication.translate("PythonConsole", "Settings"),
self.parent.openSettings)
runAction.setEnabled(False)
clearAction.setEnabled(False)
copyAction.setEnabled(False)
selectAllAction.setEnabled(False)
showEditorAction.setEnabled(True)
if self.hasSelectedText():
runAction.setEnabled(True)
copyAction.setEnabled(True)
if not self.text(3) == '':
selectAllAction.setEnabled(True)
clearAction.setEnabled(True)
if self.parent.tabEditorWidget.isVisible():
showEditorAction.setEnabled(False)
menu.exec_(self.mapToGlobal(e.pos()))
def _(s, context=u'script'):
"""
Translates a string of text.
Arguments:
s -- The string to translate.
Keyword arguments:
context -- The translation context. (default=u'script')
Returns:
The translated string.
"""
return str(
QCoreApplication.translate(context,
s,
encoding=QCoreApplication.UnicodeUTF8))
def initGui(self):
"""Create the menu entries and toolbar icons inside the QGIS GUI."""
icon_path = ':/plugins/QuickDigitize/icon.png'
self.add_action(icon_path,
text=self.tr(u'Quick Digitize'),
callback=self.run,
parent=self.iface.mainWindow())
self.settingsAction = QAction(
QCoreApplication.translate("Spline", "Settings"),
self.iface.mainWindow())
self.settingsAction.setObjectName("splineAction")
self.settingsAction.triggered.connect(self.openSettings)
self.iface.addPluginToVectorMenu(u"Digitize Spline",
self.settingsAction)
self.settingsAction.triggered.connect(self.openSettings)
def __init__(self, iface):
"""
Constructor
:param iface: interface
"""
QgsMapTool.__init__(self, iface.mapCanvas())
self.__iface = iface
self.icon_path = ':/plugins/VDLTools/icons/duplicate_icon.png'
self.text = QCoreApplication.translate("VDLTools",
"Duplicate a feature")
self.setCursor(Qt.ArrowCursor)
self.__isEditing = False
self.__layer = None
self.__lastFeatureId = None
self.__selectedFeature = None
self.__rubberBand = None
self.__newFeature = None
self.__dstDlg = None
def handleAlgorithmResults(alg, progress=None, showResults=True):
wrongLayers = []
htmlResults = False
if progress is None:
progress = SilentProgress()
progress.setText(QCoreApplication.translate('Postprocessing', 'Loading resulting layers'))
i = 0
for out in alg.outputs:
progress.setPercentage(100 * i / float(len(alg.outputs)))
if out.hidden or not out.open:
continue
if isinstance(out, (OutputRaster, OutputVector, OutputTable)):
try:
if out.value.startswith('memory:'):
layer = out.memoryLayer
QgsMapLayerRegistry.instance().addMapLayers([layer])
else:
if ProcessingConfig.getSetting(
ProcessingConfig.USE_FILENAME_AS_LAYER_NAME):
name = os.path.basename(out.value)
else:
name = out.description
dataobjects.load(out.value, name, alg.crs,
RenderingStyles.getStyle(alg.commandLineName(),
out.name))
except Exception as e:
wrongLayers.append(out.description)
elif isinstance(out, OutputHTML):
ProcessingResults.addResult(out.description, out.value)
htmlResults = True
i += 1
QApplication.restoreOverrideCursor()
if wrongLayers:
msg = "The following layers were not correctly generated.<ul>"
msg += "".join(["<li>%s</li>" % lay for lay in wrongLayers]) + "</ul>"
msg += "You can check the log messages to find more information about the execution of the algorithm"
progress.error(msg)
if showResults and htmlResults and not wrongLayers:
dlg = ResultsDialog()
dlg.exec_()
return len(wrongLayers) == 0
def __getMasterPassword():
"""
Private module function to get the password from the user.
"""
global MasterPassword
pw, ok = QInputDialog.getText(
None,
QCoreApplication.translate("Crypto", "Master Password"),
QCoreApplication.translate("Crypto", "Enter the master password:"******"MasterPassword")
try:
if masterPassword:
if verifyPassword(pw, masterPassword):
MasterPassword = pwEncode(pw)
else:
E5MessageBox.warning(
None,
QCoreApplication.translate(
"Crypto", "Master Password"),
QCoreApplication.translate(
"Crypto",
"""The given password is incorrect."""))
else:
E5MessageBox.critical(
None,
QCoreApplication.translate("Crypto", "Master Password"),
QCoreApplication.translate(
"Crypto",
"""There is no master password registered."""))
except ValueError as why:
E5MessageBox.warning(
None,
QCoreApplication.translate("Crypto", "Master Password"),
QCoreApplication.translate(
"Crypto",
"""<p>The given password cannot be verified.</p>"""
"""<p>Reason: {0}""".format(str(why))))
def delete_srids(execute_able_object, keep_epsg_code):
if isinstance(execute_able_object, DbConnectionManager):
if not execute_able_object.dbtype == u'spatialite':
return None
delete_srid_sql_aux = r"""delete from spatial_ref_sys_aux where srid NOT IN ('%s', '4326');""" % keep_epsg_code
try:
execute_able_object.execute(delete_srid_sql_aux)
except:
pass
delete_srid_sql = r"""delete from spatial_ref_sys where srid NOT IN ('%s', '4326');""" % keep_epsg_code
try:
execute_able_object.execute(delete_srid_sql)
except:
utils.MessagebarAndLog.info(log_msg=utils.returnunicode(
QCoreApplication.translate(u'delete_srids',
u'Removing srids failed using: %s')) %
str(delete_srid_sql))
def closeAndControl(self):
self.projectFinder.close()
for search in self.projectFinder.searches.values():
if search.dateEvaluated is None:
box = QMessageBox(
QMessageBox.Warning, "Quick Finder",
QCoreApplication.translate(
"Configuration dialog",
"Some searches are still not recorded to the file. Do you want to record them now ? "
),
QMessageBox.Cancel | QMessageBox.Yes | QMessageBox.Close,
self)
ret = box.exec_()
if ret == QMessageBox.Cancel:
return False
elif ret == QMessageBox.Yes:
self.refreshProjectSearch()
return False
return True
def paintEvent(self, event):
""" redraws the whole widget's area """
PyQt4.QtGui.QFrame.paintEvent(self, event)
# check whether there's a survey to show
if len(self.sondaggio) == 0:
p = PyQt4.QtGui.QPainter(self)
p.drawText(
self.rect(),
PyQt4.QtCore.Qt.AlignCenter | PyQt4.QtCore.Qt.AlignVCenter,
ru(
QCoreApplication.translate(u'SurveyWidget',
u"No data to display")))
return
painter = PyQt4.QtGui.QPainter(self)
self.drawSurveys(self.rect(), painter)
def _validateGeometry(self, layer_name, geometry, feature_id):
clean_geometry = self._getCleanGeometry(geometry)
if clean_geometry is None:
self.features_errors.append((
layer_name, feature_id,
QCoreApplication.translate(
'Importer',
'Invalid geometry, maybe all vertices have the same coordinates'
), self._getCentroid(geometry)))
return None
errors = clean_geometry.validateGeometry()
for error in errors:
self.features_errors.append(
(layer_name, feature_id, error.what(), error.where()))
return clean_geometry if len(errors) == 0 else None
def __init__(self, iface):
"""Constructor
:param iface: An interface instance that will be passed to this class
which provides the hook by which you can manipulate the QGIS
application at run time.
:type iface: QgsInterface
"""
# Save reference to the QGIS interface
self.iface = iface
self.mapCanvas = iface.mapCanvas()
self.duplicateTool = None
self.intersectTool = None
self.profileTool = None
self.subProfileTool = None
self.drawdownTool = None
self.pointerTool = None
self.moveTool = None
self.multiAttributesTool = None
self.showSettings = None
self.rebuildIndex = None
self.controlTool = None
if VDLTools.MORE_TOOLS:
self.importMeasures = None
# initialize plugin directory
self.plugin_dir = os.path.dirname(__file__)
# initialize locale
locale = QSettings().value('locale/userLocale')[0:2]
locale_path = os.path.join(self.plugin_dir, 'i18n',
'VDLTools_{}.qm'.format(locale))
if os.path.exists(locale_path):
self.translator = QTranslator()
self.translator.load(locale_path)
if qVersion() > '4.3.3':
QCoreApplication.installTranslator(self.translator)
# Declare instance attributes
self.actions = []
self.menu = QCoreApplication.translate("VDLTools", "&VDL Tools")
self.toolbar = self.iface.addToolBar("VDLTools")
self.toolbar.setObjectName("VDLTools")
def openScriptFile(self):
lastDirPath = self.settings.value("pythonConsole/lastDirPath", "")
openFileTr = QCoreApplication.translate("PythonConsole", "Open File")
fileList = QFileDialog.getOpenFileNames(self, openFileTr, lastDirPath,
"Script file (*.py)")
if fileList:
for pyFile in fileList:
for i in range(self.tabEditorWidget.count()):
tabWidget = self.tabEditorWidget.widget(i)
if tabWidget.path == pyFile:
self.tabEditorWidget.setCurrentWidget(tabWidget)
break
else:
tabName = QFileInfo(pyFile).fileName()
self.tabEditorWidget.newTabEditor(tabName, pyFile)
lastDirPath = QFileInfo(pyFile).path()
self.settings.setValue("pythonConsole/lastDirPath", pyFile)
self.updateTabListScript(pyFile, action='append')
def popupError(self, error=None, url=None):
"""Popups an Error message bar for network errors."""
disambiguation = self.tr_disambiguation[self.resourceType]
widget = iface.messageBar().createMessage(
self.tr('Connection problem', disambiguation),
self.tr('Could not connect to scripts/models repository',
disambiguation))
if error and url:
QgsMessageLog.logMessage(
self.tr(u"Network error code: {} on URL: {}").format(
error, url), u"Processing", QgsMessageLog.CRITICAL)
button = QPushButton(QCoreApplication.translate(
"Python", "View message log"),
pressed=show_message_log)
widget.layout().addWidget(button)
iface.messageBar().pushWidget(widget,
level=QgsMessageBar.CRITICAL,
duration=5)
def __init__(self, filename, parent=None):
'''
Constructor.
'''
super(ImportDxfDialog, self).__init__(parent)
Importer.__init__(self, filename)
# Set up the user interface from Designer.
# After setupUI you can access any designer object by doing
# self.<objectname>, and you can use autoconnect slots - see
# http://qt-project.org/doc/qt-4.8/designer-using-a-ui-file.html
# #widgets-and-dialogs-with-auto-connect
self.setupUi(self)
# Filename
self.lblFilename.setText(filename)
# Setup tables
self.tabLayersMapping.setHorizontalHeaderLabels([
QCoreApplication.translate('ImportDxfDialog', 'DXF Layer'),
QCoreApplication.translate('ImportDxfDialog', 'QGIS Layer'),
QCoreApplication.translate('ImportDxfDialog', 'Enabled')
])
self.tabLayersMapping.setColumnWidth(0, 460)
self.tabLayersMapping.setColumnWidth(1, 200)
self.tabFieldsMapping.setHorizontalHeaderLabels([
QCoreApplication.translate('ImportDxfDialog', 'QGIS Field'),
QCoreApplication.translate('ImportDxfDialog', 'Value'),
QCoreApplication.translate('ImportDxfDialog', 'Enabled')
])
self.tabFieldsMapping.setColumnWidth(0, 200)
self.tabFieldsMapping.setColumnWidth(1, 460)
# Load dxf layers
self._loadDxfLayers(filename)
# If DXF is not valid, return
if not self.valid:
return
# Don't trigger events if loading from config file
self.is_loading_mapping = False
# Load the QGIS layers
self._loadQgisLayers()
# Load the default mapping
self.mapping = Mapping()
self._loadLayersMapping()
def __checkIfExist(self):
"""
To check if the data we want to import is already in the table
"""
if self.__iter < len(self.__data):
data = self.__data[self.__iter]
# check if already in table
query = self.__db.exec_(
"""SELECT ST_AsText(geometry3d) FROM %s.%s WHERE st_dwithin('%s', geometry3d, 0.03)"""
% (data['schema_table'], data['name_table'], data['geom']))
if query.lastError().isValid():
self.__iface.messageBar().pushMessage(
query.lastError().text(),
level=QgsMessageBar.CRITICAL,
duration=0)
else:
in_base = False
point = None
while next(query):
point = query.value(0)
in_base = True
if in_base:
self.__data[self.__iter]['point'] = point
self.__confDlg = ImportConfirmDialog()
self.__confDlg.setMessage(
QCoreApplication.translate(
"VDLTools", "There is already a " + point +
" in table " + data['schema_table'] + """.""" +
data['name_table'] +
".\n Would you like to add it anyway ? "))
self.__confDlg.rejected.connect(self.__cancelAndNext)
self.__confDlg.accepted.connect(self.__confirmAndNext)
self.__confDlg.okButton().clicked.connect(
self.__onConfirmOk)
self.__confDlg.cancelButton().clicked.connect(
self.__onConfirmCancel)
self.__confDlg.show()
else:
self.__confirmAndNext()
else:
self.__insert()
def asPolygonV2(geometry, iface):
"""
To get the feature geometry from a polygon as a QgsCurvePolygonV2
:param geometry: the feature geometry
:param iface: interface
:return: the polygon as QgsCurvePolygonV2 , and true if it has curves or false if it hasn't, or none
"""
wktPolygon = geometry.exportToWkt()
curved = []
if wktPolygon.startswith('PolygonZ'):
polygon = wktPolygon.replace('PolygonZ', '')
elif wktPolygon.startswith('Polygon'):
polygon = wktPolygon.replace('Polygon', '')
elif wktPolygon.startswith('CurvePolygonZ'):
polygon = wktPolygon.replace('CurvePolygonZ', '')
elif wktPolygon.startswith('CurvePolygon'):
polygon = wktPolygon.replace('CurvePolygon', '')
else:
iface.messageBar().pushMessage(
QCoreApplication.translate("VDLTools", "This geometry is not yet implemented"),
level=QgsMessageBar.WARNING)
return None
polygon = polygon.strip()[1:-1]
lines = polygon.split('),')
polygonV2 = QgsCurvePolygonV2()
for i in range(0, len(lines)):
line = lines[i]
if line.startswith('CircularStringZ'):
curved.append(True)
line = line.replace('CircularStringZ', '')
elif line.startswith('CircularString'):
curved.append(True)
line = line.replace('CircularString', '')
else:
curved.append(False)
line = line.strip()[1:-1]
if i == 0:
polygonV2.setExteriorRing(GeometryV2.__createLine(line.split(','), curved[i]))
else:
polygonV2.addInteriorRing(GeometryV2.__createLine(line.split(','), curved[i]))
return polygonV2, curved
def populateModel(self, serverList):
"""
Called after the model is initialized. Adds the servers to the root.
"""
self.rootItem = RootTreeItem("Servere",
None) # Also provides the header
if not len(serverList.getTable()) > 0:
# If there's no servers :(
self.rootItem.appendChild(
LDAPErrorItem(
QCoreApplication.translate("LDAPTreeItemModel",
"No servers defined"), None,
self.rootItem))
return
for server in serverList.getTable():
tmp = ServerTreeItem([server.name], server, self.rootItem)
self.rootItem.appendChild(tmp)
def __init__(self, iface):
"""
Constructor
:param iface: interface
"""
self.__iface = iface
self.icon_path = ':/plugins/VDLTools/icons/settings_icon.png'
self.text = QCoreApplication.translate("VDLTools", "Settings")
self.__showDlg = None
self.__ctlDb = None
self.__configTable = None
self.__uriDb = None
self.__schemaDb = None
self.__memoryPointsLayer = None
self.__memoryLinesLayer = None
self.__mntUrl = None
self.__project_loaded()
QgsProject.instance().readProject.connect(self.__project_loaded)
self.__linesLayer = None
self.__fieldnames = None
def __init__(self, iface):
"""
Constructor
:param iface: interface
"""
QgsMapTool.__init__(self, iface.mapCanvas())
self.__iface = iface
self.icon_path = ':/plugins/VDLTools/icons/profile_2_icon.png'
self.text = QCoreApplication.translate("VDLTools",
"Line for MNT profile")
self.setCursor(Qt.ArrowCursor)
self.__isSelected = False
self.__dockWdg = None
self.__rubberLine = None
self.__rubberDots = None
self.ownSettings = None
self.__line = None
self.__startVertex = None
self.__isfloating = False
self.__dockGeom = None
def ask_and_update_settings(self,
objects_with_get_settings,
settingskey,
msg=''):
old_string = utils.anything_to_string_representation(
self.update_stored_settings(objects_with_get_settings))
new_string = PyQt4.QtGui.QInputDialog.getText(
None,
ru(
QCoreApplication.translate(u'ExportToFieldLogger',
"Edit settings string")), msg,
PyQt4.QtGui.QLineEdit.Normal, old_string)
if not new_string[1]:
return False
new_string_text = ru(new_string[0])
self.update_settings(new_string_text, settingskey)
def __init__(self, iface):
"""
Constructor
:param iface: interface
"""
QgsMapTool.__init__(self, iface.mapCanvas())
self.__iface = iface
self.icon_path = ':/plugins/VDLTools/icons/extrapolate_icon.png'
self.text = QCoreApplication.translate(
"VDLTools", "Extrapolate the elevation of a vertex and a "
"point at the extremity of a line")
self.__layer = None
self.setCursor(Qt.ArrowCursor)
self.__isEditing = False
self.__lastFeatureId = None
self.__rubber = None
self.__confDlg = None
self.__selectedVertex = None
self.__elevation = None
self.__selectedFeature = None
def test_qgis_translations(self):
"""Test that translations work."""
parent_path = os.path.join(__file__, os.path.pardir, os.path.pardir)
dir_path = os.path.abspath(parent_path)
file_path = os.path.join(dir_path, 'i18n', 'af.qm')
translator = QTranslator()
translator.load(file_path)
QCoreApplication.installTranslator(translator)
expected_message = 'Goeie more'
real_message = QCoreApplication.translate("@default", 'Good morning')
self.assertEqual(real_message, expected_message)
def __init__(self, parent=None):
QDockWidget.__init__(self, parent)
self.setObjectName("IPython Console")
self.setWindowTitle(
QCoreApplication.translate("IPython Console", "IPython Console"))
self.setAllowedAreas(Qt.BottomDockWidgetArea)
self.container = QWidget()
self.layout = QVBoxLayout(self.container)
self.kernel_manager = QtKernelManager()
self.kernel_manager.start_kernel()
self.kernel_manager.start_channels()
self.console = IPythonWidget(local_kernel=LOCALHOST)
self.console.kernel_manager = self.kernel_manager
print dir(self.console)
self.layout.addWidget(self.console)
self.setWidget(self.container)
def setConnection(self):
"""
To set a connection to the initialized database
:return: database connection
"""
db = QSqlDatabase.addDatabase('QPSQL')
db.setHostName(self.__host)
db.setDatabaseName(self.__dbName)
db.setUserName(self.__username)
db.setPassword(self.__pwd)
db.setPort(int(self.__port))
ok = db.open()
if not ok:
self.__iface.messageBar().pushMessage(
QCoreApplication.translate("VDLNetwork", "Database Error: ") +
db.lastError().text(),
level=QgsMessageBar.CRITICAL,
duration=0)
return None
return db
