sharpetronics/QGIS
1
0
Fork 0
mirror of https://github.com/qgis/QGIS.git synced 2025-02-25 00:58:06 -05:00
Code Issues Packages Projects Releases Wiki Activity

GdalTools: new style signals

Browse Source
This commit is contained in:
Juergen E. Fischer 2016-03-21 04:54:20 +01:00
parent c55f8b73f0
commit 9db908ccbc
52 changed files with 608 additions and 610 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

99
python/plugins/GdalTools/GdalTools.py
View File

@ -18,8 +18,9 @@ email : lorenxo86@gmail.com
***************************************************************************/
"""
# Import the PyQt and QGIS libraries
from PyQt4.QtCore import QObject, QCoreApplication, QSettings, QLocale, QFileInfo, QTranslator, SIGNAL
from PyQt4.QtGui import QMessageBox, QMenu, QIcon, QAction
from PyQt.QtCore import QCoreApplication, QSettings, QLocale, QFileInfo, QTranslator
from PyQt.QtWidgets import QMessageBox, QMenu, QAction
from PyQt.QtGui import QIcon
from qgis.core import QGis
import qgis.utils
@ -29,8 +30,8 @@ valid = True
# Import required modules
req_mods = {"osgeo": "osgeo [python-gdal]"}
try:
from osgeo import gdal
from osgeo import ogr
from osgeo import gdal # NOQA
from osgeo import ogr # NOQA
except ImportError as e:
valid = False
@ -100,7 +101,7 @@ class GdalTools:
+ QCoreApplication.translate("GdalTools", "This version of Gdal Tools requires at least QGIS version 1.0.0\nPlugin will not be enabled."))
return None
from tools.GdalTools_utils import GdalConfig, LayerRegistry
from .tools.GdalTools_utils import GdalConfig, LayerRegistry
self.GdalVersionNum = GdalConfig.versionNum()
LayerRegistry.setIface(self.iface)
@ -132,17 +133,17 @@ class GdalTools:
self.warp = QAction(QIcon(":/icons/warp.png"), QCoreApplication.translate("GdalTools", "Warp (Reproject)..."), self.iface.mainWindow())
self.warp.setObjectName("warp")
self.warp.setStatusTip(QCoreApplication.translate("GdalTools", "Warp an image into a new coordinate system"))
QObject.connect(self.warp, SIGNAL("triggered()"), self.doWarp)
self.warp.triggered.connect(self.doWarp)
self.projection = QAction(QIcon(":icons/projection-add.png"), QCoreApplication.translate("GdalTools", "Assign Projection..."), self.iface.mainWindow())
self.projection.setObjectName("projection")
self.projection.setStatusTip(QCoreApplication.translate("GdalTools", "Add projection info to the raster"))
QObject.connect(self.projection, SIGNAL("triggered()"), self.doProjection)
self.projection.triggered.connect(self.doProjection)
self.extractProj = QAction(QIcon(":icons/projection-export.png"), QCoreApplication.translate("GdalTools", "Extract Projection..."), self.iface.mainWindow())
self.extractProj.setObjectName("extractProj")
self.extractProj.setStatusTip(QCoreApplication.translate("GdalTools", "Extract projection information from raster(s)"))
QObject.connect(self.extractProj, SIGNAL("triggered()"), self.doExtractProj)
self.extractProj.triggered.connect(self.doExtractProj)
self.projectionsMenu.addActions([self.warp, self.projection, self.extractProj])
@ -154,30 +155,30 @@ class GdalTools:
self.rasterize = QAction(QIcon(":/icons/rasterize.png"), QCoreApplication.translate("GdalTools", "Rasterize (Vector to Raster)..."), self.iface.mainWindow())
self.rasterize.setObjectName("rasterize")
self.rasterize.setStatusTip(QCoreApplication.translate("GdalTools", "Burns vector geometries into a raster"))
QObject.connect(self.rasterize, SIGNAL("triggered()"), self.doRasterize)
self.rasterize.triggered.connect(self.doRasterize)
self.conversionMenu.addAction(self.rasterize)
if self.GdalVersionNum >= 1600:
self.polygonize = QAction(QIcon(":/icons/polygonize.png"), QCoreApplication.translate("GdalTools", "Polygonize (Raster to Vector)..."), self.iface.mainWindow())
self.polygonize.setObjectName("polygonize")
self.polygonize.setStatusTip(QCoreApplication.translate("GdalTools", "Produces a polygon feature layer from a raster"))
QObject.connect(self.polygonize, SIGNAL("triggered()"), self.doPolygonize)
self.polygonize.triggered.connect(self.doPolygonize)
self.conversionMenu.addAction(self.polygonize)
self.translate = QAction(QIcon(":/icons/translate.png"), QCoreApplication.translate("GdalTools", "Translate (Convert Format)..."), self.iface.mainWindow())
self.translate.setObjectName("translate")
self.translate.setStatusTip(QCoreApplication.translate("GdalTools", "Converts raster data between different formats"))
QObject.connect(self.translate, SIGNAL("triggered()"), self.doTranslate)
self.translate.triggered.connect(self.doTranslate)
self.paletted = QAction(QIcon(":icons/24-to-8-bits.png"), QCoreApplication.translate("GdalTools", "RGB to PCT..."), self.iface.mainWindow())
self.paletted.setObjectName("paletted")
self.paletted.setStatusTip(QCoreApplication.translate("GdalTools", "Convert a 24bit RGB image to 8bit paletted"))
QObject.connect(self.paletted, SIGNAL("triggered()"), self.doPaletted)
self.paletted.triggered.connect(self.doPaletted)
self.rgb = QAction(QIcon(":icons/8-to-24-bits.png"), QCoreApplication.translate("GdalTools", "PCT to RGB..."), self.iface.mainWindow())
self.rgb.setObjectName("rgb")
self.rgb.setStatusTip(QCoreApplication.translate("GdalTools", "Convert an 8bit paletted image to 24bit RGB"))
QObject.connect(self.rgb, SIGNAL("triggered()"), self.doRGB)
self.rgb.triggered.connect(self.doRGB)
self.conversionMenu.addActions([self.translate, self.paletted, self.rgb])
@ -189,13 +190,13 @@ class GdalTools:
self.contour = QAction(QIcon(":/icons/contour.png"), QCoreApplication.translate("GdalTools", "Contour..."), self.iface.mainWindow())
self.contour.setObjectName("contour")
self.contour.setStatusTip(QCoreApplication.translate("GdalTools", "Builds vector contour lines from a DEM"))
QObject.connect(self.contour, SIGNAL("triggered()"), self.doContour)
self.contour.triggered.connect(self.doContour)
self.extractionMenu.addAction(self.contour)
self.clipper = QAction(QIcon(":icons/raster-clip.png"), QCoreApplication.translate("GdalTools", "Clipper..."), self.iface.mainWindow())
self.clipper.setObjectName("clipper")
#self.clipper.setStatusTip( QCoreApplication.translate( "GdalTools", "Converts raster data between different formats") )
QObject.connect(self.clipper, SIGNAL("triggered()"), self.doClipper)
self.clipper.triggered.connect(self.doClipper)
self.extractionMenu.addActions([self.clipper])
@ -207,42 +208,42 @@ class GdalTools:
self.sieve = QAction(QIcon(":/icons/sieve.png"), QCoreApplication.translate("GdalTools", "Sieve..."), self.iface.mainWindow())
self.sieve.setObjectName("sieve")
self.sieve.setStatusTip(QCoreApplication.translate("GdalTools", "Removes small raster polygons"))
QObject.connect(self.sieve, SIGNAL("triggered()"), self.doSieve)
self.sieve.triggered.connect(self.doSieve)
self.analysisMenu.addAction(self.sieve)
if self.GdalVersionNum >= 1500:
self.nearBlack = QAction(QIcon(":/icons/nearblack.png"), QCoreApplication.translate("GdalTools", "Near Black..."), self.iface.mainWindow())
self.nearBlack.setObjectName("nearBlack")
self.nearBlack.setStatusTip(QCoreApplication.translate("GdalTools", "Convert nearly black/white borders to exact value"))
QObject.connect(self.nearBlack, SIGNAL("triggered()"), self.doNearBlack)
self.nearBlack.triggered.connect(self.doNearBlack)
self.analysisMenu.addAction(self.nearBlack)
if self.GdalVersionNum >= 1700:
self.fillNodata = QAction(QIcon(":/icons/fillnodata.png"), QCoreApplication.translate("GdalTools", "Fill nodata..."), self.iface.mainWindow())
self.fillNodata.setObjectName("fillNodata")
self.fillNodata.setStatusTip(QCoreApplication.translate("GdalTools", "Fill raster regions by interpolation from edges"))
QObject.connect(self.fillNodata, SIGNAL("triggered()"), self.doFillNodata)
self.fillNodata.triggered.connect(self.doFillNodata)
self.analysisMenu.addAction(self.fillNodata)
if self.GdalVersionNum >= 1600:
self.proximity = QAction(QIcon(":/icons/proximity.png"), QCoreApplication.translate("GdalTools", "Proximity (Raster Distance)..."), self.iface.mainWindow())
self.proximity.setObjectName("proximity")
self.proximity.setStatusTip(QCoreApplication.translate("GdalTools", "Produces a raster proximity map"))
QObject.connect(self.proximity, SIGNAL("triggered()"), self.doProximity)
self.proximity.triggered.connect(self.doProximity)
self.analysisMenu.addAction(self.proximity)
if self.GdalVersionNum >= 1500:
self.grid = QAction(QIcon(":/icons/grid.png"), QCoreApplication.translate("GdalTools", "Grid (Interpolation)..."), self.iface.mainWindow())
self.grid.setObjectName("grid")
self.grid.setStatusTip(QCoreApplication.translate("GdalTools", "Create raster from the scattered data"))
QObject.connect(self.grid, SIGNAL("triggered()"), self.doGrid)
self.grid.triggered.connect(self.doGrid)
self.analysisMenu.addAction(self.grid)
if self.GdalVersionNum >= 1700:
self.dem = QAction(QIcon(":icons/dem.png"), QCoreApplication.translate("GdalTools", "DEM (Terrain Models)..."), self.iface.mainWindow())
self.dem.setObjectName("dem")
self.dem.setStatusTip(QCoreApplication.translate("GdalTools", "Tool to analyze and visualize DEMs"))
QObject.connect(self.dem, SIGNAL("triggered()"), self.doDEM)
self.dem.triggered.connect(self.doDEM)
self.analysisMenu.addAction(self.dem)
#self.analysisMenu.addActions( [ ] )
@ -255,28 +256,28 @@ class GdalTools:
self.buildVRT = QAction(QIcon(":/icons/vrt.png"), QCoreApplication.translate("GdalTools", "Build Virtual Raster (Catalog)..."), self.iface.mainWindow())
self.buildVRT.setObjectName("buildVRT")
self.buildVRT.setStatusTip(QCoreApplication.translate("GdalTools", "Builds a VRT from a list of datasets"))
QObject.connect(self.buildVRT, SIGNAL("triggered()"), self.doBuildVRT)
self.buildVRT.triggered.connect(self.doBuildVRT)
self.miscellaneousMenu.addAction(self.buildVRT)
self.merge = QAction(QIcon(":/icons/merge.png"), QCoreApplication.translate("GdalTools", "Merge..."), self.iface.mainWindow())
self.merge.setObjectName("merge")
self.merge.setStatusTip(QCoreApplication.translate("GdalTools", "Build a quick mosaic from a set of images"))
QObject.connect(self.merge, SIGNAL("triggered()"), self.doMerge)
self.merge.triggered.connect(self.doMerge)
self.info = QAction(QIcon(":/icons/raster-info.png"), QCoreApplication.translate("GdalTools", "Information..."), self.iface.mainWindow())
self.info.setObjectName("info")
self.info.setStatusTip(QCoreApplication.translate("GdalTools", "Lists information about raster dataset"))
QObject.connect(self.info, SIGNAL("triggered()"), self.doInfo)
self.info.triggered.connect(self.doInfo)
self.overview = QAction(QIcon(":icons/raster-overview.png"), QCoreApplication.translate("GdalTools", "Build Overviews (Pyramids)..."), self.iface.mainWindow())
self.overview.setObjectName("overview")
self.overview.setStatusTip(QCoreApplication.translate("GdalTools", "Builds or rebuilds overview images"))
QObject.connect(self.overview, SIGNAL("triggered()"), self.doOverview)
self.overview.triggered.connect(self.doOverview)
self.tileindex = QAction(QIcon(":icons/tiles.png"), QCoreApplication.translate("GdalTools", "Tile Index..."), self.iface.mainWindow())
self.tileindex.setObjectName("tileindex")
self.tileindex.setStatusTip(QCoreApplication.translate("GdalTools", "Build a shapefile as a raster tileindex"))
QObject.connect(self.tileindex, SIGNAL("triggered()"), self.doTileIndex)
self.tileindex.triggered.connect(self.doTileIndex)
self.miscellaneousMenu.addActions([self.merge, self.info, self.overview, self.tileindex])
@ -292,7 +293,7 @@ class GdalTools:
self.settings = QAction(QCoreApplication.translate("GdalTools", "GdalTools Settings..."), self.iface.mainWindow())
self.settings.setObjectName("settings")
self.settings.setStatusTip(QCoreApplication.translate("GdalTools", "Various settings for Gdal Tools"))
QObject.connect(self.settings, SIGNAL("triggered()"), self.doSettings)
self.settings.triggered.connect(self.doSettings)
self.menu.addAction(self.settings)
self._menuActions.append(self.settings)
@ -303,107 +304,107 @@ class GdalTools:
self.menu.removeAction(a)
def doBuildVRT(self):
from tools.doBuildVRT import GdalToolsDialog as BuildVRT
from .tools.doBuildVRT import GdalToolsDialog as BuildVRT
d = BuildVRT(self.iface)
self.runToolDialog(d)
def doContour(self):
from tools.doContour import GdalToolsDialog as Contour
from .tools.doContour import GdalToolsDialog as Contour
d = Contour(self.iface)
self.runToolDialog(d)
def doRasterize(self):
from tools.doRasterize import GdalToolsDialog as Rasterize
from .tools.doRasterize import GdalToolsDialog as Rasterize
d = Rasterize(self.iface)
self.runToolDialog(d)
def doPolygonize(self):
from tools.doPolygonize import GdalToolsDialog as Polygonize
from .tools.doPolygonize import GdalToolsDialog as Polygonize
d = Polygonize(self.iface)
self.runToolDialog(d)
def doMerge(self):
from tools.doMerge import GdalToolsDialog as Merge
from .tools.doMerge import GdalToolsDialog as Merge
d = Merge(self.iface)
self.runToolDialog(d)
def doSieve(self):
from tools.doSieve import GdalToolsDialog as Sieve
from .tools.doSieve import GdalToolsDialog as Sieve
d = Sieve(self.iface)
self.runToolDialog(d)
def doProximity(self):
from tools.doProximity import GdalToolsDialog as Proximity
from .tools.doProximity import GdalToolsDialog as Proximity
d = Proximity(self.iface)
self.runToolDialog(d)
def doNearBlack(self):
from tools.doNearBlack import GdalToolsDialog as NearBlack
from .tools.doNearBlack import GdalToolsDialog as NearBlack
d = NearBlack(self.iface)
self.runToolDialog(d)
def doFillNodata(self):
from tools.doFillNodata import GdalToolsDialog as FillNodata
from .tools.doFillNodata import GdalToolsDialog as FillNodata
d = FillNodata(self.iface)
self.runToolDialog(d)
def doWarp(self):
from tools.doWarp import GdalToolsDialog as Warp
from .tools.doWarp import GdalToolsDialog as Warp
d = Warp(self.iface)
self.runToolDialog(d)
def doGrid(self):
from tools.doGrid import GdalToolsDialog as Grid
from .tools.doGrid import GdalToolsDialog as Grid
d = Grid(self.iface)
self.runToolDialog(d)
def doTranslate(self):
from tools.doTranslate import GdalToolsDialog as Translate
from .tools.doTranslate import GdalToolsDialog as Translate
d = Translate(self.iface)
self.runToolDialog(d)
def doInfo(self):
from tools.doInfo import GdalToolsDialog as Info
from .tools.doInfo import GdalToolsDialog as Info
d = Info(self.iface)
self.runToolDialog(d)
def doProjection(self):
from tools.doProjection import GdalToolsDialog as Projection
from .tools.doProjection import GdalToolsDialog as Projection
d = Projection(self.iface)
self.runToolDialog(d)
def doOverview(self):
from tools.doOverview import GdalToolsDialog as Overview
from .tools.doOverview import GdalToolsDialog as Overview
d = Overview(self.iface)
self.runToolDialog(d)
def doClipper(self):
from tools.doClipper import GdalToolsDialog as Clipper
from .tools.doClipper import GdalToolsDialog as Clipper
d = Clipper(self.iface)
self.runToolDialog(d)
def doPaletted(self):
from tools.doRgbPct import GdalToolsDialog as RgbPct
from .tools.doRgbPct import GdalToolsDialog as RgbPct
d = RgbPct(self.iface)
self.runToolDialog(d)
def doRGB(self):
from tools.doPctRgb import GdalToolsDialog as PctRgb
from .tools.doPctRgb import GdalToolsDialog as PctRgb
d = PctRgb(self.iface)
self.runToolDialog(d)
def doTileIndex(self):
from tools.doTileIndex import GdalToolsDialog as TileIndex
from .tools.doTileIndex import GdalToolsDialog as TileIndex
d = TileIndex(self.iface)
self.runToolDialog(d)
def doExtractProj(self):
from tools.doExtractProj import GdalToolsDialog as ExtractProj
from .tools.doExtractProj import GdalToolsDialog as ExtractProj
d = ExtractProj(self.iface)
d.exec_()
def doDEM(self):
from tools.doDEM import GdalToolsDialog as DEM
from .tools.doDEM import GdalToolsDialog as DEM
d = DEM(self.iface)
self.runToolDialog(d)
@ -413,6 +414,6 @@ class GdalTools:
del dlg
def doSettings(self):
from tools.doSettings import GdalToolsSettingsDialog as Settings
from .tools.doSettings import GdalToolsSettingsDialog as Settings
d = Settings(self.iface)
d.exec_()

2
python/plugins/GdalTools/__init__.py
View File

@ -21,5 +21,5 @@ email : lorenxo86@gmail.com - brush.tyler@gmail.com
def classFactory(iface):
# load GdalTools class from file GdalTools
from GdalTools import GdalTools
from .GdalTools import GdalTools
return GdalTools(iface)

21
python/plugins/GdalTools/tools/GdalTools_utils.py
View File

@ -29,8 +29,8 @@ __revision__ = '$Format:%H$'
# setLastUsedDir( QString *file_or_dir path )
# -------------------------------------------------
from PyQt4.QtCore import QObject, QSettings, QFileInfo, SIGNAL, QDir, QCoreApplication
from PyQt4.QtGui import QFileDialog
from PyQt.QtCore import QObject, QSettings, QFileInfo, QDir, QCoreApplication, pyqtSignal
from PyQt.QtWidgets import QFileDialog
from qgis.core import QgsApplication, QgsMapLayerRegistry, QgsRectangle, QgsProviderRegistry, QgsLogger
from qgis.gui import QgsEncodingFileDialog
@ -153,6 +153,7 @@ def getVectorExtensions():
class LayerRegistry(QObject):
layersChanged = pyqtSignal()
_instance = None
_iface = None
@ -176,9 +177,9 @@ class LayerRegistry(QObject):
LayerRegistry.layers = self.getAllLayers()
LayerRegistry._instance = self
self.connect(QgsMapLayerRegistry.instance(), SIGNAL("removeAll()"), self.removeAllLayers)
self.connect(QgsMapLayerRegistry.instance(), SIGNAL("layerWasAdded(QgsMapLayer *)"), self.layerAdded)
self.connect(QgsMapLayerRegistry.instance(), SIGNAL("layerWillBeRemoved(QString)"), self.removeLayer)
QgsMapLayerRegistry.instance().removeAll.connect(self.removeAllLayers)
QgsMapLayerRegistry.instance().layerWasAdded.connect(self.layerAdded)
QgsMapLayerRegistry.instance().layerWillBeRemoved.connect(self.removeLayer)
def getAllLayers(self):
if LayerRegistry._iface and hasattr(LayerRegistry._iface, 'legendInterface'):
@ -187,15 +188,15 @@ class LayerRegistry(QObject):
def layerAdded(self, layer):
LayerRegistry.layers.append(layer)
self.emit(SIGNAL("layersChanged"))
self.layersChanged.emit()
def removeLayer(self, layerId):
LayerRegistry.layers = filter(lambda x: x.id() != layerId, LayerRegistry.layers)
self.emit(SIGNAL("layersChanged"))
LayerRegistry.layers = [x for x in LayerRegistry.layers if x.id() != layerId]
self.layersChanged.emit()
def removeAllLayers(self):
LayerRegistry.layers = []
self.emit(SIGNAL("layersChanged"))
self.layersChanged.emit()
@classmethod
def isRaster(self, layer):
@ -904,7 +905,7 @@ def setProcessEnvironment(process):
envval = os.getenv(name)
if envval is None or envval == "":
envval = unicode(val)
elif (platform.system() == "Windows" and val.lower() not in envval.lower().split( sep )) or \
elif (platform.system() == "Windows" and val.lower() not in envval.lower().split(sep)) or \
(platform.system() != "Windows" and val not in envval.split(sep)):
envval += "%s%s" % (sep, unicode(val))
else:

63
python/plugins/GdalTools/tools/dialogBase.py
View File

@ -23,20 +23,29 @@ __copyright__ = '(C) 2010, Giuseppe Sucameli'
# This will get replaced with a git SHA1 when you do a git archive
__revision__ = '$Format:%H$'
from PyQt4.QtCore import Qt, SIGNAL, QProcess, QUrl, QIODevice, QCoreApplication
from PyQt4.QtGui import QDialog, QIcon, QDialogButtonBox, QMessageBox, QDesktopServices, QErrorMessage, QApplication
from PyQt.QtCore import Qt, QProcess, QUrl, QIODevice, QCoreApplication, pyqtSignal
from PyQt.QtWidgets import QDialog, QDialogButtonBox, QMessageBox, QErrorMessage, QApplication
from PyQt.QtGui import QIcon, QDesktopServices
# to know the os
import platform
from ui_dialogBase import Ui_GdalToolsDialog as Ui_Dialog
import GdalTools_utils as Utils
#from .. import resources_rc
from .ui_dialogBase import Ui_GdalToolsDialog as Ui_Dialog
from . import GdalTools_utils as Utils
from .. import resources_rc # NOQA
import string
class GdalToolsBaseDialog(QDialog, Ui_Dialog):
refreshArgs = pyqtSignal()
okClicked = pyqtSignal()
closeClicked = pyqtSignal()
helpClicked = pyqtSignal()
processError = pyqtSignal(QProcess.ProcessError)
processFinished = pyqtSignal(int, QProcess.ExitStatus)
finished = pyqtSignal(bool)
valuesChanged = pyqtSignal(list)
def __init__(self, parent, iface, pluginBase, pluginName, pluginCommand):
QDialog.__init__(self, parent)
@ -45,26 +54,26 @@ class GdalToolsBaseDialog(QDialog, Ui_Dialog):
self.process = QProcess(self)
Utils.setProcessEnvironment(self.process)
self.connect(self.process, SIGNAL("error(QProcess::ProcessError)"), self.processError)
self.connect(self.process, SIGNAL("finished(int, QProcess::ExitStatus)"), self.processFinished)
self.process.error.connect(self.processError)
self.process.finished.connect(self.processFinished)
self.setupUi(self)
self.arguments = []
self.editCmdBtn.setIcon(QIcon(":/icons/edit.png"))
self.connect(self.editCmdBtn, SIGNAL("toggled(bool)"), self.editCommand)
self.editCmdBtn.toggled.connect(self.editCommand)
self.resetCmdBtn.setIcon(QIcon(":/icons/reset.png"))
self.connect(self.resetCmdBtn, SIGNAL("clicked()"), self.resetCommand)
self.resetCmdBtn.clicked.connect(self.resetCommand)
self.editCommand(False)
self.connect(self.buttonBox, SIGNAL("rejected()"), self.reject)
self.connect(self.buttonBox, SIGNAL("accepted()"), self.accept)
self.connect(self.buttonBox, SIGNAL("helpRequested()"), self.help)
self.buttonBox.rejected.connect(self.reject)
self.buttonBox.accepted.connect(self.accept)
self.buttonBox.helpRequested.connect(self.help)
self.buttonBox.button(QDialogButtonBox.Ok).setDefault(True)
self.plugin = pluginBase
self.connect(self.plugin, SIGNAL("valuesChanged(PyQt_PyObject)"), self.refreshArgs)
self.valuesChanged.connect(self.handleRefreshArgs)
self.pluginLayout.addWidget(self.plugin)
self.plugin.setFocus()
@ -91,12 +100,12 @@ class GdalToolsBaseDialog(QDialog, Ui_Dialog):
self.resetCmdBtn.setEnabled(enabled)
self.textEditCommand.setReadOnly(not enabled)
self.controlsWidget.setEnabled(not enabled)
self.emit(SIGNAL("refreshArgs()"))
self.refreshArgs.emit()
def resetCommand(self):
if not self.commandIsEditable():
return
self.emit(SIGNAL("refreshArgs()"))
self.refreshArgs.emit()
def commandIsEditable(self):
return self.commandIsEnabled() and self.editCmdBtn.isChecked()
@ -115,22 +124,16 @@ class GdalToolsBaseDialog(QDialog, Ui_Dialog):
if ret == QMessageBox.No:
return
self.disconnect(self.process, SIGNAL("error(QProcess::ProcessError)"), self.processError)
self.disconnect(self.process, SIGNAL("finished(int, QProcess::ExitStatus)"), self.processFinished)
self.process.error.disconnect(self.processError)
self.process.finished.disconnect(self.processFinished)
self.emit(SIGNAL("closeClicked()"))
self.closeClicked.emit()
def accept(self):
self.emit(SIGNAL("okClicked()"))
self.okClicked.emit()
def help(self):
self.emit(SIGNAL("helpClicked()"))
def processError(self, error):
self.emit(SIGNAL("processError(QProcess::ProcessError)"), error)
def processFinished(self, exitCode, status):
self.emit(SIGNAL("processFinished(int, QProcess::ExitStatus)"), exitCode, status)
self.helpClicked.emit()
# show the online tool documentation in the default browser
def onHelp(self):
@ -142,7 +145,7 @@ class GdalToolsBaseDialog(QDialog, Ui_Dialog):
QDesktopServices.openUrl(url)
# called when a value in the plugin widget interface changed
def refreshArgs(self, args):
def handleRefreshArgs(self, args):
self.arguments = [unicode(a) for a in args]
if not self.commandIsEnabled():
@ -185,7 +188,7 @@ class GdalToolsBaseDialog(QDialog, Ui_Dialog):
msg = QCoreApplication.translate("GdalTools", "An unknown error occurred.")
QErrorMessage(self).showMessage(msg)
QApplication.processEvents() # give the user chance to see the message
QApplication.processEvents() # give the user chance to see the message
self.stop()
@ -197,7 +200,7 @@ class GdalToolsBaseDialog(QDialog, Ui_Dialog):
return
if self.command.find("gdalinfo") != -1 and exitCode == 0:
self.emit(SIGNAL("finished(bool)"), self.loadCheckBox.isChecked())
self.finished.emit(self.loadCheckBox.isChecked())
self.stop()
return
@ -226,6 +229,6 @@ class GdalToolsBaseDialog(QDialog, Ui_Dialog):
QErrorMessage(self).showMessage(msg.replace("\n", "<br>"))
if exitCode == 0:
self.emit(SIGNAL("finished(bool)"), self.loadCheckBox.isChecked())
self.finished.emit(self.loadCheckBox.isChecked())
self.stop()

2
python/plugins/GdalTools/tools/dialogExtractProjection.ui
View File

@ -75,7 +75,7 @@
<customwidget>
<class>GdalToolsInOutSelector</class>
<extends>QWidget</extends>
<header>inOutSelector</header>
<header>.inOutSelector</header>
<container>1</container>
</customwidget>
</customwidgets>

7
python/plugins/GdalTools/tools/dialogSRS.py
View File

@ -23,8 +23,7 @@ __copyright__ = '(C) 2010, Giuseppe Sucameli'
# This will get replaced with a git SHA1 when you do a git archive
__revision__ = '$Format:%H$'
from PyQt4.QtCore import SIGNAL
from PyQt4.QtGui import QDialog, QVBoxLayout, QDialogButtonBox
from PyQt.QtWidgets import QDialog, QVBoxLayout, QDialogButtonBox
from qgis.gui import QgsProjectionSelector
@ -42,8 +41,8 @@ class GdalToolsSRSDialog(QDialog):
layout.addWidget(buttonBox)
self.setLayout(layout)
self.connect(buttonBox, SIGNAL("accepted()"), self.accept)
self.connect(buttonBox, SIGNAL("rejected()"), self.reject)
buttonBox.accepted.connect(self.accept)
buttonBox.rejected.connect(self.reject)
def authid(self):
return unicode(self.selector.selectedAuthId())

56
python/plugins/GdalTools/tools/doBuildVRT.py
View File

@ -23,13 +23,13 @@ __copyright__ = '(C) 2010, Giuseppe Sucameli'
# This will get replaced with a git SHA1 when you do a git archive
__revision__ = '$Format:%H$'
from PyQt4.QtCore import SIGNAL, QCoreApplication, QObject
from PyQt4.QtGui import QWidget
from PyQt.QtCore import QCoreApplication
from PyQt.QtWidgets import QWidget
from ui_widgetBuildVRT import Ui_GdalToolsWidget as Ui_Widget
from widgetPluginBase import GdalToolsBasePluginWidget as BasePluginWidget
from dialogSRS import GdalToolsSRSDialog as SRSDialog
import GdalTools_utils as Utils
from .ui_widgetBuildVRT import Ui_GdalToolsWidget as Ui_Widget
from .widgetPluginBase import GdalToolsBasePluginWidget as BasePluginWidget
from .dialogSRS import GdalToolsSRSDialog as SRSDialog
from . import GdalTools_utils as Utils
class GdalToolsDialog(QWidget, Ui_Widget, BasePluginWidget):
@ -49,35 +49,35 @@ class GdalToolsDialog(QWidget, Ui_Widget, BasePluginWidget):
self.setParamsStatus(
[
(self.inSelector, SIGNAL("filenameChanged()")),
(self.outSelector, SIGNAL("filenameChanged()")),
(self.resolutionComboBox, SIGNAL("currentIndexChanged(int)"), self.resolutionCheck),
(self.noDataEdit, SIGNAL("textChanged( const QString & )"), self.srcNoDataCheck, 1700),
(self.inputDirCheck, SIGNAL("stateChanged(int)")),
(self.separateCheck, SIGNAL("stateChanged(int)"), None, 1700),
(self.targetSRSEdit, SIGNAL("textChanged(const QString &)"), self.targetSRSCheck),
(self.allowProjDiffCheck, SIGNAL("stateChanged(int)"), None, 1700),
(self.recurseCheck, SIGNAL("stateChanged(int)"), self.inputDirCheck),
(self.inputSelLayersCheck, SIGNAL("stateChanged(int)"))
(self.inSelector, "filenameChanged"),
(self.outSelector, "filenameChanged"),
(self.resolutionComboBox, "currentIndexChanged", self.resolutionCheck),
(self.noDataEdit, "textChanged", self.srcNoDataCheck, 1700),
(self.inputDirCheck, "stateChanged"),
(self.separateCheck, "stateChanged", None, 1700),
(self.targetSRSEdit, "textChanged", self.targetSRSCheck),
(self.allowProjDiffCheck, "stateChanged", None, 1700),
(self.recurseCheck, "stateChanged", self.inputDirCheck),
(self.inputSelLayersCheck, "stateChanged")
]
)
self.connect(self.inSelector, SIGNAL("selectClicked()"), self.fillInputFilesEdit)
self.connect(self.outSelector, SIGNAL("selectClicked()"), self.fillOutputFileEdit)
self.connect(self.inputDirCheck, SIGNAL("stateChanged( int )"), self.switchToolMode)
self.connect(self.inputSelLayersCheck, SIGNAL("stateChanged( int )"), self.switchLayerMode)
self.connect(self.iface.mapCanvas(), SIGNAL("stateChanged( int )"), self.switchLayerMode)
self.connect(self.selectTargetSRSButton, SIGNAL("clicked()"), self.fillTargetSRSEdit)
self.inSelector.selectClicked.connect(self.fillInputFilesEdit)
self.outSelector.selectClicked.connect(self.fillOutputFileEdit)
self.inputDirCheck.stateChanged.connect(self.switchToolMode)
self.inputSelLayersCheck.stateChanged.connect(self.switchLayerMode)
self.iface.mapCanvas().layersChanged.connect(self.switchLayerMode)
self.selectTargetSRSButton.clicked.connect(self.fillTargetSRSEdit)
def initialize(self):
# connect to mapCanvas.layerChanged() signal
self.connect(self.iface.mapCanvas(), SIGNAL("layersChanged()"), self.onVisibleLayersChanged)
self.iface.mapCanvas().layersChanged.connect(self.onVisibleLayersChanged)
self.onVisibleLayersChanged()
BasePluginWidget.initialize(self)
def onClosing(self):
# disconnect from mapCanvas.layerChanged() signal
self.disconnect(self.iface.mapCanvas(), SIGNAL("layersChanged()"), self.onVisibleLayersChanged)
self.iface.mapCanvas().layersChanged.disconnect(self.onVisibleLayersChanged)
BasePluginWidget.onClosing(self)
def onVisibleLayersChanged(self):
@ -98,13 +98,13 @@ class GdalToolsDialog(QWidget, Ui_Widget, BasePluginWidget):
self.inFileLabel = self.label.text()
self.label.setText(QCoreApplication.translate("GdalTools", "&Input directory"))
QObject.disconnect(self.inSelector, SIGNAL("selectClicked()"), self.fillInputFilesEdit)
QObject.connect(self.inSelector, SIGNAL("selectClicked()"), self.fillInputDir)
self.inSelector.selectClicked.disconnect(self.fillInputFilesEdit)
self.inSelector.selectClicked.connect(self.fillInputDir)
else:
self.label.setText(self.inFileLabel)
QObject.connect(self.inSelector, SIGNAL("selectClicked()"), self.fillInputFilesEdit)
QObject.disconnect(self.inSelector, SIGNAL("selectClicked()"), self.fillInputDir)
self.inSelector.selectClicked.connect(self.fillInputFilesEdit)
self.inSelector.selectClicked.disconnect(self.fillInputDir)
def switchLayerMode(self):
enableInputFiles = not self.inputSelLayersCheck.isChecked()

43
python/plugins/GdalTools/tools/doClipper.py
View File

@ -23,13 +23,12 @@ __copyright__ = '(C) 2010, Giuseppe Sucameli'
# This will get replaced with a git SHA1 when you do a git archive
__revision__ = '$Format:%H$'
from PyQt4.QtCore import SIGNAL
from PyQt4.QtGui import QWidget
from PyQt.QtWidgets import QWidget
from qgis.core import QGis
from ui_widgetClipper import Ui_GdalToolsWidget as Ui_Widget
from widgetPluginBase import GdalToolsBasePluginWidget as BasePluginWidget
import GdalTools_utils as Utils
from .ui_widgetClipper import Ui_GdalToolsWidget as Ui_Widget
from .widgetPluginBase import GdalToolsBasePluginWidget as BasePluginWidget
from . import GdalTools_utils as Utils
class GdalToolsDialog(QWidget, Ui_Widget, BasePluginWidget):
@ -51,25 +50,25 @@ class GdalToolsDialog(QWidget, Ui_Widget, BasePluginWidget):
self.yRes.setValue(12.5)
self.setParamsStatus([
(self.inSelector, SIGNAL("filenameChanged()")),
(self.outSelector, SIGNAL("filenameChanged()")),
(self.noDataSpin, SIGNAL("valueChanged(int)"), self.noDataCheck, 1700),
(self.maskSelector, SIGNAL("filenameChanged()"), self.maskModeRadio, 1600),
(self.alphaBandCheck, SIGNAL("stateChanged(int)")),
(self.cropToCutlineCheck, SIGNAL("stateChanged(int)")),
([self.xRes, self.yRes], SIGNAL("valueChanged(double)"), self.setResolutionRadio),
(self.extentSelector, [SIGNAL("selectionStarted()"), SIGNAL("newExtentDefined()")], self.extentModeRadio),
(self.modeStackedWidget, SIGNAL("currentIndexChanged(int)"))
(self.inSelector, "filenameChanged"),
(self.outSelector, "filenameChanged"),
(self.noDataSpin, "valueChanged", self.noDataCheck, 1700),
(self.maskSelector, "filenameChanged", self.maskModeRadio, 1600),
(self.alphaBandCheck, "stateChanged"),
(self.cropToCutlineCheck, "stateChanged"),
([self.xRes, self.yRes], "valueChanged", self.setResolutionRadio),
(self.extentSelector, ["selectionStarted", "newExtentDefined"], self.extentModeRadio),
(self.modeStackedWidget, "currentChanged")
])
self.connect(self.inSelector, SIGNAL("selectClicked()"), self.fillInputFileEdit)
self.connect(self.outSelector, SIGNAL("selectClicked()"), self.fillOutputFileEdit)
self.connect(self.maskSelector, SIGNAL("selectClicked()"), self.fillMaskFileEdit)
self.connect(self.extentSelector, SIGNAL("newExtentDefined()"), self.extentChanged)
self.connect(self.extentSelector, SIGNAL("selectionStarted()"), self.checkRun)
self.inSelector.selectClicked.connect(self.fillInputFileEdit)
self.outSelector.selectClicked.connect(self.fillOutputFileEdit)
self.maskSelector.selectClicked.connect(self.fillMaskFileEdit)
self.extentSelector.newExtentDefined.connect(self.extentChanged)
self.extentSelector.selectionStarted.connect(self.checkRun)
self.connect(self.extentModeRadio, SIGNAL("toggled(bool)"), self.switchClippingMode)
self.connect(self.keepResolutionRadio, SIGNAL("toggled(bool)"), self.switchResolutionMode)
self.extentModeRadio.toggled.connect(self.switchClippingMode)
self.keepResolutionRadio.toggled.connect(self.switchResolutionMode)
def show_(self):
self.switchClippingMode()
@ -110,7 +109,7 @@ class GdalToolsDialog(QWidget, Ui_Widget, BasePluginWidget):
def onLayersChanged(self):
self.inSelector.setLayers(Utils.LayerRegistry.instance().getRasterLayers())
self.maskSelector.setLayers(filter(lambda x: x.geometryType() == QGis.Polygon, Utils.LayerRegistry.instance().getVectorLayers()))
self.maskSelector.setLayers([x for x in Utils.LayerRegistry.instance().getVectorLayers() if x.geometryType() == QGis.Polygon])
self.checkRun()
def fillInputFileEdit(self):

24
python/plugins/GdalTools/tools/doContour.py
View File

@ -23,12 +23,12 @@ __copyright__ = '(C) 2010, Giuseppe Sucameli'
# This will get replaced with a git SHA1 when you do a git archive
__revision__ = '$Format:%H$'
from PyQt4.QtCore import SIGNAL, QDir
from PyQt4.QtGui import QWidget, QApplication
from PyQt.QtCore import QDir
from PyQt.QtWidgets import QWidget, QApplication
from ui_widgetContour import Ui_GdalToolsWidget as Ui_Widget
from widgetPluginBase import GdalToolsBasePluginWidget as BasePluginWidget
import GdalTools_utils as Utils
from .ui_widgetContour import Ui_GdalToolsWidget as Ui_Widget
from .widgetPluginBase import GdalToolsBasePluginWidget as BasePluginWidget
from . import GdalTools_utils as Utils
class GdalToolsDialog(QWidget, Ui_Widget, BasePluginWidget):
@ -51,14 +51,14 @@ class GdalToolsDialog(QWidget, Ui_Widget, BasePluginWidget):
self.intervalDSpinBox.setValue(10.0)
self.setParamsStatus([
(self.inSelector, SIGNAL("filenameChanged()")),
(self.outSelector, SIGNAL("filenameChanged()")),
(self.intervalDSpinBox, SIGNAL("valueChanged(double)")),
(self.attributeEdit, SIGNAL("textChanged(const QString &)"), self.attributeCheck)
(self.inSelector, "filenameChanged"),
(self.outSelector, "filenameChanged"),
(self.intervalDSpinBox, "valueChanged"),
(self.attributeEdit, "textChanged", self.attributeCheck)
])
self.connect(self.inSelector, SIGNAL("selectClicked()"), self.fillInputFileEdit)
self.connect(self.outSelector, SIGNAL("selectClicked()"), self.fillOutputFileEdit)
self.inSelector.selectClicked.connect(self.fillInputFileEdit)
self.outSelector.selectClicked.connect(self.fillOutputFileEdit)
def onLayersChanged(self):
self.inSelector.setLayers(Utils.LayerRegistry.instance().getRasterLayers())
@ -93,7 +93,7 @@ class GdalToolsDialog(QWidget, Ui_Widget, BasePluginWidget):
if self.attributeCheck.isChecked() and self.attributeEdit.text():
arguments.append("-a")
arguments.append(self.attributeEdit.text())
if True: # XXX in this moment the -i argument is not optional
if True: # XXX in this moment the -i argument is not optional
arguments.append("-i")
arguments.append(unicode(self.intervalDSpinBox.value()))
arguments.append(self.getInputFileName())

47
python/plugins/GdalTools/tools/doDEM.py
View File

@ -23,12 +23,11 @@ __copyright__ = '(C) 2011, Giuseppe Sucameli'
# This will get replaced with a git SHA1 when you do a git archive
__revision__ = '$Format:%H$'
from PyQt4.QtCore import SIGNAL
from PyQt4.QtGui import QWidget
from PyQt.QtWidgets import QWidget
from ui_widgetDEM import Ui_GdalToolsWidget as Ui_Widget
from widgetPluginBase import GdalToolsBasePluginWidget as BasePluginWidget
import GdalTools_utils as Utils
from .ui_widgetDEM import Ui_GdalToolsWidget as Ui_Widget
from .widgetPluginBase import GdalToolsBasePluginWidget as BasePluginWidget
from . import GdalTools_utils as Utils
class GdalToolsDialog(QWidget, Ui_Widget, BasePluginWidget):
@ -62,27 +61,27 @@ class GdalToolsDialog(QWidget, Ui_Widget, BasePluginWidget):
self.creationOptionsWidget.setFormat(self.outputFormat)
self.setParamsStatus([
(self.inSelector, SIGNAL("filenameChanged()")),
(self.outSelector, SIGNAL("filenameChanged()")),
(self.computeEdgesCheck, SIGNAL("stateChanged(int)"), None, 1800),
(self.bandSpin, SIGNAL("valueChanged(int)"), self.bandCheck),
(self.algorithmCheck, SIGNAL("stateChanged(int)"), None, 1800),
(self.creationOptionsWidget, SIGNAL("optionsChanged()")),
(self.creationOptionsGroupBox, SIGNAL("toggled(bool)")),
(self.modeCombo, SIGNAL("currentIndexChanged(int)")),
([self.hillshadeZFactorSpin, self.hillshadeScaleSpin, self.hillshadeAltitudeSpin, self.hillshadeAzimuthSpin], SIGNAL("valueChanged(double)")),
(self.slopeScaleSpin, SIGNAL("valueChanged(double)")),
(self.slopePercentCheck, SIGNAL("stateChanged(int)")),
([self.aspectTrigonometricCheck, self.aspectZeroForFlatCheck], SIGNAL("stateChanged(int)")),
(self.configSelector, SIGNAL("filenameChanged()")),
([self.colorExactRadio, self.colorNearestRadio], SIGNAL("toggled(bool)"), self.colorMatchGroupBox),
(self.colorAlphaCheck, SIGNAL("stateChanged(int)"))
(self.inSelector, "filenameChanged"),
(self.outSelector, "filenameChanged"),
(self.computeEdgesCheck, "stateChanged", None, 1800),
(self.bandSpin, "valueChanged", self.bandCheck),
(self.algorithmCheck, "stateChanged", None, 1800),
(self.creationOptionsWidget, "optionsChanged"),
(self.creationOptionsGroupBox, "toggled"),
(self.modeCombo, "currentIndexChanged"),
([self.hillshadeZFactorSpin, self.hillshadeScaleSpin, self.hillshadeAltitudeSpin, self.hillshadeAzimuthSpin], "valueChanged"),
(self.slopeScaleSpin, "valueChanged"),
(self.slopePercentCheck, "stateChanged"),
([self.aspectTrigonometricCheck, self.aspectZeroForFlatCheck], "stateChanged"),
(self.configSelector, "filenameChanged"),
([self.colorExactRadio, self.colorNearestRadio], "toggled", self.colorMatchGroupBox),
(self.colorAlphaCheck, "stateChanged")
])
self.connect(self.inSelector, SIGNAL("selectClicked()"), self.fillInputFileEdit)
self.connect(self.outSelector, SIGNAL("selectClicked()"), self.fillOutputFileEdit)
self.connect(self.configSelector, SIGNAL("selectClicked()"), self.fillColorConfigFileEdit)
self.connect(self.modeCombo, SIGNAL("currentIndexChanged(int)"), self.showModeParams)
self.inSelector.selectClicked.connect(self.fillInputFileEdit)
self.outSelector.selectClicked.connect(self.fillOutputFileEdit)
self.configSelector.selectClicked.connect(self.fillColorConfigFileEdit)
self.modeCombo.currentIndexChanged.connect(self.showModeParams)
def showModeParams(self, index):
self.stackedWidget.setVisible(index < 4)

41
python/plugins/GdalTools/tools/doExtractProj.py
View File

@ -23,11 +23,12 @@ __copyright__ = '(C) 2011, Alexander Bruy'
# This will get replaced with a git SHA1 when you do a git archive
__revision__ = '$Format:%H$'
from PyQt4.QtCore import Qt, SIGNAL, QCoreApplication, QObject, QThread, QMutex
from PyQt4.QtGui import QDialog, QDialogButtonBox, QApplication, QCursor, QMessageBox
from PyQt.QtCore import Qt, QCoreApplication, QThread, QMutex
from PyQt.QtWidgets import QDialog, QDialogButtonBox, QApplication, QMessageBox
from PyQt.QtGui import QCursor
from ui_dialogExtractProjection import Ui_GdalToolsDialog as Ui_Dialog
import GdalTools_utils as Utils
from .ui_dialogExtractProjection import Ui_GdalToolsDialog as Ui_Dialog
from . import GdalTools_utils as Utils
import os.path
@ -57,8 +58,8 @@ class GdalToolsDialog(QDialog, Ui_Dialog):
self.okButton = self.buttonBox.button(QDialogButtonBox.Ok)
self.cancelButton = self.buttonBox.button(QDialogButtonBox.Cancel)
self.connect(self.inSelector, SIGNAL("selectClicked()"), self.fillInputFileEdit)
self.connect(self.batchCheck, SIGNAL("stateChanged( int )"), self.switchToolMode)
self.inSelector.selectClicked.connect(self.fillInputFileEdit)
self.batchCheck.stateChanged.connect(self.switchToolMode)
def switchToolMode(self):
self.recurseCheck.setVisible(self.batchCheck.isChecked())
@ -69,13 +70,13 @@ class GdalToolsDialog(QDialog, Ui_Dialog):
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)
self.inSelector.selectClicked.disconnect(self.fillInputFileEdit)
self.inSelector.selectClicked.connect(self.fillInputDir)
else:
self.label.setText(self.inFileLabel)
QObject.connect(self.inSelector, SIGNAL("selectClicked()"), self.fillInputFileEdit)
QObject.disconnect(self.inSelector, SIGNAL("selectClicked()"), self.fillInputDir)
self.inSelector.selectClicked.connect(self.fillInputFileEdit)
self.inSelector.selectClicked.disconnect(self.fillInputDir)
def fillInputFileEdit(self):
lastUsedFilter = Utils.FileFilter.lastUsedRasterFilter()
@ -107,12 +108,12 @@ class GdalToolsDialog(QDialog, Ui_Dialog):
self.okButton.setEnabled(False)
self.extractor = ExtractThread(self.inFiles, self.prjCheck.isChecked())
QObject.connect(self.extractor, SIGNAL("fileProcessed()"), self.updateProgress)
QObject.connect(self.extractor, SIGNAL("processFinished()"), self.processingFinished)
QObject.connect(self.extractor, SIGNAL("processInterrupted()"), self.processingInterrupted)
self.extractor.fileProcessed.connect(self.updateProgress)
self.extractor.processFinished.connect(self.processingFinished)
self.extractor.processInterrupted.connect(self.processingInterrupted)
QObject.disconnect(self.buttonBox, SIGNAL("rejected()"), self.reject)
QObject.connect(self.buttonBox, SIGNAL("rejected()"), self.stopProcessing)
self.buttonBox.rejected.disconnect(self.reject)
self.buttonBox.rejected.connect(self.stopProcessing)
self.extractor.start()
@ -139,8 +140,8 @@ class GdalToolsDialog(QDialog, Ui_Dialog):
QApplication.restoreOverrideCursor()
QObject.disconnect(self.buttonBox, SIGNAL("rejected()"), self.stopProcessing)
QObject.connect(self.buttonBox, SIGNAL("rejected()"), self.reject)
self.buttonBox.rejected.disconnect(self.stopProcessing)
self.buttonBox.rejected.connect(self.reject)
self.okButton.setEnabled(True)
@ -200,7 +201,7 @@ class ExtractThread(QThread):
for f in self.inFiles:
extractProjection(f, self.needPrj)
self.emit(SIGNAL("fileProcessed()"))
self.fileProcessed.emit()
self.mutex.lock()
s = self.stopMe
@ -210,9 +211,9 @@ class ExtractThread(QThread):
break
if not interrupted:
self.emit(SIGNAL("processFinished()"))
self.processFinished.emit()
else:
self.emit(SIGNAL("processIterrupted()"))
self.processIterrupted.emit()
def stop(self):
self.mutex.lock()

48
python/plugins/GdalTools/tools/doFillNodata.py
View File

@ -23,12 +23,12 @@ __copyright__ = '(C) 2011, Alexander Bruy'
# This will get replaced with a git SHA1 when you do a git archive
__revision__ = '$Format:%H$'
from PyQt4.QtCore import Qt, QObject, SIGNAL, QCoreApplication, QDir
from PyQt4.QtGui import QWidget
from PyQt.QtCore import Qt, QCoreApplication, QDir
from PyQt.QtWidgets import QWidget
from ui_widgetFillNodata import Ui_GdalToolsWidget as Ui_Widget
from widgetBatchBase import GdalToolsBaseBatchWidget as BaseBatchWidget
import GdalTools_utils as Utils
from .ui_widgetFillNodata import Ui_GdalToolsWidget as Ui_Widget
from .widgetBatchBase import GdalToolsBaseBatchWidget as BaseBatchWidget
from . import GdalTools_utils as Utils
import re
@ -54,19 +54,19 @@ class GdalToolsDialog(QWidget, Ui_Widget, BaseBatchWidget):
self.outputFormat = Utils.fillRasterOutputFormat()
self.setParamsStatus([
(self.inSelector, SIGNAL("filenameChanged()")),
(self.outSelector, SIGNAL("filenameChanged()")),
(self.maskSelector, SIGNAL("filenameChanged()"), self.maskCheck),
(self.distanceSpin, SIGNAL("valueChanged( int )"), self.distanceCheck),
(self.smoothSpin, SIGNAL("valueChanged( int )"), self.smoothCheck),
(self.bandSpin, SIGNAL("valueChanged( int )"), self.bandCheck),
(self.nomaskCheck, SIGNAL("stateChanged( int )"))
(self.inSelector, "filenameChanged"),
(self.outSelector, "filenameChanged"),
(self.maskSelector, "filenameChanged", self.maskCheck),
(self.distanceSpin, "valueChanged", self.distanceCheck),
(self.smoothSpin, "valueChanged", self.smoothCheck),
(self.bandSpin, "valueChanged", self.bandCheck),
(self.nomaskCheck, "stateChanged")
])
self.connect(self.inSelector, SIGNAL("selectClicked()"), self.fillInputFile)
self.connect(self.outSelector, SIGNAL("selectClicked()"), self.fillOutputFile)
self.connect(self.maskSelector, SIGNAL("selectClicked()"), self.fillMaskFile)
self.connect(self.batchCheck, SIGNAL("stateChanged( int )"), self.switchToolMode)
self.inSelector.selectClicked.connect(self.fillInputFile)
self.outSelector.selectClicked.connect(self.fillOutputFile)
self.maskSelector.selectClicked.connect(self.fillMaskFile)
self.batchCheck.stateChanged.connect(self.switchToolMode)
# add raster filters to combo
self.formatCombo.addItems(Utils.FileFilter.allRastersFilter().split(";;"))
@ -86,20 +86,20 @@ class GdalToolsDialog(QWidget, Ui_Widget, BaseBatchWidget):
self.label.setText(QCoreApplication.translate("GdalTools", "&Input directory"))
self.label_1.setText(QCoreApplication.translate("GdalTools", "&Output directory"))
QObject.disconnect(self.inSelector, SIGNAL("selectClicked()"), self.fillInputFile)
QObject.disconnect(self.outSelector, SIGNAL("selectClicked()"), self.fillOutputFile)
self.inSelector.selectClicked.disconnect(self.fillInputFile)
self.outSelector.selectClicked.disconnect(self.fillOutputFile)
QObject.connect(self.inSelector, SIGNAL("selectClicked()"), self. fillInputDir)
QObject.connect(self.outSelector, SIGNAL("selectClicked()"), self.fillOutputDir)
self.inSelector.selectClicked.connect(self. fillInputDir)
self.outSelector.selectClicked.connect(self.fillOutputDir)
else:
self.label.setText(self.inFileLabel)
self.label_1.setText(self.outFileLabel)
QObject.disconnect(self.inSelector, SIGNAL("selectClicked()"), self.fillInputDir)
QObject.disconnect(self.outSelector, SIGNAL("selectClicked()"), self.fillOutputDir)
self.inSelector.selectClicked.disconnect(self.fillInputDir)
self.outSelector.selectClicked.disconnect(self.fillOutputDir)
QObject.connect(self.inSelector, SIGNAL("selectClicked()"), self.fillInputFile)
QObject.connect(self.outSelector, SIGNAL("selectClicked()"), self.fillOutputFile)
self.inSelector.selectClicked.connect(self.fillInputFile)
self.outSelector.selectClicked.connect(self.fillOutputFile)
def fillInputFile(self):
lastUsedFilter = Utils.FileFilter.lastUsedRasterFilter()

46
python/plugins/GdalTools/tools/doGrid.py
View File

@ -23,12 +23,12 @@ __copyright__ = '(C) 2010, Giuseppe Sucameli'
# This will get replaced with a git SHA1 when you do a git archive
__revision__ = '$Format:%H$'
from PyQt4.QtCore import SIGNAL, QFileInfo, QTextCodec
from PyQt4.QtGui import QWidget, QErrorMessage
from PyQt.QtCore import QFileInfo, QTextCodec
from PyQt.QtWidgets import QWidget, QErrorMessage
from ui_widgetGrid import Ui_GdalToolsWidget as Ui_Widget
from widgetPluginBase import GdalToolsBasePluginWidget as BasePluginWidget
import GdalTools_utils as Utils
from .ui_widgetGrid import Ui_GdalToolsWidget as Ui_Widget
from .widgetPluginBase import GdalToolsBasePluginWidget as BasePluginWidget
from . import GdalTools_utils as Utils
class GdalToolsDialog(QWidget, Ui_Widget, BasePluginWidget):
@ -56,27 +56,27 @@ class GdalToolsDialog(QWidget, Ui_Widget, BasePluginWidget):
self.lastEncoding = Utils.getLastUsedEncoding()
self.setParamsStatus([
(self.inSelector, SIGNAL("filenameChanged()")),
(self.outSelector, SIGNAL("filenameChanged()")),
(self.zfieldCombo, SIGNAL("currentIndexChanged(int)"), self.zfieldCheck),
(self.algorithmCombo, SIGNAL("currentIndexChanged(int)"), self.algorithmCheck),
(self.inSelector, "filenameChanged"),
(self.outSelector, "filenameChanged"),
(self.zfieldCombo, "currentIndexChanged", self.zfieldCheck),
(self.algorithmCombo, "currentIndexChanged", self.algorithmCheck),
(self.stackedWidget, None, self.algorithmCheck),
([self.invdistPowerSpin, self.invdistSmothingSpin, self.invdistRadius1Spin, self.invdistRadius2Spin, self.invdistAngleSpin, self.invdistNoDataSpin], SIGNAL("valueChanged(double)")),
([self.invdistMaxPointsSpin, self.invdistMinPointsSpin], SIGNAL("valueChanged(int)")),
([self.averageRadius1Spin, self.averageRadius2Spin, self.averageAngleSpin, self.averageNoDataSpin], SIGNAL("valueChanged(double)")),
(self.averageMinPointsSpin, SIGNAL("valueChanged(int)")),
([self.nearestRadius1Spin, self.nearestRadius2Spin, self.nearestAngleSpin, self.nearestNoDataSpin], SIGNAL("valueChanged(double)")),
(self.datametricsCombo, SIGNAL("currentIndexChanged(int)")),
([self.datametricsRadius1Spin, self.datametricsRadius2Spin, self.datametricsAngleSpin, self.datametricsNoDataSpin], SIGNAL("valueChanged(double)")),
(self.datametricsMinPointsSpin, SIGNAL("valueChanged(int)")),
(self.extentSelector, [SIGNAL("selectionStarted()"), SIGNAL("newExtentDefined()")], self.extentGroup),
([self.widthSpin, self.heightSpin], SIGNAL("valueChanged(int)"), self.resizeGroupBox)
([self.invdistPowerSpin, self.invdistSmothingSpin, self.invdistRadius1Spin, self.invdistRadius2Spin, self.invdistAngleSpin, self.invdistNoDataSpin], "valueChanged"),
([self.invdistMaxPointsSpin, self.invdistMinPointsSpin], "valueChanged"),
([self.averageRadius1Spin, self.averageRadius2Spin, self.averageAngleSpin, self.averageNoDataSpin], "valueChanged"),
(self.averageMinPointsSpin, "valueChanged"),
([self.nearestRadius1Spin, self.nearestRadius2Spin, self.nearestAngleSpin, self.nearestNoDataSpin], "valueChanged"),
(self.datametricsCombo, "currentIndexChanged"),
([self.datametricsRadius1Spin, self.datametricsRadius2Spin, self.datametricsAngleSpin, self.datametricsNoDataSpin], "valueChanged"),
(self.datametricsMinPointsSpin, "valueChanged"),
(self.extentSelector, ["selectionStarted", "newExtentDefined"], self.extentGroup),
([self.widthSpin, self.heightSpin], "valueChanged", self.resizeGroupBox)
])
self.connect(self.inSelector, SIGNAL("selectClicked()"), self.fillInputFileEdit)
self.connect(self.outSelector, SIGNAL("selectClicked()"), self.fillOutputFileEdit)
self.connect(self.inSelector, SIGNAL("layerChanged()"), self.fillFieldsCombo)
self.connect(self.extentGroup, SIGNAL("toggled(bool)"), self.onExtentCheckedChanged)
self.inSelector.selectClicked.connect(self.fillInputFileEdit)
self.outSelector.selectClicked.connect(self.fillOutputFileEdit)
self.inSelector.layerChanged.connect(self.fillFieldsCombo)
self.extentGroup.toggled.connect(self.onExtentCheckedChanged)
def onClosing(self):
self.extentSelector.stop()

22
python/plugins/GdalTools/tools/doInfo.py
View File

@ -23,12 +23,12 @@ __copyright__ = '(C) 2010, Giuseppe Sucameli'
# This will get replaced with a git SHA1 when you do a git archive
__revision__ = '$Format:%H$'
from PyQt4.QtCore import Qt, QObject, SIGNAL
from PyQt4.QtGui import QWidget, QAction, QApplication, QMenu
from PyQt.QtCore import Qt
from PyQt.QtWidgets import QWidget, QAction, QApplication, QMenu
from ui_widgetInfo import Ui_GdalToolsWidget as Ui_Widget
from widgetPluginBase import GdalToolsBasePluginWidget as BasePluginWidget
import GdalTools_utils as Utils
from .ui_widgetInfo import Ui_GdalToolsWidget as Ui_Widget
from .widgetPluginBase import GdalToolsBasePluginWidget as BasePluginWidget
from . import GdalTools_utils as Utils
import platform
@ -48,18 +48,18 @@ class GdalToolsDialog(QWidget, Ui_Widget, BasePluginWidget):
self.base.resize(400, 360)
self.setParamsStatus([
(self.inSelector, SIGNAL("filenameChanged()")),
(self.suppressGCPCheck, SIGNAL("stateChanged( int )")),
(self.suppressMDCheck, SIGNAL("stateChanged( int )"))
(self.inSelector, "filenameChanged"),
(self.suppressGCPCheck, "stateChanged"),
(self.suppressMDCheck, "stateChanged")
])
self.connect(self.inSelector, SIGNAL("selectClicked()"), self.fillInputFileEdit)
self.inSelector.selectClicked.connect(self.fillInputFileEdit)
# helper actions for copying info output
self.copyLine = QAction(self.tr("Copy"), self)
QObject.connect(self.copyLine, SIGNAL("triggered()"), self.doCopyLine)
self.copyLine.triggered.connect(self.doCopyLine)
self.copyAll = QAction(self.tr("Copy all"), self)
QObject.connect(self.copyAll, SIGNAL("triggered()"), self.doCopyAll)
self.copyAll.triggered.connect(self.doCopyAll)
def doCopyLine(self):
output = ''

48
python/plugins/GdalTools/tools/doMerge.py
View File

@ -23,12 +23,12 @@ __copyright__ = '(C) 2010, Giuseppe Sucameli'
# This will get replaced with a git SHA1 when you do a git archive
__revision__ = '$Format:%H$'
from PyQt4.QtCore import SIGNAL, QObject, QCoreApplication
from PyQt4.QtGui import QWidget, QMessageBox
from PyQt.QtCore import QCoreApplication
from PyQt.QtWidgets import QWidget, QMessageBox
from ui_widgetMerge import Ui_GdalToolsWidget as Ui_Widget
from widgetPluginBase import GdalToolsBasePluginWidget as BasePluginWidget
import GdalTools_utils as Utils
from .ui_widgetMerge import Ui_GdalToolsWidget as Ui_Widget
from .widgetPluginBase import GdalToolsBasePluginWidget as BasePluginWidget
from . import GdalTools_utils as Utils
class GdalToolsDialog(QWidget, Ui_Widget, BasePluginWidget):
@ -50,23 +50,23 @@ class GdalToolsDialog(QWidget, Ui_Widget, BasePluginWidget):
self.extent = None
self.setParamsStatus([
(self.inSelector, SIGNAL("filenameChanged()")),
(self.outSelector, SIGNAL("filenameChanged()")),
(self.noDataSpin, SIGNAL("valueChanged(int)"), self.noDataCheck),
(self.inputDirCheck, SIGNAL("stateChanged(int)")),
(self.recurseCheck, SIGNAL("stateChanged(int)"), self.inputDirCheck),
(self.separateCheck, SIGNAL("stateChanged( int )")),
(self.pctCheck, SIGNAL("stateChanged( int )")),
(self.intersectCheck, SIGNAL("stateChanged( int )")),
(self.creationOptionsWidget, SIGNAL("optionsChanged()")),
(self.creationOptionsGroupBox, SIGNAL("toggled(bool)"))
(self.inSelector, "filenameChanged"),
(self.outSelector, "filenameChanged"),
(self.noDataSpin, "valueChanged", self.noDataCheck),
(self.inputDirCheck, "stateChanged"),
(self.recurseCheck, "stateChanged", self.inputDirCheck),
(self.separateCheck, "stateChanged"),
(self.pctCheck, "stateChanged"),
(self.intersectCheck, "stateChanged"),
(self.creationOptionsWidget, "optionsChanged"),
(self.creationOptionsGroupBox, "toggled")
])
self.connect(self.inSelector, SIGNAL("selectClicked()"), self.fillInputFilesEdit)
self.connect(self.outSelector, SIGNAL("selectClicked()"), self.fillOutputFileEdit)
self.connect(self.intersectCheck, SIGNAL("toggled(bool)"), self.refreshExtent)
self.connect(self.inputDirCheck, SIGNAL("stateChanged( int )"), self.switchToolMode)
self.connect(self.inSelector, SIGNAL("filenameChanged()"), self.refreshExtent)
self.inSelector.selectClicked.connect(self.fillInputFilesEdit)
self.outSelector.selectClicked.connect(self.fillOutputFileEdit)
self.intersectCheck.toggled.connect(self.refreshExtent)
self.inputDirCheck.stateChanged.connect(self.switchToolMode)
self.inSelector.filenameChanged.connect(self.refreshExtent)
def switchToolMode(self):
self.recurseCheck.setVisible(self.inputDirCheck.isChecked())
@ -76,13 +76,13 @@ class GdalToolsDialog(QWidget, Ui_Widget, BasePluginWidget):
self.inFileLabel = self.label.text()
self.label.setText(QCoreApplication.translate("GdalTools", "&Input directory"))
QObject.disconnect(self.inSelector, SIGNAL("selectClicked()"), self.fillInputFilesEdit)
QObject.connect(self.inSelector, SIGNAL("selectClicked()"), self.fillInputDir)
self.inSelector.selectClicked.disconnect(self.fillInputFilesEdit)
self.inSelector.selectClicked.connect(self.fillInputDir)
else:
self.label.setText(self.inFileLabel)
QObject.connect(self.inSelector, SIGNAL("selectClicked()"), self.fillInputFilesEdit)
QObject.disconnect(self.inSelector, SIGNAL("selectClicked()"), self.fillInputDir)
self.inSelector.selectClicked.connect(self.fillInputFilesEdit)
self.inSelector.selectClicked.disconnect(self.fillInputDir)
def fillInputFilesEdit(self):
lastUsedFilter = Utils.FileFilter.lastUsedRasterFilter()

21
python/plugins/GdalTools/tools/doNearBlack.py
View File

@ -23,12 +23,11 @@ __copyright__ = '(C) 2010, Giuseppe Sucameli'
# This will get replaced with a git SHA1 when you do a git archive
__revision__ = '$Format:%H$'
from PyQt4.QtCore import SIGNAL
from PyQt4.QtGui import QWidget
from PyQt.QtWidgets import QWidget
from ui_widgetNearBlack import Ui_GdalToolsWidget as Ui_Widget
from widgetPluginBase import GdalToolsBasePluginWidget as BasePluginWidget
import GdalTools_utils as Utils
from .ui_widgetNearBlack import Ui_GdalToolsWidget as Ui_Widget
from .widgetPluginBase import GdalToolsBasePluginWidget as BasePluginWidget
from . import GdalTools_utils as Utils
class GdalToolsDialog(QWidget, Ui_Widget, BasePluginWidget):
@ -46,14 +45,14 @@ class GdalToolsDialog(QWidget, Ui_Widget, BasePluginWidget):
self.nearSpin.setValue(15)
self.setParamsStatus([
(self.inSelector, SIGNAL("filenameChanged()")),
(self.outSelector, SIGNAL("filenameChanged()")),
(self.nearSpin, SIGNAL("valueChanged(int)"), self.nearCheck),
(self.whiteCheckBox, SIGNAL("stateChanged(int)"))
(self.inSelector, "filenameChanged"),
(self.outSelector, "filenameChanged"),
(self.nearSpin, "valueChanged", self.nearCheck),
(self.whiteCheckBox, "stateChanged")
])
self.connect(self.inSelector, SIGNAL("selectClicked()"), self.fillInputFileEdit)
self.connect(self.outSelector, SIGNAL("selectClicked()"), self.fillOutputFileEdit)
self.inSelector.selectClicked.connect(self.fillInputFileEdit)
self.outSelector.selectClicked.connect(self.fillOutputFileEdit)
def onLayersChanged(self):
self.inSelector.setLayers(Utils.LayerRegistry.instance().getRasterLayers())

32
python/plugins/GdalTools/tools/doOverview.py
View File

@ -23,13 +23,13 @@ __copyright__ = '(C) 2010, Giuseppe Sucameli'
# This will get replaced with a git SHA1 when you do a git archive
__revision__ = '$Format:%H$'
from PyQt4.QtCore import QObject, SIGNAL, QCoreApplication
from PyQt4.QtGui import QWidget
from PyQt.QtCore import QCoreApplication
from PyQt.QtWidgets import QWidget
from qgis.core import QgsRaster
from ui_widgetOverview import Ui_GdalToolsWidget as Ui_Widget
from widgetBatchBase import GdalToolsBaseBatchWidget as BaseBatchWidget
import GdalTools_utils as Utils
from .ui_widgetOverview import Ui_GdalToolsWidget as Ui_Widget
from .widgetBatchBase import GdalToolsBaseBatchWidget as BaseBatchWidget
from . import GdalTools_utils as Utils
class GdalToolsDialog(QWidget, Ui_Widget, BaseBatchWidget):
@ -50,14 +50,14 @@ class GdalToolsDialog(QWidget, Ui_Widget, BaseBatchWidget):
self.base.loadCheckBox.hide()
self.setParamsStatus([
(self.inSelector, SIGNAL("filenameChanged()")),
(self.cleanCheck, SIGNAL("stateChanged(int)"), None, 1700),
(self.mPyramidOptionsWidget, SIGNAL("overviewListChanged()")),
(self.mPyramidOptionsWidget, SIGNAL("someValueChanged()"))
(self.inSelector, "filenameChanged"),
(self.cleanCheck, "stateChanged", None, 1700),
(self.mPyramidOptionsWidget, "overviewListChanged"),
(self.mPyramidOptionsWidget, "someValueChanged")
])
self.connect(self.inSelector, SIGNAL("selectClicked()"), self.fillInputFile)
self.connect(self.batchCheck, SIGNAL("stateChanged( int )"), self.switchToolMode)
self.inSelector.selectClicked.connect(self.fillInputFile)
self.batchCheck.stateChanged.connect(self.switchToolMode)
self.init = False # workaround bug that pyramid options widgets are not initialized at first
@ -77,13 +77,13 @@ class GdalToolsDialog(QWidget, Ui_Widget, BaseBatchWidget):
self.inFileLabel = self.label.text()
self.label.setText(QCoreApplication.translate("GdalTools", "&Input directory"))
QObject.disconnect(self.inSelector, SIGNAL("selectClicked()"), self.fillInputFile)
QObject.connect(self.inSelector, SIGNAL("selectClicked()"), self.fillInputDir)
self.inSelector.selectClicked.disconnect(self.fillInputFile)
self.inSelector.selectClicked.connect(self.fillInputDir)
else:
self.label.setText(self.inFileLabel)
QObject.disconnect(self.inSelector, SIGNAL("selectClicked()"), self.fillInputDir)
QObject.connect(self.inSelector, SIGNAL("selectClicked()"), self.fillInputFile)
self.inSelector.selectClicked.disconnect(self.fillInputDir)
self.inSelector.selectClicked.connect(self.fillInputFile)
def onLayersChanged(self):
self.inSelector.setLayers(Utils.LayerRegistry.instance().getRasterLayers())
@ -176,7 +176,7 @@ class GdalToolsDialog(QWidget, Ui_Widget, BaseBatchWidget):
def onFinished(self, exitCode, status):
if not self.isBatchEnabled():
from widgetPluginBase import GdalToolsBasePluginWidget as BasePluginWidget
from .widgetPluginBase import GdalToolsBasePluginWidget as BasePluginWidget
BasePluginWidget.onFinished(self, exitCode, status)
return

40
python/plugins/GdalTools/tools/doPctRgb.py
View File

@ -23,12 +23,12 @@ __copyright__ = '(C) 2010, Giuseppe Sucameli'
# This will get replaced with a git SHA1 when you do a git archive
__revision__ = '$Format:%H$'
from PyQt4.QtCore import QObject, SIGNAL, QCoreApplication
from PyQt4.QtGui import QWidget
from PyQt.QtCore import QCoreApplication
from PyQt.QtWidgets import QWidget
from ui_widgetConvert import Ui_GdalToolsWidget as Ui_Widget
from widgetBatchBase import GdalToolsBaseBatchWidget as BaseBatchWidget
import GdalTools_utils as Utils
from .ui_widgetConvert import Ui_GdalToolsWidget as Ui_Widget
from .widgetBatchBase import GdalToolsBaseBatchWidget as BaseBatchWidget
from . import GdalTools_utils as Utils
class GdalToolsDialog(QWidget, Ui_Widget, BaseBatchWidget):
@ -53,15 +53,15 @@ class GdalToolsDialog(QWidget, Ui_Widget, BaseBatchWidget):
self.outputFormat = Utils.fillRasterOutputFormat()
self.setParamsStatus([
(self.inSelector, SIGNAL("filenameChanged()")),
(self.outSelector, SIGNAL("filenameChanged()")),
(self.colorsSpin, SIGNAL("valueChanged(int)"), self.colorsCheck, "-1"), # hide this option
(self.bandSpin, SIGNAL("valueChanged(int)"), self.bandCheck)
(self.inSelector, "filenameChanged"),
(self.outSelector, "filenameChanged"),
(self.colorsSpin, "valueChanged", self.colorsCheck, "-1"), # hide this option
(self.bandSpin, "valueChanged", self.bandCheck)
])
self.connect(self.inSelector, SIGNAL("selectClicked()"), self.fillInputFile)
self.connect(self.outSelector, SIGNAL("selectClicked()"), self.fillOutputFileEdit)
self.connect(self.batchCheck, SIGNAL("stateChanged( int )"), self.switchToolMode)
self.inSelector.selectClicked.connect(self.fillInputFile)
self.outSelector.selectClicked.connect(self.fillOutputFileEdit)
self.batchCheck.stateChanged.connect(self.switchToolMode)
# switch to batch or normal mode
def switchToolMode(self):
@ -77,20 +77,20 @@ class GdalToolsDialog(QWidget, Ui_Widget, BaseBatchWidget):
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)
self.inSelector.selectClicked.disconnect(self.fillInputFile)
self.outSelector.selectClicked.disconnect(self.fillOutputFileEdit)
QObject.connect(self.inSelector, SIGNAL("selectClicked()"), self.fillInputDir)
QObject.connect(self.outSelector, SIGNAL("selectClicked()"), self.fillOutputDir)
self.inSelector.selectClicked.connect(self.fillInputDir)
self.outSelector.selectClicked.connect(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)
self.inSelector.selectClicked.disconnect(self.fillInputDir)
self.outSelector.selectClicked.disconnect(self.fillOutputDir)
QObject.connect(self.inSelector, SIGNAL("selectClicked()"), self.fillInputFile)
QObject.connect(self.outSelector, SIGNAL("selectClicked()"), self.fillOutputFileEdit)
self.inSelector.selectClicked.connect(self.fillInputFile)
self.outSelector.selectClicked.connect(self.fillOutputFileEdit)
def onLayersChanged(self):
self.inSelector.setLayers(Utils.LayerRegistry.instance().getRasterLayers())

24
python/plugins/GdalTools/tools/doPolygonize.py
View File

@ -23,12 +23,12 @@ __copyright__ = '(C) 2010, Giuseppe Sucameli'
# This will get replaced with a git SHA1 when you do a git archive
__revision__ = '$Format:%H$'
from PyQt4.QtCore import SIGNAL, QFileInfo
from PyQt4.QtGui import QWidget
from PyQt.QtCore import QFileInfo
from PyQt.QtWidgets import QWidget
from ui_widgetPolygonize import Ui_GdalToolsWidget as Ui_Widget
from widgetPluginBase import GdalToolsBasePluginWidget as BasePluginWidget
import GdalTools_utils as Utils
from .ui_widgetPolygonize import Ui_GdalToolsWidget as Ui_Widget
from .widgetPluginBase import GdalToolsBasePluginWidget as BasePluginWidget
from . import GdalTools_utils as Utils
class GdalToolsDialog(QWidget, Ui_Widget, BasePluginWidget):
@ -45,15 +45,15 @@ class GdalToolsDialog(QWidget, Ui_Widget, BasePluginWidget):
self.outputFormat = Utils.fillVectorOutputFormat()
self.setParamsStatus([
(self.inSelector, SIGNAL("filenameChanged()")),
(self.outSelector, SIGNAL("filenameChanged()")),
(self.maskSelector, SIGNAL("filenameChanged()"), self.maskCheck),
(self.fieldEdit, SIGNAL("textChanged(const QString &)"), self.fieldCheck)
(self.inSelector, "filenameChanged"),
(self.outSelector, "filenameChanged"),
(self.maskSelector, "filenameChanged", self.maskCheck),
(self.fieldEdit, "textChanged", self.fieldCheck)
])
self.connect(self.inSelector, SIGNAL("selectClicked()"), self.fillInputFileEdit)
self.connect(self.outSelector, SIGNAL("selectClicked()"), self.fillOutputFileEdit)
self.connect(self.maskSelector, SIGNAL("selectClicked()"), self.fillMaskFileEdit)
self.inSelector.selectClicked.connect(self.fillInputFileEdit)
self.outSelector.selectClicked.connect(self.fillOutputFileEdit)
self.maskSelector.selectClicked.connect(self.fillMaskFileEdit)
def onLayersChanged(self):
self.inSelector.setLayers(Utils.LayerRegistry.instance().getRasterLayers())

32
python/plugins/GdalTools/tools/doProjection.py
View File

@ -23,14 +23,14 @@ __copyright__ = '(C) 2010, Giuseppe Sucameli'
# This will get replaced with a git SHA1 when you do a git archive
__revision__ = '$Format:%H$'
from PyQt4.QtCore import Qt, QObject, SIGNAL, QCoreApplication, QFile, QFileInfo
from PyQt4.QtGui import QWidget, QMessageBox
from PyQt.QtCore import Qt, QCoreApplication, QFile, QFileInfo
from PyQt.QtWidgets import QWidget, QMessageBox
from qgis.core import QgsMapLayerRegistry, QgsMapLayer
from ui_widgetProjection import Ui_GdalToolsWidget as Ui_Widget
from widgetBatchBase import GdalToolsBaseBatchWidget as BaseBatchWidget
from dialogSRS import GdalToolsSRSDialog as SRSDialog
import GdalTools_utils as Utils
from .ui_widgetProjection import Ui_GdalToolsWidget as Ui_Widget
from .widgetBatchBase import GdalToolsBaseBatchWidget as BaseBatchWidget
from .dialogSRS import GdalToolsSRSDialog as SRSDialog
from . import GdalTools_utils as Utils
import re
@ -53,14 +53,14 @@ class GdalToolsDialog(QWidget, Ui_Widget, BaseBatchWidget):
self.recurseCheck.hide()
self.setParamsStatus([
(self.inSelector, SIGNAL("filenameChanged()")),
(self.desiredSRSEdit, SIGNAL("textChanged( const QString & )"))
(self.inSelector, "filenameChanged"),
(self.desiredSRSEdit, "textChanged")
])
self.connect(self.inSelector, SIGNAL("selectClicked()"), self.fillInputFileEdit)
self.connect(self.selectDesiredSRSButton, SIGNAL("clicked()"), self.fillDesiredSRSEdit)
self.connect(self.batchCheck, SIGNAL("stateChanged( int )"), self.switchToolMode)
self.connect(self.recurseCheck, SIGNAL("stateChanged( int )"), self.enableRecurse)
self.inSelector.selectClicked.connect(self.fillInputFileEdit)
self.selectDesiredSRSButton.clicked.connect(self.fillDesiredSRSEdit)
self.batchCheck.stateChanged.connect(self.switchToolMode)
self.recurseCheck.stateChanged.connect(self.enableRecurse)
def switchToolMode(self):
self.setCommandViewerEnabled(not self.batchCheck.isChecked())
@ -73,13 +73,13 @@ class GdalToolsDialog(QWidget, Ui_Widget, BaseBatchWidget):
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)
self.inSelector.selectClicked.disconnect(self.fillInputFileEdit)
self.inSelector.selectClicked.connect(self.fillInputDir)
else:
self.label.setText(self.inFileLabel)
QObject.connect(self.inSelector, SIGNAL("selectClicked()"), self.fillInputFileEdit)
QObject.disconnect(self.inSelector, SIGNAL("selectClicked()"), self.fillInputDir)
self.inSelector.selectClicked.connect(self.fillInputFileEdit)
self.inSelector.selectClicked.disconnect(self.fillInputDir)
def enableRecurse(self):
if self.recurseCheck.isChecked():

27
python/plugins/GdalTools/tools/doProximity.py
View File

@ -23,12 +23,11 @@ __copyright__ = '(C) 2010, Giuseppe Sucameli'
# This will get replaced with a git SHA1 when you do a git archive
__revision__ = '$Format:%H$'
from PyQt4.QtCore import SIGNAL
from PyQt4.QtGui import QWidget
from PyQt.QtWidgets import QWidget
from ui_widgetProximity import Ui_GdalToolsWidget as Ui_Widget
from widgetPluginBase import GdalToolsBasePluginWidget as BasePluginWidget
import GdalTools_utils as Utils
from .ui_widgetProximity import Ui_GdalToolsWidget as Ui_Widget
from .widgetPluginBase import GdalToolsBasePluginWidget as BasePluginWidget
from . import GdalTools_utils as Utils
class GdalToolsDialog(QWidget, Ui_Widget, BasePluginWidget):
@ -44,17 +43,17 @@ class GdalToolsDialog(QWidget, Ui_Widget, BasePluginWidget):
self.outputFormat = Utils.fillRasterOutputFormat()
self.setParamsStatus([
(self.inSelector, SIGNAL("filenameChanged()")),
(self.outSelector, SIGNAL("filenameChanged()")),
(self.valuesEdit, SIGNAL("textChanged(const QString &)"), self.valuesCheck),
(self.distUnitsCombo, SIGNAL("currentIndexChanged(int)"), self.distUnitsCheck),
(self.maxDistSpin, SIGNAL("valueChanged(int)"), self.maxDistCheck),
(self.noDataSpin, SIGNAL("valueChanged(int)"), self.noDataCheck),
(self.fixedBufValSpin, SIGNAL("valueChanged(int)"), self.fixedBufValCheck)
(self.inSelector, "filenameChanged"),
(self.outSelector, "filenameChanged"),
(self.valuesEdit, "textChanged", self.valuesCheck),
(self.distUnitsCombo, "currentIndexChanged", self.distUnitsCheck),
(self.maxDistSpin, "valueChanged", self.maxDistCheck),
(self.noDataSpin, "valueChanged", self.noDataCheck),
(self.fixedBufValSpin, "valueChanged", self.fixedBufValCheck)
])
self.connect(self.inSelector, SIGNAL("selectClicked()"), self.fillInputFileEdit)
self.connect(self.outSelector, SIGNAL("selectClicked()"), self.fillOutputFileEdit)
self.inSelector.selectClicked.connect(self.fillInputFileEdit)
self.outSelector.selectClicked.connect(self.fillOutputFileEdit)
def onLayersChanged(self):
self.inSelector.setLayers(Utils.LayerRegistry().getRasterLayers())

30
python/plugins/GdalTools/tools/doRasterize.py
View File

@ -23,12 +23,12 @@ __copyright__ = '(C) 2010, Giuseppe Sucameli'
# This will get replaced with a git SHA1 when you do a git archive
__revision__ = '$Format:%H$'
from PyQt4.QtCore import SIGNAL, QFileInfo, QTextCodec
from PyQt4.QtGui import QWidget, QMessageBox, QErrorMessage
from PyQt.QtCore import QFileInfo, QTextCodec
from PyQt.QtWidgets import QWidget, QMessageBox, QErrorMessage
from ui_widgetRasterize import Ui_GdalToolsWidget as Ui_Widget
from widgetPluginBase import GdalToolsBasePluginWidget as BasePluginWidget
import GdalTools_utils as Utils
from .ui_widgetRasterize import Ui_GdalToolsWidget as Ui_Widget
from .widgetPluginBase import GdalToolsBasePluginWidget as BasePluginWidget
from . import GdalTools_utils as Utils
class GdalToolsDialog(QWidget, Ui_Widget, BasePluginWidget):
@ -51,18 +51,18 @@ class GdalToolsDialog(QWidget, Ui_Widget, BasePluginWidget):
self.lastEncoding = Utils.getLastUsedEncoding()
self.setParamsStatus([
(self.inSelector, SIGNAL("filenameChanged()")),
(self.outSelector, SIGNAL("filenameChanged()")),
(self.attributeComboBox, SIGNAL("currentIndexChanged(int)")),
([self.widthSpin, self.heightSpin], SIGNAL("valueChanged(int)")),
([self.horizresSpin, self.vertresSpin], SIGNAL("valueChanged(double)"))
(self.inSelector, "filenameChanged"),
(self.outSelector, "filenameChanged"),
(self.attributeComboBox, "currentIndexChanged"),
([self.widthSpin, self.heightSpin], "valueChanged"),
([self.horizresSpin, self.vertresSpin], "valueChanged")
])
self.connect(self.inSelector, SIGNAL("selectClicked()"), self.fillInputFileEdit)
self.connect(self.outSelector, SIGNAL("selectClicked()"), self.fillOutputFileEdit)
self.connect(self.inSelector, SIGNAL("layerChanged()"), self.fillFieldsCombo)
self.connect(self.radioSetSize, SIGNAL("toggled(bool)"), self.someValueChanged)
self.connect(self.radioSetResolution, SIGNAL("toggled(bool)"), self.someValueChanged)
self.inSelector.selectClicked.connect(self.fillInputFileEdit)
self.outSelector.selectClicked.connect(self.fillOutputFileEdit)
self.inSelector.layerChanged.connect(self.fillFieldsCombo)
self.radioSetSize.toggled.connect(self.someValueChanged)
self.radioSetResolution.toggled.connect(self.someValueChanged)
def onLayersChanged(self):
self.inSelector.setLayers(Utils.LayerRegistry.instance().getVectorLayers())

40
python/plugins/GdalTools/tools/doRgbPct.py
View File

@ -23,12 +23,12 @@ __copyright__ = '(C) 2010, Giuseppe Sucameli'
# This will get replaced with a git SHA1 when you do a git archive
__revision__ = '$Format:%H$'
from PyQt4.QtCore import SIGNAL, QObject, QCoreApplication
from PyQt4.QtGui import QWidget
from PyQt.QtCore import QCoreApplication
from PyQt.QtWidgets import QWidget
from ui_widgetConvert import Ui_GdalToolsWidget as Ui_Widget
from widgetBatchBase import GdalToolsBaseBatchWidget as BaseBatchWidget
import GdalTools_utils as Utils
from .ui_widgetConvert import Ui_GdalToolsWidget as Ui_Widget
from .widgetBatchBase import GdalToolsBaseBatchWidget as BaseBatchWidget
from . import GdalTools_utils as Utils
class GdalToolsDialog(QWidget, Ui_Widget, BaseBatchWidget):
@ -50,15 +50,15 @@ class GdalToolsDialog(QWidget, Ui_Widget, BaseBatchWidget):
self.outputFormat = Utils.fillRasterOutputFormat()
self.setParamsStatus([
(self.inSelector, SIGNAL("filenameChanged()")),
(self.outSelector, SIGNAL("filenameChanged()")),
(self.colorsSpin, SIGNAL("valueChanged(int)"), self.colorsCheck),
(self.bandSpin, SIGNAL("valueChanged(int)"), self.bandCheck, "-1") # hide this option
(self.inSelector, "filenameChanged"),
(self.outSelector, "filenameChanged"),
(self.colorsSpin, "valueChanged", self.colorsCheck),
(self.bandSpin, "valueChanged", self.bandCheck, "-1") # hide this option
])
self.connect(self.inSelector, SIGNAL("selectClicked()"), self.fillInputFile)
self.connect(self.outSelector, SIGNAL("selectClicked()"), self.fillOutputFileEdit)
self.connect(self.batchCheck, SIGNAL("stateChanged( int )"), self.switchToolMode)
self.inSelector.selectClicked.connect(self.fillInputFile)
self.outSelector.selectClicked.connect(self.fillOutputFileEdit)
self.batchCheck.stateChanged.connect(self.switchToolMode)
# switch to batch or normal mode
def switchToolMode(self):
@ -74,20 +74,20 @@ class GdalToolsDialog(QWidget, Ui_Widget, BaseBatchWidget):
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)
self.inSelector.selectClicked.disconnect(self.fillInputFile)
self.outSelector.selectClicked.disconnect(self.fillOutputFileEdit)
QObject.connect(self.inSelector, SIGNAL("selectClicked()"), self.fillInputDir)
QObject.connect(self.outSelector, SIGNAL("selectClicked()"), self.fillOutputDir)
self.inSelector.selectClicked.connect(self.fillInputDir)
self.outSelector.selectClicked.connect(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)
self.inSelector.selectClicked.disconnect(self.fillInputDir)
self.outSelector.selectClicked.disconnect(self.fillOutputDir)
QObject.connect(self.inSelector, SIGNAL("selectClicked()"), self.fillInputFile)
QObject.connect(self.outSelector, SIGNAL("selectClicked()"), self.fillOutputFileEdit)
self.inSelector.selectClicked.connect(self.fillInputFile)
self.outSelector.selectClicked.connect(self.fillOutputFileEdit)
def onLayersChanged(self):
self.inSelector.setLayers(Utils.LayerRegistry.instance().getRasterLayers())

27
python/plugins/GdalTools/tools/doSettings.py
View File

@ -23,11 +23,12 @@ __copyright__ = '(C) 2010, Giuseppe Sucameli'
# This will get replaced with a git SHA1 when you do a git archive
__revision__ = '$Format:%H$'
from PyQt4.QtCore import Qt, SIGNAL, QObject
from PyQt4.QtGui import QDialog, QPixmap
from PyQt.QtCore import Qt
from PyQt.QtWidgets import QDialog
from PyQt.QtGui import QPixmap
from ui_dialogSettings import Ui_GdalToolsSettingsDialog as Ui_Dialog
import GdalTools_utils as Utils
from .ui_dialogSettings import Ui_GdalToolsSettingsDialog as Ui_Dialog
from . import GdalTools_utils as Utils
class GdalToolsSettingsDialog(QDialog, Ui_Dialog):
@ -40,31 +41,31 @@ class GdalToolsSettingsDialog(QDialog, Ui_Dialog):
# binaries
self.leGdalBinPath.setText(Utils.getGdalBinPath())
QObject.connect(self.btnSetBinPath, SIGNAL("clicked()"), self.setBinPath)
self.btnSetBinPath.clicked.connect(self.setBinPath)
self.bin_tooltip_label.setPixmap(QPixmap(':/icons/tooltip.png'))
self.bin_tooltip_label.setToolTip( self.tr( u"""\
self.bin_tooltip_label.setToolTip(self.tr(u"""\
A list of colon-separated (Linux and MacOS) or
semicolon-separated (Windows) paths to both binaries
and python executables.
MacOS users usually need to set it to something like
/Library/Frameworks/GDAL.framework/Versions/1.8/Programs""") )
/Library/Frameworks/GDAL.framework/Versions/1.8/Programs"""))
# python modules
self.leGdalPymodPath.setText(Utils.getGdalPymodPath())
QObject.connect(self.btnSetPymodPath, SIGNAL("clicked()"), self.setPymodPath)
self.btnSetPymodPath.clicked.connect(self.setPymodPath)
self.pymod_tooltip_label.setPixmap(QPixmap(':/icons/tooltip.png'))
self.pymod_tooltip_label.setToolTip( self.tr( u"""\
self.pymod_tooltip_label.setToolTip(self.tr(u"""\
A list of colon-separated (Linux and MacOS) or
semicolon-separated (Windows) paths to python modules.""") )
semicolon-separated (Windows) paths to python modules."""))
# help
self.leGdalHelpPath.setText(Utils.getHelpPath())
QObject.connect(self.btnSetHelpPath, SIGNAL("clicked()"), self.setHelpPath)
self.btnSetHelpPath.clicked.connect(self.setHelpPath)
self.help_tooltip_label.setPixmap(QPixmap(':/icons/tooltip.png'))
self.help_tooltip_label.setToolTip( self.tr( u"""\
self.help_tooltip_label.setToolTip(self.tr(u"""\
Useful to open local GDAL documentation instead of online help
when pressing on the tool dialog's Help button.""") )
when pressing on the tool dialog's Help button."""))
def setBinPath(self):
inputDir = Utils.FileDialog.getExistingDirectory(self, self.tr("Select directory with GDAL executables"))

21
python/plugins/GdalTools/tools/doSieve.py
View File

@ -23,12 +23,11 @@ __copyright__ = '(C) 2010, Giuseppe Sucameli'
# This will get replaced with a git SHA1 when you do a git archive
__revision__ = '$Format:%H$'
from PyQt4.QtCore import SIGNAL
from PyQt4.QtGui import QWidget
from PyQt.QtWidgets import QWidget
from ui_widgetSieve import Ui_GdalToolsWidget as Ui_Widget
from widgetPluginBase import GdalToolsBasePluginWidget as BasePluginWidget
import GdalTools_utils as Utils
from .ui_widgetSieve import Ui_GdalToolsWidget as Ui_Widget
from .widgetPluginBase import GdalToolsBasePluginWidget as BasePluginWidget
from . import GdalTools_utils as Utils
class GdalToolsDialog(QWidget, Ui_Widget, BasePluginWidget):
@ -44,14 +43,14 @@ class GdalToolsDialog(QWidget, Ui_Widget, BasePluginWidget):
self.outputFormat = Utils.fillRasterOutputFormat()
self.setParamsStatus([
(self.inSelector, SIGNAL("filenameChanged()")),
(self.outSelector, SIGNAL("filenameChanged()")),
(self.thresholdSpin, SIGNAL("valueChanged(int)"), self.thresholdCheck),
(self.connectionsCombo, SIGNAL("currentIndexChanged(int)"), self.connectionsCheck)
(self.inSelector, "filenameChanged"),
(self.outSelector, "filenameChanged"),
(self.thresholdSpin, "valueChanged", self.thresholdCheck),
(self.connectionsCombo, "currentIndexChanged", self.connectionsCheck)
])
self.connect(self.inSelector, SIGNAL("selectClicked()"), self.fillInputFileEdit)
self.connect(self.outSelector, SIGNAL("selectClicked()"), self.fillOutputFileEdit)
self.inSelector.selectClicked.connect(self.fillInputFileEdit)
self.outSelector.selectClicked.connect(self.fillOutputFileEdit)
def onLayersChanged(self):
self.inSelector.setLayers(Utils.LayerRegistry.instance().getRasterLayers())

23
python/plugins/GdalTools/tools/doTileIndex.py
View File

@ -23,12 +23,11 @@ __copyright__ = '(C) 2011, Giuseppe Sucameli'
# This will get replaced with a git SHA1 when you do a git archive
__revision__ = '$Format:%H$'
from PyQt4.QtCore import SIGNAL
from PyQt4.QtGui import QWidget
from PyQt.QtWidgets import QWidget
from ui_widgetTileIndex import Ui_GdalToolsWidget as Ui_Widget
from widgetPluginBase import GdalToolsBasePluginWidget as BasePluginWidget
import GdalTools_utils as Utils
from .ui_widgetTileIndex import Ui_GdalToolsWidget as Ui_Widget
from .widgetPluginBase import GdalToolsBasePluginWidget as BasePluginWidget
from . import GdalTools_utils as Utils
class GdalToolsDialog(QWidget, Ui_Widget, BasePluginWidget):
@ -44,15 +43,15 @@ class GdalToolsDialog(QWidget, Ui_Widget, BasePluginWidget):
self.outSelector.setType(self.outSelector.FILE)
self.setParamsStatus([
(self.inSelector, SIGNAL("filenameChanged()")),
#( self.recurseCheck, SIGNAL( "stateChanged( int )" ),
(self.outSelector, SIGNAL("filenameChanged()")),
(self.indexFieldEdit, SIGNAL("textChanged( const QString & )"), self.indexFieldCheck),
(self.skipDifferentProjCheck, SIGNAL("stateChanged( int )"), None, 1500)
(self.inSelector, "filenameChanged"),
#( self.recurseCheck, "stateChanged" ),
(self.outSelector, "filenameChanged"),
(self.indexFieldEdit, "textChanged", self.indexFieldCheck),
(self.skipDifferentProjCheck, "stateChanged", None, 1500)
])
self.connect(self.inSelector, SIGNAL("selectClicked()"), self.fillInputDirEdit)
self.connect(self.outSelector, SIGNAL("selectClicked()"), self.fillOutputFileEdit)
self.inSelector.selectClicked.connect(self.fillInputDirEdit)
self.outSelector.selectClicked.connect(self.fillOutputFileEdit)
def fillInputDirEdit(self):
inputDir = Utils.FileDialog.getExistingDirectory(self, self.tr("Select the input directory with raster files"))

64
python/plugins/GdalTools/tools/doTranslate.py
View File

@ -23,13 +23,13 @@ __copyright__ = '(C) 2010, Giuseppe Sucameli'
# This will get replaced with a git SHA1 when you do a git archive
__revision__ = '$Format:%H$'
from PyQt4.QtCore import QObject, Qt, SIGNAL, QCoreApplication, QDir
from PyQt4.QtGui import QWidget, QMessageBox
from PyQt.QtCore import Qt, QCoreApplication, QDir
from PyQt.QtWidgets import QWidget, QMessageBox
from ui_widgetTranslate import Ui_GdalToolsWidget as Ui_Widget
from widgetBatchBase import GdalToolsBaseBatchWidget as BaseBatchWidget
from dialogSRS import GdalToolsSRSDialog as SRSDialog
import GdalTools_utils as Utils
from .ui_widgetTranslate import Ui_GdalToolsWidget as Ui_Widget
from .widgetBatchBase import GdalToolsBaseBatchWidget as BaseBatchWidget
from .dialogSRS import GdalToolsSRSDialog as SRSDialog
from . import GdalTools_utils as Utils
import re
@ -63,25 +63,25 @@ class GdalToolsDialog(QWidget, Ui_Widget, BaseBatchWidget):
self.outputFormat = Utils.fillRasterOutputFormat()
self.setParamsStatus([
(self.inSelector, SIGNAL("filenameChanged()")),
(self.outSelector, SIGNAL("filenameChanged()")),
(self.targetSRSEdit, SIGNAL("textChanged(const QString &)"), self.targetSRSCheck),
(self.inSelector, "filenameChanged"),
(self.outSelector, "filenameChanged"),
(self.targetSRSEdit, "textChanged", self.targetSRSCheck),
(self.selectTargetSRSButton, None, self.targetSRSCheck),
(self.creationOptionsWidget, SIGNAL("optionsChanged()")),
(self.outsizeSpin, SIGNAL("valueChanged(const QString &)"), self.outsizeCheck),
(self.nodataSpin, SIGNAL("valueChanged(int)"), self.nodataCheck),
(self.expandCombo, SIGNAL("currentIndexChanged(int)"), self.expandCheck, 1600),
(self.sdsCheck, SIGNAL("stateChanged(int)")),
(self.srcwinEdit, SIGNAL("textChanged(const QString &)"), self.srcwinCheck),
(self.prjwinEdit, SIGNAL("textChanged(const QString &)"), self.prjwinCheck)
(self.creationOptionsWidget, "optionsChanged"),
(self.outsizeSpin, "valueChanged", self.outsizeCheck),
(self.nodataSpin, "valueChanged", self.nodataCheck),
(self.expandCombo, "currentIndexChanged", self.expandCheck, 1600),
(self.sdsCheck, "stateChanged"),
(self.srcwinEdit, "textChanged", self.srcwinCheck),
(self.prjwinEdit, "textChanged", self.prjwinCheck)
])
#self.connect(self.canvas, SIGNAL("layersChanged()"), self.fillInputLayerCombo)
self.connect(self.inSelector, SIGNAL("layerChanged()"), self.fillTargetSRSEditDefault)
self.connect(self.inSelector, SIGNAL("selectClicked()"), self.fillInputFile)
self.connect(self.outSelector, SIGNAL("selectClicked()"), self.fillOutputFileEdit)
self.connect(self.selectTargetSRSButton, SIGNAL("clicked()"), self.fillTargetSRSEdit)
self.connect(self.batchCheck, SIGNAL("stateChanged( int )"), self.switchToolMode)
#self.canvas.layersChanged.connect(self.fillInputLayerCombo)
self.inSelector.layerChanged.connect(self.fillTargetSRSEditDefault)
self.inSelector.selectClicked.connect(self.fillInputFile)
self.outSelector.selectClicked.connect(self.fillOutputFileEdit)
self.selectTargetSRSButton.clicked.connect(self.fillTargetSRSEdit)
self.batchCheck.stateChanged.connect(self.switchToolMode)
# add raster filters to combo
self.formatCombo.addItems(Utils.FileFilter.allRastersFilter().split(";;"))
@ -101,20 +101,20 @@ class GdalToolsDialog(QWidget, Ui_Widget, BaseBatchWidget):
self.label_3.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)
self.inSelector.selectClicked.disconnect(self.fillInputFile)
self.outSelector.selectClicked.disconnect(self.fillOutputFileEdit)
QObject.connect(self.inSelector, SIGNAL("selectClicked()"), self. fillInputDir)
QObject.connect(self.outSelector, SIGNAL("selectClicked()"), self.fillOutputDir)
self.inSelector.selectClicked.connect(self. fillInputDir)
self.outSelector.selectClicked.connect(self.fillOutputDir)
else:
self.label_3.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)
self.inSelector.selectClicked.disconnect(self.fillInputDir)
self.outSelector.selectClicked.disconnect(self.fillOutputDir)
QObject.connect(self.inSelector, SIGNAL("selectClicked()"), self.fillInputFile)
QObject.connect(self.outSelector, SIGNAL("selectClicked()"), self.fillOutputFileEdit)
self.inSelector.selectClicked.connect(self.fillInputFile)
self.outSelector.selectClicked.connect(self.fillOutputFileEdit)
def onLayersChanged(self):
self.inSelector.setLayers(Utils.LayerRegistry.instance().getRasterLayers())
@ -201,7 +201,7 @@ class GdalToolsDialog(QWidget, Ui_Widget, BaseBatchWidget):
if self.sdsCheck.isChecked():
arguments.append("-sds")
if self.srcwinCheck.isChecked() and self.srcwinEdit.text():
coordList = self.srcwinEdit.text().split() # split the string on whitespace(s)
coordList = self.srcwinEdit.text().split() # split the string on whitespace(s)
if len(coordList) == 4 and coordList[3]:
try:
for x in coordList:
@ -214,7 +214,7 @@ class GdalToolsDialog(QWidget, Ui_Widget, BaseBatchWidget):
for x in coordList:
arguments.append(x)
if self.prjwinCheck.isChecked() and self.prjwinEdit.text():
coordList = self.prjwinEdit.text().split() # split the string on whitespace(s)
coordList = self.prjwinEdit.text().split() # split the string on whitespace(s)
if len(coordList) == 4 and coordList[3]:
try:
for x in coordList:

64
python/plugins/GdalTools/tools/doWarp.py
View File

@ -23,14 +23,14 @@ __copyright__ = '(C) 2010, Giuseppe Sucameli'
# This will get replaced with a git SHA1 when you do a git archive
__revision__ = '$Format:%H$'
from PyQt4.QtCore import QObject, QCoreApplication, SIGNAL, QDir
from PyQt4.QtGui import QWidget
from PyQt.QtCore import QCoreApplication, QDir
from PyQt.QtWidgets import QWidget
from qgis.core import QGis
from ui_widgetWarp import Ui_GdalToolsWidget as Ui_Widget
from widgetBatchBase import GdalToolsBaseBatchWidget as BaseBatchWidget
from dialogSRS import GdalToolsSRSDialog as SRSDialog
import GdalTools_utils as Utils
from .ui_widgetWarp import Ui_GdalToolsWidget as Ui_Widget
from .widgetBatchBase import GdalToolsBaseBatchWidget as BaseBatchWidget
from .dialogSRS import GdalToolsSRSDialog as SRSDialog
from . import GdalTools_utils as Utils
class GdalToolsDialog(QWidget, Ui_Widget, BaseBatchWidget):
@ -55,27 +55,27 @@ class GdalToolsDialog(QWidget, Ui_Widget, BaseBatchWidget):
self.outputFormat = Utils.fillRasterOutputFormat()
self.setParamsStatus([
(self.inSelector, SIGNAL("filenameChanged()")),
(self.outSelector, SIGNAL("filenameChanged()")),
(self.sourceSRSEdit, SIGNAL("textChanged(const QString &)"), self.sourceSRSCheck),
(self.inSelector, "filenameChanged"),
(self.outSelector, "filenameChanged"),
(self.sourceSRSEdit, "textChanged", self.sourceSRSCheck),
(self.selectSourceSRSButton, None, self.sourceSRSCheck),
(self.targetSRSEdit, SIGNAL("textChanged(const QString &)"), self.targetSRSCheck),
(self.targetSRSEdit, "textChanged", self.targetSRSCheck),
(self.selectTargetSRSButton, None, self.targetSRSCheck),
(self.resamplingCombo, SIGNAL("currentIndexChanged(int)"), self.resamplingCheck),
(self.cacheSpin, SIGNAL("valueChanged(int)"), self.cacheCheck),
([self.widthSpin, self.heightSpin], SIGNAL("valueChanged(int)"), self.resizeGroupBox),
(self.multithreadCheck, SIGNAL("stateChanged(int)")),
(self.noDataEdit, SIGNAL("textChanged( const QString & )"), self.noDataCheck),
(self.maskSelector, SIGNAL("filenameChanged()"), self.maskCheck, 1600),
(self.resamplingCombo, "currentIndexChanged", self.resamplingCheck),
(self.cacheSpin, "valueChanged", self.cacheCheck),
([self.widthSpin, self.heightSpin], "valueChanged", self.resizeGroupBox),
(self.multithreadCheck, "stateChanged"),
(self.noDataEdit, "textChanged", self.noDataCheck),
(self.maskSelector, "filenameChanged", self.maskCheck, 1600),
])
self.connect(self.inSelector, SIGNAL("layerChanged()"), self.fillSourceSRSEditDefault)
self.connect(self.inSelector, SIGNAL("selectClicked()"), self.fillInputFile)
self.connect(self.outSelector, SIGNAL("selectClicked()"), self.fillOutputFileEdit)
self.connect(self.selectSourceSRSButton, SIGNAL("clicked()"), self.fillSourceSRSEdit)
self.connect(self.selectTargetSRSButton, SIGNAL("clicked()"), self.fillTargetSRSEdit)
self.connect(self.maskSelector, SIGNAL("selectClicked()"), self.fillMaskFile)
self.connect(self.batchCheck, SIGNAL("stateChanged( int )"), self.switchToolMode)
self.inSelector.layerChanged.connect(self.fillSourceSRSEditDefault)
self.inSelector.selectClicked.connect(self.fillInputFile)
self.outSelector.selectClicked.connect(self.fillOutputFileEdit)
self.selectSourceSRSButton.clicked.connect(self.fillSourceSRSEdit)
self.selectTargetSRSButton.clicked.connect(self.fillTargetSRSEdit)
self.maskSelector.selectClicked.connect(self.fillMaskFile)
self.batchCheck.stateChanged.connect(self.switchToolMode)
# switch to batch or normal mode
def switchToolMode(self):
@ -91,24 +91,24 @@ class GdalToolsDialog(QWidget, Ui_Widget, BaseBatchWidget):
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)
self.inSelector.selectClicked.disconnect(self.fillInputFile)
self.outSelector.selectClicked.disconnect(self.fillOutputFileEdit)
QObject.connect(self.inSelector, SIGNAL("selectClicked()"), self.fillInputDir)
QObject.connect(self.outSelector, SIGNAL("selectClicked()"), self.fillOutputDir)
self.inSelector.selectClicked.connect(self.fillInputDir)
self.outSelector.selectClicked.connect(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)
self.inSelector.selectClicked.disconnect(self.fillInputDir)
self.outSelector.selectClicked.disconnect(self.fillOutputDir)
QObject.connect(self.inSelector, SIGNAL("selectClicked()"), self.fillInputFile)
QObject.connect(self.outSelector, SIGNAL("selectClicked()"), self.fillOutputFileEdit)
self.inSelector.selectClicked.connect(self.fillInputFile)
self.outSelector.selectClicked.connect(self.fillOutputFileEdit)
def onLayersChanged(self):
self.inSelector.setLayers(Utils.LayerRegistry.instance().getRasterLayers())
self.maskSelector.setLayers(filter(lambda x: x.geometryType() == QGis.Polygon, Utils.LayerRegistry.instance().getVectorLayers()))
self.maskSelector.setLayers([x for x in Utils.LayerRegistry.instance().getVectorLayers() if x.geometryType() == QGis.Polygon])
def fillInputFile(self):
lastUsedFilter = Utils.FileFilter.lastUsedRasterFilter()

44
python/plugins/GdalTools/tools/extentSelector.py
View File

@ -23,15 +23,20 @@ __copyright__ = '(C) 2010, Giuseppe Sucameli'
# This will get replaced with a git SHA1 when you do a git archive
__revision__ = '$Format:%H$'
from PyQt4.QtCore import SIGNAL
from PyQt4.QtGui import QWidget, QColor
from PyQt.QtCore import pyqtSignal
from PyQt.QtWidgets import QWidget
from PyQt.QtGui import QColor
from qgis.core import QgsPoint, QgsRectangle, QGis
from qgis.gui import QgsMapTool, QgsMapToolEmitPoint, QgsRubberBand
from ui_extentSelector import Ui_GdalToolsExtentSelector as Ui_ExtentSelector
from .ui_extentSelector import Ui_GdalToolsExtentSelector as Ui_ExtentSelector
class GdalToolsExtentSelector(QWidget, Ui_ExtentSelector):
selectionStarted = pyqtSignal()
selectionStopped = pyqtSignal()
selectionPaused = pyqtSignal()
newExtentDefined = pyqtSignal()
def __init__(self, parent=None):
QWidget.__init__(self, parent)
@ -42,18 +47,18 @@ class GdalToolsExtentSelector(QWidget, Ui_ExtentSelector):
self.setupUi(self)
self.connect(self.x1CoordEdit, SIGNAL("textChanged(const QString &)"), self.coordsChanged)
self.connect(self.x2CoordEdit, SIGNAL("textChanged(const QString &)"), self.coordsChanged)
self.connect(self.y1CoordEdit, SIGNAL("textChanged(const QString &)"), self.coordsChanged)
self.connect(self.y2CoordEdit, SIGNAL("textChanged(const QString &)"), self.coordsChanged)
self.connect(self.btnEnable, SIGNAL("clicked()"), self.start)
self.x1CoordEdit.textChanged.connect(self.coordsChanged)
self.x2CoordEdit.textChanged.connect(self.coordsChanged)
self.y1CoordEdit.textChanged.connect(self.coordsChanged)
self.y2CoordEdit.textChanged.connect(self.coordsChanged)
self.btnEnable.clicked.connect(self.start)
def setCanvas(self, canvas):
self.canvas = canvas
self.tool = RectangleMapTool(self.canvas)
self.previousMapTool = self.canvas.mapTool()
self.connect(self.tool, SIGNAL("rectangleCreated()"), self.fillCoords)
self.connect(self.tool, SIGNAL("deactivated()"), self.pause)
self.tool.rectangleCreated.connect(self.fillCoords)
self.tool.deactivated.connect(self.pause)
def stop(self):
if not self.isStarted:
@ -65,7 +70,7 @@ class GdalToolsExtentSelector(QWidget, Ui_ExtentSelector):
if self.previousMapTool != self.tool:
self.canvas.setMapTool(self.previousMapTool)
#self.coordsChanged()
self.emit(SIGNAL("selectionStopped()"))
self.selectionStopped.emit()
def start(self):
prevMapTool = self.canvas.mapTool()
@ -75,18 +80,18 @@ class GdalToolsExtentSelector(QWidget, Ui_ExtentSelector):
self.isStarted = True
self.btnEnable.setVisible(False)
self.coordsChanged()
self.emit(SIGNAL("selectionStarted()"))
self.selectionStarted.emit()
def pause(self):
if not self.isStarted:
return
self.btnEnable.setVisible(True)
self.emit(SIGNAL("selectionPaused()"))
self.selectionPaused.emit()
def setExtent(self, rect):
if self.tool.setRectangle(rect):
self.emit(SIGNAL("newExtentDefined()"))
self.newExtentDefined.emit()
def getExtent(self):
return self.tool.rectangle()
@ -123,10 +128,11 @@ class GdalToolsExtentSelector(QWidget, Ui_ExtentSelector):
self.y1CoordEdit.clear()
self.y2CoordEdit.clear()
self.blockSignals(False)
self.emit(SIGNAL("newExtentDefined()"))
self.newExtentDefined.emit()
class RectangleMapTool(QgsMapToolEmitPoint):
rectangleCreated = pyqtSignal()
def __init__(self, canvas):
self.canvas = canvas
@ -152,9 +158,7 @@ class RectangleMapTool(QgsMapToolEmitPoint):
def canvasReleaseEvent(self, e):
self.isEmittingPoint = False
#if self.rectangle() != None:
# self.emit( SIGNAL("rectangleCreated()") )
self.emit(SIGNAL("rectangleCreated()"))
self.rectangleCreated.emit()
def canvasMoveEvent(self, e):
if not self.isEmittingPoint:
@ -176,7 +180,7 @@ class RectangleMapTool(QgsMapToolEmitPoint):
self.rubberBand.addPoint(point1, False)
self.rubberBand.addPoint(point2, False)
self.rubberBand.addPoint(point3, False)
self.rubberBand.addPoint(point4, True) # true to update canvas
self.rubberBand.addPoint(point4, True) # true to update canvas
self.rubberBand.show()
def rectangle(self):
@ -201,4 +205,4 @@ class RectangleMapTool(QgsMapToolEmitPoint):
def deactivate(self):
QgsMapTool.deactivate(self)
self.emit(SIGNAL("deactivated()"))
self.deactivated.emit()

49
python/plugins/GdalTools/tools/inOutSelector.py
View File

@ -23,12 +23,12 @@ __copyright__ = '(C) 2011, Giuseppe Sucameli'
# This will get replaced with a git SHA1 when you do a git archive
__revision__ = '$Format:%H$'
from PyQt4.QtCore import SIGNAL, Qt, pyqtProperty
from PyQt4.QtGui import QWidget, QComboBox
from PyQt.QtCore import Qt, pyqtSignal, pyqtProperty
from PyQt.QtWidgets import QWidget, QComboBox
from qgis.core import QgsMapLayerRegistry, QgsMapLayer
from ui_inOutSelector import Ui_GdalToolsInOutSelector
from .ui_inOutSelector import Ui_GdalToolsInOutSelector
class GdalToolsInOutSelector(QWidget, Ui_GdalToolsInOutSelector):
@ -40,7 +40,9 @@ class GdalToolsInOutSelector(QWidget, Ui_GdalToolsInOutSelector):
FILES = 0x1 | 0x4 # NOT IMPLEMENTED YET
FILES_LAYER = 0x3 | 0x4 # NOT IMPLEMENTED YET
__pyqtSignals__ = ("selectClicked()", "filenameChanged(), layerChanged()")
selectClicked = pyqtSignal()
filenameChanged = pyqtSignal()
layerChanged = pyqtSignal()
def __init__(self, parent=None, type=None):
QWidget.__init__(self, parent)
@ -57,10 +59,10 @@ class GdalToolsInOutSelector(QWidget, Ui_GdalToolsInOutSelector):
else:
self.setType(type)
self.connect(self.selectBtn, SIGNAL("clicked()"), self.selectButtonClicked)
self.connect(self.fileEdit, SIGNAL("textChanged(const QString &)"), self.textChanged)
self.connect(self.combo, SIGNAL("editTextChanged(const QString &)"), self.textChanged)
self.connect(self.combo, SIGNAL("currentIndexChanged(int)"), self.indexChanged)
self.selectBtn.clicked.connect(self.selectClicked)
self.fileEdit.textChanged.connect(self.textChanged)
self.combo.editTextChanged.connect(self.textChanged)
self.combo.currentIndexChanged.connect(self.indexChanged)
def clear(self):
self.filenames = []
@ -77,20 +79,11 @@ class GdalToolsInOutSelector(QWidget, Ui_GdalToolsInOutSelector):
text = self.combo.currentText()
if text != self.combo.itemText(index):
return self.setFilename(text)
self.filenameChanged()
self.filenameChanged.emit()
def indexChanged(self):
self.layerChanged()
self.filenameChanged()
def selectButtonClicked(self):
self.emit(SIGNAL("selectClicked()"))
def filenameChanged(self):
self.emit(SIGNAL("filenameChanged()"))
def layerChanged(self):
self.emit(SIGNAL("layerChanged()"))
self.layerChanged.emit()
self.filenameChanged.emit()
def setType(self, type):
if type == self.typ:
@ -112,8 +105,8 @@ class GdalToolsInOutSelector(QWidget, Ui_GdalToolsInOutSelector):
self.setFocusProxy(self.combo)
# send signals to refresh connected widgets
self.filenameChanged()
self.layerChanged()
self.filenameChanged.emit()
self.layerChanged.emit()
def getType(self):
return self.typ
@ -154,9 +147,9 @@ class GdalToolsInOutSelector(QWidget, Ui_GdalToolsInOutSelector):
self.blockSignals(False)
if self.filename() != prevFn:
self.filenameChanged()
self.filenameChanged.emit()
if self.layer() != prevLayer:
self.layerChanged()
self.layerChanged.emit()
def setLayer(self, layer=None):
if not (self.getType() & self.LAYER):
@ -182,9 +175,9 @@ class GdalToolsInOutSelector(QWidget, Ui_GdalToolsInOutSelector):
self.blockSignals(False)
if self.filename() != prevFn:
self.filenameChanged()
self.filenameChanged.emit()
if self.layer() != prevLayer:
self.layerChanged()
self.layerChanged.emit()
def setLayers(self, layers=None):
if layers is None or not hasattr(layers, '__iter__') or len(layers) <= 0:
@ -202,9 +195,9 @@ class GdalToolsInOutSelector(QWidget, Ui_GdalToolsInOutSelector):
self.restoreComboState()
self.blockSignals(False)
if self.filename() != prevFn:
self.filenameChanged()
self.filenameChanged.emit()
if self.layer() != prevLayer:
self.layerChanged()
self.layerChanged.emit()
def clearComboState(self):
self.prevState = None

20
python/plugins/GdalTools/tools/optionsTable.py
View File

@ -23,24 +23,26 @@ __copyright__ = '(C) 2010, Giuseppe Sucameli'
# This will get replaced with a git SHA1 when you do a git archive
__revision__ = '$Format:%H$'
from PyQt4.QtCore import SIGNAL
from PyQt4.QtGui import QWidget, QTableWidgetItem
from PyQt.QtCore import pyqtSignal
from PyQt.QtWidgets import QWidget, QTableWidgetItem
from ui_optionsTable import Ui_GdalToolsOptionsTable as Ui_OptionsTable
from .ui_optionsTable import Ui_GdalToolsOptionsTable as Ui_OptionsTable
class GdalToolsOptionsTable(QWidget, Ui_OptionsTable):
rowAdded = pyqtSignal(int)
rowRemoved = pyqtSignal()
def __init__(self, parent=None):
QWidget.__init__(self, parent)
self.setupUi(self)
self.connect(self.table, SIGNAL("cellChanged(int, int)"), SIGNAL("cellValueChanged(int, int)"))
self.table.cellChanged.connect(self.cellValueChanged)
self.connect(self.table, SIGNAL("itemSelectionChanged()"), self.enableDeleteButton)
self.connect(self.btnAdd, SIGNAL("clicked()"), self.addNewRow)
self.connect(self.btnDel, SIGNAL("clicked()"), self.deleteRow)
self.table.itemSelectionChanged.connect(self.enableDeleteButton)
self.btnAdd.clicked.connect(self.addNewRow)
self.btnDel.clicked.connect(self.deleteRow)
self.btnDel.setEnabled(False)
@ -54,7 +56,7 @@ class GdalToolsOptionsTable(QWidget, Ui_OptionsTable):
item = QTableWidgetItem()
self.table.setItem(newRow, 0, item)
self.table.setCurrentItem(item)
self.emit(SIGNAL("rowAdded(int)"), newRow)
self.rowAdded.emit(newRow)
def deleteRow(self):
if self.table.currentRow() >= 0:
@ -62,7 +64,7 @@ class GdalToolsOptionsTable(QWidget, Ui_OptionsTable):
# select the previous row or the next one if there is no previous row
item = self.table.item(self.table.currentRow(), 0)
self.table.setCurrentItem(item)
self.emit(SIGNAL("rowRemoved()"))
self.rowRemoved.emit()
def options(self):
options = []

10
python/plugins/GdalTools/tools/widgetBatchBase.py
View File

@ -23,11 +23,11 @@ __copyright__ = '(C) 2010, Giuseppe Sucameli'
# This will get replaced with a git SHA1 when you do a git archive
__revision__ = '$Format:%H$'
from PyQt4.QtCore import Qt, QFile, QFileInfo
from PyQt4.QtGui import QMessageBox, QErrorMessage
from PyQt.QtCore import Qt, QFile, QFileInfo
from PyQt.QtWidgets import QMessageBox, QErrorMessage
from widgetPluginBase import GdalToolsBasePluginWidget as BasePluginWidget
import GdalTools_utils as Utils
from .widgetPluginBase import GdalToolsBasePluginWidget as BasePluginWidget
from . import GdalTools_utils as Utils
class GdalToolsBaseBatchWidget(BasePluginWidget):
@ -104,7 +104,7 @@ class GdalToolsBaseBatchWidget(BasePluginWidget):
outFile = self.outFiles[index]
args = self.getBatchArguments(self.inFiles[index], outFile)
self.base.refreshArgs(args)
self.base.refreshArgs.emit(args)
BasePluginWidget.onRun(self)
def onFinished(self, exitCode, status):

2
python/plugins/GdalTools/tools/widgetBuildVRT.ui
View File

@ -164,7 +164,7 @@
<customwidget>
<class>GdalToolsInOutSelector</class>
<extends>QWidget</extends>
<header>inOutSelector</header>
<header>.inOutSelector</header>
<container>1</container>
</customwidget>
</customwidgets>

4
python/plugins/GdalTools/tools/widgetClipper.ui
View File

@ -341,13 +341,13 @@
<customwidget>
<class>GdalToolsInOutSelector</class>
<extends>QWidget</extends>
<header>inOutSelector</header>
<header>.inOutSelector</header>
<container>1</container>
</customwidget>
<customwidget>
<class>GdalToolsExtentSelector</class>
<extends>QWidget</extends>
<header>extentSelector</header>
<header>.extentSelector</header>
<container>1</container>
</customwidget>
</customwidgets>

2
python/plugins/GdalTools/tools/widgetContour.ui
View File

@ -135,7 +135,7 @@
<customwidget>
<class>GdalToolsInOutSelector</class>
<extends>QWidget</extends>
<header>inOutSelector</header>
<header>.inOutSelector</header>
<container>1</container>
</customwidget>
</customwidgets>

2
python/plugins/GdalTools/tools/widgetConvert.ui
View File

@ -100,7 +100,7 @@
<customwidget>
<class>GdalToolsInOutSelector</class>
<extends>QWidget</extends>
<header>inOutSelector</header>
<header>.inOutSelector</header>
<container>1</container>
</customwidget>
</customwidgets>

2
python/plugins/GdalTools/tools/widgetDEM.ui
View File

@ -440,7 +440,7 @@
<customwidget>
<class>GdalToolsInOutSelector</class>
<extends>QWidget</extends>
<header>inOutSelector</header>
<header>.inOutSelector</header>
<container>1</container>
</customwidget>
<customwidget>

2
python/plugins/GdalTools/tools/widgetFillNodata.ui
View File

@ -150,7 +150,7 @@
<customwidget>
<class>GdalToolsInOutSelector</class>
<extends>QWidget</extends>
<header>inOutSelector</header>
<header>.inOutSelector</header>
<container>1</container>
</customwidget>
</customwidgets>

4
python/plugins/GdalTools/tools/widgetGrid.ui
View File

@ -822,13 +822,13 @@
<customwidget>
<class>GdalToolsInOutSelector</class>
<extends>QWidget</extends>
<header>inOutSelector</header>
<header>.inOutSelector</header>
<container>1</container>
</customwidget>
<customwidget>
<class>GdalToolsExtentSelector</class>
<extends>QWidget</extends>
<header>extentSelector</header>
<header>.extentSelector</header>
<container>1</container>
</customwidget>
</customwidgets>

2
python/plugins/GdalTools/tools/widgetInfo.ui
View File

@ -77,7 +77,7 @@
<customwidget>
<class>GdalToolsInOutSelector</class>
<extends>QWidget</extends>
<header>inOutSelector</header>
<header>.inOutSelector</header>
<container>1</container>
</customwidget>
</customwidgets>

2
python/plugins/GdalTools/tools/widgetMerge.ui
View File

@ -138,7 +138,7 @@
<customwidget>
<class>GdalToolsInOutSelector</class>
<extends>QWidget</extends>
<header>inOutSelector</header>
<header>.inOutSelector</header>
<container>1</container>
</customwidget>
<customwidget>

2
python/plugins/GdalTools/tools/widgetNearBlack.ui
View File

@ -77,7 +77,7 @@
<customwidget>
<class>GdalToolsInOutSelector</class>
<extends>QWidget</extends>
<header>inOutSelector</header>
<header>.inOutSelector</header>
<container>1</container>
</customwidget>
</customwidgets>

2
python/plugins/GdalTools/tools/widgetOverview.ui
View File

@ -76,7 +76,7 @@
<customwidget>
<class>GdalToolsInOutSelector</class>
<extends>QWidget</extends>
<header>inOutSelector</header>
<header>.inOutSelector</header>
<container>1</container>
</customwidget>
<customwidget>

39
python/plugins/GdalTools/tools/widgetPluginBase.py
View File

@ -23,11 +23,11 @@ __copyright__ = '(C) 2010, Giuseppe Sucameli'
# This will get replaced with a git SHA1 when you do a git archive
__revision__ = '$Format:%H$'
from PyQt4.QtCore import SIGNAL, QFileInfo
from PyQt4.QtGui import QWidget, QMessageBox, QAbstractButton, QGroupBox
from PyQt.QtCore import QFileInfo
from PyQt.QtWidgets import QWidget, QMessageBox, QAbstractButton, QGroupBox
from dialogBase import GdalToolsBaseDialog as BaseDialog
import GdalTools_utils as Utils
from .dialogBase import GdalToolsBaseDialog as BaseDialog
from . import GdalTools_utils as Utils
class GdalToolsBasePluginWidget:
@ -37,26 +37,26 @@ class GdalToolsBasePluginWidget:
self.initialized = False
self.base = BaseDialog(iface.mainWindow(), iface, self, self.windowTitle(), commandName)
self.connect(self.base, SIGNAL("processError(QProcess::ProcessError)"), self.onError)
self.connect(self.base, SIGNAL("processFinished(int, QProcess::ExitStatus)"), self.onFinished)
self.base.processError.connect(self.onError)
self.base.processFinished.connect(self.onFinished)
self.connect(self.base, SIGNAL("okClicked()"), self.onRun)
self.connect(self.base, SIGNAL("closeClicked()"), self.onClosing)
self.connect(self.base, SIGNAL("helpClicked()"), self.onHelp)
self.base.okClicked.connect(self.onRun)
self.base.closeClicked.connect(self.onClosing)
self.base.helpClicked.connect(self.onHelp)
self.connect(self.base, SIGNAL("finished(bool)"), self.finished)
self.connect(self.base, SIGNAL("refreshArgs()"), self.someValueChanged)
self.base.finished.connect(self.finished)
self.base.refreshArgs.connect(self.someValueChanged)
def someValueChanged(self):
if self.initialized:
self.emit(SIGNAL("valuesChanged(PyQt_PyObject)"), self.getArguments())
self.base.valuesChanged.emit(self.getArguments())
def onLayersChanged(self):
pass
def initialize(self):
if not self.initialized:
self.connect(Utils.LayerRegistry.instance(), SIGNAL("layersChanged"), self.onLayersChanged)
Utils.LayerRegistry.instance().layersChanged.connect(self.onLayersChanged)
self.onLayersChanged()
self.initialized = True
self.someValueChanged()
@ -77,7 +77,7 @@ class GdalToolsBasePluginWidget:
self.base.onRun()
def onClosing(self):
self.disconnect(Utils.LayerRegistry.instance(), SIGNAL("layersChanged"), self.onLayersChanged)
Utils.LayerRegistry.instance().layersChanged.disconnect(self.onLayersChanged)
self.base.onClosing()
self.initialized = False
@ -182,7 +182,7 @@ class GdalToolsBasePluginWidget:
if not isinstance(ver, Utils.Version):
ver = Utils.Version(ver)
gdalVer = Utils.GdalConfig.version()
if ver < "0" or (gdalVer is not None and ver > gdalVer):
if ver < Utils.Version("0") or (gdalVer is not None and ver > gdalVer):
wdgt.setVisible(False)
if isinstance(chk, QWidget):
chk.setVisible(False)
@ -198,13 +198,12 @@ class GdalToolsBasePluginWidget:
sgnl = sgnls
if sgnl is not None:
self.connect(wdgt, sgnl, self.someValueChanged)
getattr(wdgt, sgnl).connect(self.someValueChanged)
# set the passed checkbox as widget enabler
if isinstance(chk, bool):
wdgt.setEnabled(chk)
if ( isinstance(chk, QAbstractButton) or isinstance(chk, QGroupBox) ) and \
chk.isCheckable():
if (isinstance(chk, QAbstractButton) or isinstance(chk, QGroupBox)) and chk.isCheckable():
wdgt.setEnabled(chk.isChecked())
self.connect(chk, SIGNAL("toggled(bool)"), wdgt.setEnabled)
self.connect(chk, SIGNAL("toggled(bool)"), self.someValueChanged)
chk.toggled.connect(wdgt.setEnabled)
chk.toggled.connect(self.someValueChanged)

2
python/plugins/GdalTools/tools/widgetPolygonize.ui
View File

@ -76,7 +76,7 @@
<customwidget>
<class>GdalToolsInOutSelector</class>
<extends>QWidget</extends>
<header>inOutSelector</header>
<header>.inOutSelector</header>
<container>1</container>
</customwidget>
</customwidgets>

2
python/plugins/GdalTools/tools/widgetProjection.ui
View File

@ -100,7 +100,7 @@
<customwidget>
<class>GdalToolsInOutSelector</class>
<extends>QWidget</extends>
<header>inOutSelector</header>
<header>.inOutSelector</header>
<container>1</container>
</customwidget>
</customwidgets>

2
python/plugins/GdalTools/tools/widgetProximity.ui
View File

@ -139,7 +139,7 @@
<customwidget>
<class>GdalToolsInOutSelector</class>
<extends>QWidget</extends>
<header>inOutSelector</header>
<header>.inOutSelector</header>
<container>1</container>
</customwidget>
</customwidgets>

2
python/plugins/GdalTools/tools/widgetRasterize.ui
View File

@ -243,7 +243,7 @@
<customwidget>
<class>GdalToolsInOutSelector</class>
<extends>QWidget</extends>
<header>inOutSelector</header>
<header>.inOutSelector</header>
<container>1</container>
</customwidget>
</customwidgets>

2
python/plugins/GdalTools/tools/widgetSieve.ui
View File

@ -91,7 +91,7 @@
<customwidget>
<class>GdalToolsInOutSelector</class>
<extends>QWidget</extends>
<header>inOutSelector</header>
<header>.inOutSelector</header>
<container>1</container>
</customwidget>
</customwidgets>

2
python/plugins/GdalTools/tools/widgetTileIndex.ui
View File

@ -81,7 +81,7 @@
<customwidget>
<class>GdalToolsInOutSelector</class>
<extends>QWidget</extends>
<header>inOutSelector</header>
<header>.inOutSelector</header>
<container>1</container>
</customwidget>
</customwidgets>

2
python/plugins/GdalTools/tools/widgetTranslate.ui
View File

@ -282,7 +282,7 @@ The 'gray' value (from GDAL 1.7.0) enables to expand a dataset with a color tabl
<customwidget>
<class>GdalToolsInOutSelector</class>
<extends>QWidget</extends>
<header>inOutSelector</header>
<header>.inOutSelector</header>
<container>1</container>
</customwidget>
<customwidget>

2
python/plugins/GdalTools/tools/widgetWarp.ui
View File

@ -267,7 +267,7 @@
<customwidget>
<class>GdalToolsInOutSelector</class>
<extends>QWidget</extends>
<header>inOutSelector</header>
<header>.inOutSelector</header>
<container>1</container>
</customwidget>
</customwidgets>