def __init__(self, canvas):
"""Constructor.
:param canvas:
"""
QObject.__init__(self)
self.canvas = canvas
self.legend = QgisLegend(canvas)
self.message_bar = QgsMessageBar(None)
# Set up slots so we can mimic the behaviour of QGIS when layers
# are added.
LOGGER.debug('Initialising canvas...')
# noinspection PyArgumentList
QgsMapLayerRegistry.instance().layersAdded.connect(self.addLayers)
# noinspection PyArgumentList
QgsMapLayerRegistry.instance().layerWasAdded.connect(self.addLayer)
# noinspection PyArgumentList
QgsMapLayerRegistry.instance().removeAll.connect(self.removeAllLayers)
# For processing module
self.destCrs = None
# For keeping track of which layer is active in the legend.
self.active_layer = None
# In the next section of code, we are going to do some monkey patching
# to make the QGIS processing framework think that this mock QGIS IFACE
# instance is the actual one. It will also ensure that the processing
# algorithms are nicely loaded and available for use.
# noinspection PyUnresolvedReferences
from processing.tools import dataobjects
# noinspection PyUnresolvedReferences
import processing
# noinspection PyUnresolvedReferences
from processing.core.Processing import Processing
# pylint: enable=F0401, E0611
processing.classFactory(self)
# We create our own getAlgorithm function below which will will monkey
# patch in to the Processing class in QGIS in order to ensure that the
# Processing.initialize() call is made before asking for an alg.
@staticmethod
def mock_getAlgorithm(name):
"""
Modified version of the original getAlgorithm function.
:param name: Name of the algorithm to load.
:type name: str
:return: An algorithm concrete class.
:rtype: QgsAlgorithm ?
"""
Processing.initialize()
# FIXME: Had some weird bug in QGIS 2.18 MacOSX (KyngChaos)
try:
providers = Processing.algs.values()
except:
providers = Processing.algs().values()
for provider in providers:
if name in provider:
return provider[name]
return None
# Now we let the monkey loose!
Processing.getAlgorithm = mock_getAlgorithm
# We also need to make dataobjects think that this iface is 'the one'
# Note. the placement here (after the getAlgorithm monkey patch above)
# is significant, so don't move it!
dataobjects.iface = self
# set up a layer tree bridge so that new added layers appear in legend
self.layer_tree_root = QgsProject.instance().layerTreeRoot()
self.bridge = QgsLayerTreeMapCanvasBridge(self.layer_tree_root,
self.canvas)
self.bridge.setCanvasLayers()
def __init__(self, iface, db, qgis_utils, parent=None):
QWizard.__init__(self, parent)
self.setupUi(self)
self.iface = iface
self.log = QgsApplication.messageLog()
self._db = db
self.qgis_utils = qgis_utils
self.help_strings = HelpStrings()
self.insert_features_to_layer = InsertFeaturesToLayer()
self.target_layer = None
# Auxiliary data to set nonlinear next pages
self.pages = [self.wizardPage1, self.wizardPage2, self.wizardPage3]
self.dict_pages_ids = {
self.pages[idx]: pid
for idx, pid in enumerate(self.pageIds())
}
# Set connections
self.btn_browse_file.clicked.connect(
make_file_selector(self.txt_file_path,
file_filter=QCoreApplication.translate(
"CreatePointsCadastreWizard",
'CSV File (*.csv *.txt)')))
self.txt_file_path.textChanged.connect(self.file_path_changed)
self.crsSelector.crsChanged.connect(self.crs_changed)
self.crs = QgsCoordinateReferenceSystem()
self.txt_delimiter.textChanged.connect(self.fill_long_lat_combos)
self.known_delimiters = [{
'name': ';',
'value': ';'
}, {
'name': ',',
'value': ','
}, {
'name': 'tab',
'value': '\t'
}, {
'name': 'space',
'value': ' '
}, {
'name': '|',
'value': '|'
}, {
'name': '~',
'value': '~'
}, {
'name': 'Other',
'value': ''
}]
self.cbo_delimiter.addItems(
[item['name'] for item in self.known_delimiters])
self.cbo_delimiter.currentTextChanged.connect(self.separator_changed)
self.restore_settings()
self.txt_file_path.textChanged.emit(self.txt_file_path.text())
self.rad_boundary_point.toggled.connect(self.point_option_changed)
self.rad_control_point.toggled.connect(self.point_option_changed)
self.rad_csv.toggled.connect(self.adjust_page_2_controls)
self.point_option_changed() # Initialize it
self.button(QWizard.FinishButton).clicked.connect(self.finished_dialog)
self.currentIdChanged.connect(self.current_page_changed)
self.mMapLayerComboBox.setFilters(QgsMapLayerProxyModel.PointLayer)
self.txt_help_page_2.setHtml(
self.help_strings.WIZ_ADD_POINTS_CADASTRE_PAGE_2_OPTION_CSV)
self.wizardPage2.setButtonText(
QWizard.FinishButton,
QCoreApplication.translate("CreatePointsCadastreWizard", "Import"))
self.txt_help_page_3.setHtml(
self.help_strings.WIZ_ADD_POINTS_CADASTRE_PAGE_3_OPTION_CSV)
self.txt_help_page_3.anchorClicked.connect(self.save_template)
self.button(QWizard.HelpButton).clicked.connect(self.show_help)
# Set MessageBar for QWizard
self.bar = QgsMessageBar()
self.bar.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed)
self.setLayout(QGridLayout())
self.layout().addWidget(self.bar, 0, 0, Qt.AlignTop)
def __init__(self, parent=None):
super(ShellOutputScintilla,self).__init__(parent)
self.parent = parent
self.shell = self.parent.shell
self.settings = QSettings()
# Creates layout for message bar
self.layout = QGridLayout(self)
self.layout.setContentsMargins(0, 0, 0, 0)
spacerItem = QSpacerItem(20, 40, QSizePolicy.Minimum, QSizePolicy.Expanding)
self.layout.addItem(spacerItem, 1, 0, 1, 1)
# messageBar instance
self.infoBar = QgsMessageBar()
sizePolicy = QSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed)
self.infoBar.setSizePolicy(sizePolicy)
self.layout.addWidget(self.infoBar, 0, 0, 1, 1)
# Enable non-ascii chars for editor
self.setUtf8(True)
sys.stdout = writeOut(self, sys.stdout)
sys.stderr = writeOut(self, sys.stderr, "_traceback")
self.insertInitText()
self.setLexers()
self.setReadOnly(True)
# Set the default font
font = QFont()
font.setFamily('Courier')
font.setFixedPitch(True)
font.setPointSize(10)
self.setFont(font)
self.setMarginsFont(font)
# Margin 0 is used for line numbers
self.setMarginWidth(0, 0)
self.setMarginWidth(1, 0)
self.setMarginWidth(2, 0)
#fm = QFontMetrics(font)
self.setMarginsFont(font)
self.setMarginWidth(1, "00000")
self.setMarginLineNumbers(1, True)
self.setMarginsForegroundColor(QColor("#3E3EE3"))
self.setMarginsBackgroundColor(QColor("#f9f9f9"))
self.setCaretLineVisible(True)
self.setCaretLineBackgroundColor(QColor("#fcf3ed"))
self.setMinimumHeight(120)
self.setWrapMode(QsciScintilla.WrapCharacter)
self.SendScintilla(QsciScintilla.SCI_SETHSCROLLBAR, 0)
self.runScut = QShortcut(QKeySequence(Qt.CTRL + Qt.Key_E), self)
self.runScut.setContext(Qt.WidgetShortcut)
self.runScut.activated.connect(self.enteredSelected)
# Reimplemeted copy action to prevent paste prompt (>>>,...) in command view
self.copyShortcut = QShortcut(QKeySequence.Copy, self)
self.copyShortcut.activated.connect(self.copy)
self.selectAllShortcut = QShortcut(QKeySequence.SelectAll, self)
self.selectAllShortcut.activated.connect(self.selectAll)
def setupUi(self):
self.checkBoxes = {}
self.showAdvanced = False
self.wrappers = {}
self.valueItems = {}
self.dependentItems = {}
self.algorithmItem = None
self.resize(650, 450)
self.buttonBox = QDialogButtonBox()
self.buttonBox.setOrientation(Qt.Horizontal)
self.buttonBox.setStandardButtons(QDialogButtonBox.Cancel
| QDialogButtonBox.Ok
| QDialogButtonBox.Help)
self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.verticalLayout = QVBoxLayout()
self.verticalLayout.setSpacing(5)
self.verticalLayout.setMargin(20)
self.bar = QgsMessageBar()
self.bar.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed)
self.verticalLayout.addWidget(self.bar)
hLayout = QHBoxLayout()
hLayout.setSpacing(5)
hLayout.setMargin(0)
descriptionLabel = QLabel(self.tr("Description"))
self.descriptionBox = QLineEdit()
self.descriptionBox.setText(self._alg.displayName())
hLayout.addWidget(descriptionLabel)
hLayout.addWidget(self.descriptionBox)
self.verticalLayout.addLayout(hLayout)
line = QFrame()
line.setFrameShape(QFrame.HLine)
line.setFrameShadow(QFrame.Sunken)
self.verticalLayout.addWidget(line)
self.algorithmItem = QgsGui.instance().processingGuiRegistry(
).algorithmConfigurationWidget(self._alg)
if self.configuration:
self.algorithmItem.setConfiguration(self.configuration)
self.verticalLayout.addWidget(self.algorithmItem)
widget_context = QgsProcessingParameterWidgetContext()
if iface is not None:
widget_context.setMapCanvas(iface.mapCanvas())
widget_context.setModel(self.model)
widget_context.setModelChildAlgorithmId(self.childId)
for param in self._alg.parameterDefinitions():
if param.flags() & QgsProcessingParameterDefinition.FlagAdvanced:
self.advancedButton = QPushButton()
self.advancedButton.setText(
self.tr('Show advanced parameters'))
self.advancedButton.clicked.connect(
self.showAdvancedParametersClicked)
advancedButtonHLayout = QHBoxLayout()
advancedButtonHLayout.addWidget(self.advancedButton)
advancedButtonHLayout.addStretch()
self.verticalLayout.addLayout(advancedButtonHLayout)
break
for param in self._alg.parameterDefinitions():
if param.isDestination(
) or param.flags() & QgsProcessingParameterDefinition.FlagHidden:
continue
wrapper = WidgetWrapperFactory.create_wrapper(param, self)
self.wrappers[param.name()] = wrapper
if issubclass(wrapper.__class__,
QgsProcessingModelerParameterWidget):
wrapper.setWidgetContext(widget_context)
wrapper.registerProcessingContextGenerator(
self.context_generator)
widget = wrapper
else:
widget = wrapper.widget
if widget is not None:
self.valueItems[param.name()] = widget
if issubclass(wrapper.__class__,
QgsProcessingModelerParameterWidget):
label = wrapper.createLabel()
else:
tooltip = param.description()
widget.setToolTip(tooltip)
label = wrapper.label
self.widget_labels[param.name()] = label
if param.flags(
) & QgsProcessingParameterDefinition.FlagAdvanced:
label.setVisible(self.showAdvanced)
widget.setVisible(self.showAdvanced)
self.verticalLayout.addWidget(label)
self.verticalLayout.addWidget(widget)
for dest in self._alg.destinationParameterDefinitions():
if dest.flags() & QgsProcessingParameterDefinition.FlagHidden:
continue
if isinstance(dest, (QgsProcessingParameterRasterDestination,
QgsProcessingParameterVectorDestination,
QgsProcessingParameterFeatureSink,
QgsProcessingParameterFileDestination,
QgsProcessingParameterFolderDestination)):
label = QLabel(dest.description())
item = QgsFilterLineEdit()
if hasattr(item, 'setPlaceholderText'):
item.setPlaceholderText(
self.tr('[Enter name if this is a final result]'))
self.verticalLayout.addWidget(label)
self.verticalLayout.addWidget(item)
self.valueItems[dest.name()] = item
label = QLabel(' ')
self.verticalLayout.addWidget(label)
label = QLabel(self.tr('Parent algorithms'))
self.dependenciesPanel = self.getDependenciesPanel()
self.verticalLayout.addWidget(label)
self.verticalLayout.addWidget(self.dependenciesPanel)
self.verticalLayout.addStretch(1000)
self.setPreviousValues()
self.setWindowTitle(self._alg.displayName())
self.verticalLayout2 = QVBoxLayout()
self.verticalLayout2.setSpacing(2)
self.verticalLayout2.setMargin(0)
self.paramPanel = QWidget()
self.paramPanel.setLayout(self.verticalLayout)
self.scrollArea = QgsScrollArea()
self.scrollArea.setWidget(self.paramPanel)
self.scrollArea.setWidgetResizable(True)
self.verticalLayout2.addWidget(self.scrollArea)
self.verticalLayout2.addWidget(self.buttonBox)
self.setLayout(self.verticalLayout2)
self.buttonBox.accepted.connect(self.okPressed)
self.buttonBox.rejected.connect(self.cancelPressed)
self.buttonBox.helpRequested.connect(self.openHelp)
QMetaObject.connectSlotsByName(self)
def __init__(self, model=None):
super(ModelerDialog, self).__init__(None)
self.setupUi(self)
self.bar = QgsMessageBar()
self.bar.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed)
self.centralWidget().layout().insertWidget(0, self.bar)
try:
self.setDockOptions(self.dockOptions()
| QMainWindow.GroupedDragging)
except:
pass
self.mToolbar.setIconSize(iface.iconSize())
self.mActionOpen.setIcon(
QgsApplication.getThemeIcon('/mActionFileOpen.svg'))
self.mActionSave.setIcon(
QgsApplication.getThemeIcon('/mActionFileSave.svg'))
self.mActionSaveAs.setIcon(
QgsApplication.getThemeIcon('/mActionFileSaveAs.svg'))
self.mActionZoomActual.setIcon(
QgsApplication.getThemeIcon('/mActionZoomActual.svg'))
self.mActionZoomIn.setIcon(
QgsApplication.getThemeIcon('/mActionZoomIn.svg'))
self.mActionZoomOut.setIcon(
QgsApplication.getThemeIcon('/mActionZoomOut.svg'))
self.mActionExportImage.setIcon(
QgsApplication.getThemeIcon('/mActionSaveMapAsImage.svg'))
self.mActionZoomToItems.setIcon(
QgsApplication.getThemeIcon('/mActionZoomFullExtent.svg'))
self.mActionExportPdf.setIcon(
QgsApplication.getThemeIcon('/mActionSaveAsPDF.svg'))
self.mActionExportSvg.setIcon(
QgsApplication.getThemeIcon('/mActionSaveAsSVG.svg'))
self.mActionExportPython.setIcon(
QgsApplication.getThemeIcon('/mActionSaveAsPython.svg'))
self.mActionEditHelp.setIcon(
QgsApplication.getThemeIcon('/mActionEditHelpContent.svg'))
self.mActionRun.setIcon(
QgsApplication.getThemeIcon('/mActionStart.svg'))
self.addDockWidget(Qt.LeftDockWidgetArea, self.propertiesDock)
self.addDockWidget(Qt.LeftDockWidgetArea, self.inputsDock)
self.addDockWidget(Qt.LeftDockWidgetArea, self.algorithmsDock)
self.tabifyDockWidget(self.inputsDock, self.algorithmsDock)
self.inputsDock.raise_()
self.zoom = 1
self.setWindowFlags(Qt.WindowMinimizeButtonHint
| Qt.WindowMaximizeButtonHint
| Qt.WindowCloseButtonHint)
settings = QgsSettings()
self.restoreState(
settings.value("/Processing/stateModeler", QByteArray()))
self.restoreGeometry(
settings.value("/Processing/geometryModeler", QByteArray()))
self.scene = ModelerScene(self, dialog=self)
self.scene.setSceneRect(
QRectF(0, 0, self.CANVAS_SIZE, self.CANVAS_SIZE))
self.view.setScene(self.scene)
self.view.setAcceptDrops(True)
self.view.ensureVisible(0, 0, 10, 10)
def _dragEnterEvent(event):
if event.mimeData().hasText():
event.acceptProposedAction()
else:
event.ignore()
def _dropEvent(event):
if event.mimeData().hasText():
text = event.mimeData().text()
if text in ModelerParameterDefinitionDialog.paramTypes:
self.addInputOfType(text, event.pos())
else:
alg = QgsApplication.processingRegistry(
).createAlgorithmById(text)
if alg is not None:
self._addAlgorithm(alg, event.pos())
event.accept()
else:
event.ignore()
def _dragMoveEvent(event):
if event.mimeData().hasText():
event.accept()
else:
event.ignore()
def _wheelEvent(event):
self.view.setTransformationAnchor(QGraphicsView.AnchorUnderMouse)
settings = QgsSettings()
factor = settings.value('/qgis/zoom_favor', 2.0)
# "Normal" mouse has an angle delta of 120, precision mouses provide data
# faster, in smaller steps
factor = 1.0 + (factor - 1.0) / 120.0 * abs(event.angleDelta().y())
if (event.modifiers() == Qt.ControlModifier):
factor = 1.0 + (factor - 1.0) / 20.0
if event.angleDelta().y() < 0:
factor = 1 / factor
self.view.scale(factor, factor)
def _enterEvent(e):
QGraphicsView.enterEvent(self.view, e)
self.view.viewport().setCursor(Qt.ArrowCursor)
def _mouseReleaseEvent(e):
QGraphicsView.mouseReleaseEvent(self.view, e)
self.view.viewport().setCursor(Qt.ArrowCursor)
def _mousePressEvent(e):
if e.button() == Qt.MidButton:
self.previousMousePos = e.pos()
else:
QGraphicsView.mousePressEvent(self.view, e)
def _mouseMoveEvent(e):
if e.buttons() == Qt.MidButton:
offset = self.previousMousePos - e.pos()
self.previousMousePos = e.pos()
self.view.verticalScrollBar().setValue(
self.view.verticalScrollBar().value() + offset.y())
self.view.horizontalScrollBar().setValue(
self.view.horizontalScrollBar().value() + offset.x())
else:
QGraphicsView.mouseMoveEvent(self.view, e)
self.view.setDragMode(QGraphicsView.ScrollHandDrag)
self.view.dragEnterEvent = _dragEnterEvent
self.view.dropEvent = _dropEvent
self.view.dragMoveEvent = _dragMoveEvent
self.view.wheelEvent = _wheelEvent
self.view.enterEvent = _enterEvent
self.view.mousePressEvent = _mousePressEvent
self.view.mouseMoveEvent = _mouseMoveEvent
def _mimeDataInput(items):
mimeData = QMimeData()
text = items[0].text(0)
mimeData.setText(text)
return mimeData
self.inputsTree.mimeData = _mimeDataInput
self.inputsTree.setDragDropMode(QTreeWidget.DragOnly)
self.inputsTree.setDropIndicatorShown(True)
def _mimeDataAlgorithm(items):
item = items[0]
if isinstance(item, TreeAlgorithmItem):
mimeData = QMimeData()
mimeData.setText(item.alg.id())
return mimeData
self.algorithmTree.mimeData = _mimeDataAlgorithm
self.algorithmTree.setDragDropMode(QTreeWidget.DragOnly)
self.algorithmTree.setDropIndicatorShown(True)
if hasattr(self.searchBox, 'setPlaceholderText'):
self.searchBox.setPlaceholderText(self.tr('Search...'))
if hasattr(self.textName, 'setPlaceholderText'):
self.textName.setPlaceholderText(self.tr('Enter model name here'))
if hasattr(self.textGroup, 'setPlaceholderText'):
self.textGroup.setPlaceholderText(self.tr('Enter group name here'))
# Connect signals and slots
self.inputsTree.doubleClicked.connect(self.addInput)
self.searchBox.textChanged.connect(self.fillAlgorithmTree)
self.algorithmTree.doubleClicked.connect(self.addAlgorithm)
# Ctrl+= should also trigger a zoom in action
ctrlEquals = QShortcut(QKeySequence("Ctrl+="), self)
ctrlEquals.activated.connect(self.zoomIn)
self.mActionOpen.triggered.connect(self.openModel)
self.mActionSave.triggered.connect(self.save)
self.mActionSaveAs.triggered.connect(self.saveAs)
self.mActionZoomIn.triggered.connect(self.zoomIn)
self.mActionZoomOut.triggered.connect(self.zoomOut)
self.mActionZoomActual.triggered.connect(self.zoomActual)
self.mActionZoomToItems.triggered.connect(self.zoomToItems)
self.mActionExportImage.triggered.connect(self.exportAsImage)
self.mActionExportPdf.triggered.connect(self.exportAsPdf)
self.mActionExportSvg.triggered.connect(self.exportAsSvg)
self.mActionExportPython.triggered.connect(self.exportAsPython)
self.mActionEditHelp.triggered.connect(self.editHelp)
self.mActionRun.triggered.connect(self.runModel)
if model is not None:
self.model = model.create()
self.model.setSourceFilePath(model.sourceFilePath())
self.textGroup.setText(self.model.group())
self.textName.setText(self.model.displayName())
self.repaintModel()
else:
self.model = QgsProcessingModelAlgorithm()
self.model.setProvider(
QgsApplication.processingRegistry().providerById('model'))
self.fillInputsTree()
self.fillAlgorithmTree()
self.view.centerOn(0, 0)
self.help = None
self.hasChanged = False
def setupUi(self):
self.labels = {}
self.widgets = {}
self.checkBoxes = {}
self.showAdvanced = False
self.valueItems = {}
self.dependentItems = {}
self.resize(650, 450)
self.buttonBox = QDialogButtonBox()
self.buttonBox.setOrientation(Qt.Horizontal)
self.buttonBox.setStandardButtons(QDialogButtonBox.Cancel
| QDialogButtonBox.Ok)
tooltips = self._alg.getParameterDescriptions()
self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.verticalLayout = QVBoxLayout()
self.verticalLayout.setSpacing(5)
self.verticalLayout.setMargin(20)
self.bar = QgsMessageBar()
self.bar.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed)
self.verticalLayout.addWidget(self.bar)
hLayout = QHBoxLayout()
hLayout.setSpacing(5)
hLayout.setMargin(0)
descriptionLabel = QLabel(self.tr("Description"))
self.descriptionBox = QLineEdit()
self.descriptionBox.setText(self._alg.name)
hLayout.addWidget(descriptionLabel)
hLayout.addWidget(self.descriptionBox)
self.verticalLayout.addLayout(hLayout)
line = QFrame()
line.setFrameShape(QFrame.HLine)
line.setFrameShadow(QFrame.Sunken)
self.verticalLayout.addWidget(line)
for param in self._alg.parameters:
if param.isAdvanced:
self.advancedButton = QPushButton()
self.advancedButton.setText(
self.tr('Show advanced parameters'))
self.advancedButton.clicked.connect(
self.showAdvancedParametersClicked)
advancedButtonHLayout = QHBoxLayout()
advancedButtonHLayout.addWidget(self.advancedButton)
advancedButtonHLayout.addStretch()
self.verticalLayout.addLayout(advancedButtonHLayout)
break
for param in self._alg.parameters:
if param.hidden:
continue
desc = param.description
if isinstance(param, ParameterExtent):
desc += self.tr('(xmin, xmax, ymin, ymax)')
if isinstance(param, ParameterPoint):
desc += self.tr('(x, y)')
label = QLabel(desc)
self.labels[param.name] = label
widget = self.getWidgetFromParameter(param)
self.valueItems[param.name] = widget
if param.name in tooltips.keys():
tooltip = tooltips[param.name]
else:
tooltip = param.description
label.setToolTip(tooltip)
widget.setToolTip(tooltip)
if param.isAdvanced:
label.setVisible(self.showAdvanced)
widget.setVisible(self.showAdvanced)
self.widgets[param.name] = widget
self.verticalLayout.addWidget(label)
self.verticalLayout.addWidget(widget)
for output in self._alg.outputs:
if output.hidden:
continue
if isinstance(output, (OutputRaster, OutputVector, OutputTable,
OutputHTML, OutputFile, OutputDirectory)):
label = QLabel(output.description + '<' +
output.__class__.__name__ + '>')
item = QLineEdit()
if hasattr(item, 'setPlaceholderText'):
item.setPlaceholderText(ModelerParametersDialog.ENTER_NAME)
self.verticalLayout.addWidget(label)
self.verticalLayout.addWidget(item)
self.valueItems[output.name] = item
label = QLabel(' ')
self.verticalLayout.addWidget(label)
label = QLabel(self.tr('Parent algorithms'))
self.dependenciesPanel = self.getDependenciesPanel()
self.verticalLayout.addWidget(label)
self.verticalLayout.addWidget(self.dependenciesPanel)
self.verticalLayout.addStretch(1000)
self.setLayout(self.verticalLayout)
self.setPreviousValues()
self.setWindowTitle(self._alg.name)
self.verticalLayout2 = QVBoxLayout()
self.verticalLayout2.setSpacing(2)
self.verticalLayout2.setMargin(0)
self.tabWidget = QTabWidget()
self.tabWidget.setMinimumWidth(300)
self.paramPanel = QWidget()
self.paramPanel.setLayout(self.verticalLayout)
self.scrollArea = QScrollArea()
self.scrollArea.setWidget(self.paramPanel)
self.scrollArea.setWidgetResizable(True)
self.tabWidget.addTab(self.scrollArea, self.tr('Parameters'))
self.txtHelp = QTextBrowser()
html = None
isText, algHelp = self._alg.help()
if algHelp is not None:
algHelp = algHelp if isText else QUrl(algHelp)
try:
if isText:
self.txtHelp.setHtml(algHelp)
else:
html = self.tr(
'<p>Downloading algorithm help... Please wait.</p>')
self.txtHelp.setHtml(html)
self.reply = QgsNetworkAccessManager.instance().get(
QNetworkRequest(algHelp))
self.reply.finished.connect(self.requestFinished)
except:
self.txtHelp.setHtml(
self.tr('<h2>No help available for this algorithm</h2>'))
self.tabWidget.addTab(self.txtHelp, 'Help')
self.verticalLayout2.addWidget(self.tabWidget)
self.verticalLayout2.addWidget(self.buttonBox)
self.setLayout(self.verticalLayout2)
self.buttonBox.accepted.connect(self.okPressed)
self.buttonBox.rejected.connect(self.cancelPressed)
QMetaObject.connectSlotsByName(self)
def __init__(self, iface, base_config, parent=None):
QDialog.__init__(self, parent)
self.iface = iface
self.setupUi(self)
QgsGui.instance().enableAutoGeometryRestore(self)
self.db_simple_factory = DbSimpleFactory()
self.buttonBox.accepted.disconnect()
self.buttonBox.clear()
self.buttonBox.addButton(QDialogButtonBox.Cancel)
self.buttonBox.addButton(QDialogButtonBox.Help)
self.buttonBox.helpRequested.connect(self.help_requested)
self.import_text = self.tr('Import Data')
self.set_button_to_import_action = QAction(self.import_text, None)
self.set_button_to_import_action.triggered.connect(
self.set_button_to_import)
self.import_without_validation_text = self.tr(
'Import without validation')
self.set_button_to_import_without_validation_action = QAction(
self.import_without_validation_text, None)
self.set_button_to_import_without_validation_action.triggered.connect(
self.set_button_to_import_without_validation)
self.edit_command_action = QAction(self.tr('Edit ili2db command'),
None)
self.edit_command_action.triggered.connect(self.edit_command)
self.import_tool_button.addAction(
self.set_button_to_import_without_validation_action)
self.import_tool_button.addAction(self.edit_command_action)
self.import_tool_button.setText(self.import_text)
self.import_tool_button.clicked.connect(self.accepted)
self.xtf_file_browse_button.clicked.connect(
make_file_selector(
self.xtf_file_line_edit,
title=self.tr('Open Transfer or Catalog File'),
file_filter=self.
tr('Transfer File (*.xtf *.itf *.XTF *.ITF);;Catalogue File (*.xml *.XML *.xls *.XLS *.xlsx *.XLSX)'
)))
self.type_combo_box.clear()
self._lst_panel = dict()
for db_id in self.db_simple_factory.get_db_list(False):
self.type_combo_box.addItem(displayDbIliMode[db_id], db_id)
db_factory = self.db_simple_factory.create_factory(db_id)
item_panel = db_factory.get_config_panel(self,
DbActionType.IMPORT_DATA)
self._lst_panel[db_id] = item_panel
self.db_layout.addWidget(item_panel)
self.type_combo_box.currentIndexChanged.connect(self.type_changed)
self.ili2db_options = Ili2dbOptionsDialog()
self.ili2db_options_button.clicked.connect(self.ili2db_options.open)
self.ili2db_options.finished.connect(self.fill_toml_file_info_label)
self.multiple_models_dialog = MultipleModelsDialog(self)
self.multiple_models_button.clicked.connect(
self.multiple_models_dialog.open)
self.multiple_models_dialog.accepted.connect(
self.fill_models_line_edit)
self.validate_data = True # validates imported data by default, We use --disableValidation when is False
self.base_configuration = base_config
self.restore_configuration()
self.validators = Validators()
fileValidator = FileValidator(
pattern=['*.' + ext for ext in self.ValidExtensions])
self.xtf_file_line_edit.setValidator(fileValidator)
self.ili_models_line_edit.setPlaceholderText(
self.tr('[Search model in repository]'))
self.ili_models_line_edit.textChanged.connect(
self.complete_models_completer)
self.ili_models_line_edit.punched.connect(
self.complete_models_completer)
self.xtf_file_line_edit.textChanged.connect(
self.validators.validate_line_edits)
self.xtf_file_line_edit.textChanged.emit(
self.xtf_file_line_edit.text())
# Reset to import as default text
self.xtf_file_line_edit.textChanged.connect(self.set_button_to_import)
settings = QSettings()
ilifile = settings.value('QgisModelBaker/ili2db/ilifile')
self.ilicache = IliCache(base_config, ilifile or None)
self.update_models_completer()
self.ilicache.refresh()
self.bar = QgsMessageBar()
self.bar.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed)
self.txtStdout.setLayout(QGridLayout())
self.txtStdout.layout().setContentsMargins(0, 0, 0, 0)
self.txtStdout.layout().addWidget(self.bar, 0, 0, Qt.AlignTop)
def initGui(self):
"""
Create all the icons and setup the tool bars. Called by QGIS when
loading. This is called before setupUI.
"""
QApplication.setWindowIcon(QIcon(":/branding/logo"))
self.mainwindow.findChildren(QMenuBar)[0].setVisible(False)
self.mainwindow.setContextMenuPolicy(Qt.PreventContextMenu)
self.mainwindow.setWindowTitle("IntraMaps Roam: Mobile Data Collection")
# Disable QGIS logging window popups. We do our own logging
QgsMessageLog.instance().messageReceived.disconnect()
s = """
QToolButton {
padding: 6px;
color: #4f4f4f;
}
QToolButton:hover {
padding: 6px;
background-color: rgb(211, 228, 255);
}
QToolBar {
background: white;
}
QCheckBox::indicator {
width: 40px;
height: 40px;
}
QLabel {
color: #4f4f4f;
}
QDialog { background-color: rgb(255, 255, 255); }
QPushButton {
border: 1px solid #e1e1e1;
padding: 6px;
color: #4f4f4f;
}
QPushButton:hover {
border: 1px solid #e1e1e1;
padding: 6px;
background-color: rgb(211, 228, 255);
}
QCheckBox {
color: #4f4f4f;
}
QComboBox::drop-down {
width: 30px;
}
"""
self.mainwindow.setStyleSheet(s)
mainwidget = self.mainwindow.centralWidget()
mainwidget.setLayout(QGridLayout())
mainwidget.layout().setContentsMargins(0,0,0,0)
newlayout = QGridLayout()
newlayout.setContentsMargins(0,0,0,0)
newlayout.addWidget(self.iface.mapCanvas(), 0,0,2,1)
newlayout.addWidget(self.iface.messageBar(), 0,0,1,1)
wid = QWidget()
wid.setLayout(newlayout)
self.stack = QStackedWidget()
self.messageBar = QgsMessageBar(wid)
self.messageBar.setSizePolicy( QSizePolicy.Minimum, QSizePolicy.Fixed )
self.errorreport = PopDownReport(self.messageBar)
mainwidget.layout().addWidget(self.stack, 0,0,2,1)
mainwidget.layout().addWidget(self.messageBar, 0,0,1,1)
self.helppage = HelpPage()
helppath = os.path.join(os.path.dirname(__file__) , 'help',"help.html")
self.helppage.setHelpPage(helppath)
self.projectwidget = ProjectsWidget()
self.projectwidget.requestOpenProject.connect(self.loadProject)
self.stack.addWidget(wid)
self.stack.addWidget(self.projectwidget)
self.stack.addWidget(self.helppage)
sys.excepthook = self.excepthook
def createSpacer(width=30):
widget = QWidget()
widget.setMinimumWidth(width)
return widget
self.createToolBars()
self.createActions()
spacewidget = createSpacer(60)
gpsspacewidget = createSpacer()
gpsspacewidget.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.moveaction.toggled.connect(functools.partial(self.setMapTool, self.movetool))
showediting = (functools.partial(self.editingtoolbar.showToolbar,
self.editingmodeaction,
self.editattributesaction))
self.editingmodeaction.toggled.connect(showediting)
self.addatgpsaction.triggered.connect(self.addAtGPS)
self.addatgpsaction.setEnabled(self.gpsAction.isConnected)
self.gpsAction.gpsfixed.connect(self.addatgpsaction.setEnabled)
self.editingtoolbar.addToActionGroup(self.editattributesaction)
self.editingtoolbar.addToActionGroup(self.moveaction)
self.actionGroup.addAction(self.editingmodeaction)
self.homeAction.triggered.connect(self.zoomToDefaultView)
self.openProjectAction.triggered.connect(self.showOpenProjectDialog)
self.openProjectAction.triggered.connect(functools.partial(self.stack.setCurrentIndex, 1))
self.toggleRasterAction.triggered.connect(self.toggleRasterLayers)
self.navtoolbar.insertAction(self.iface.actionZoomIn(), self.iface.actionTouch())
self.navtoolbar.insertAction(self.iface.actionTouch(), self.homeAction)
self.navtoolbar.insertAction(self.iface.actionTouch(), self.iface.actionZoomFullExtent())
self.navtoolbar.insertAction(self.homeAction, self.iface.actionZoomFullExtent())
self.navtoolbar.addAction(self.toggleRasterAction)
self.navtoolbar.insertWidget(self.iface.actionZoomFullExtent(), spacewidget)
self.toolbar.addAction(self.editingmodeaction)
self.toolbar.addAction(self.syncAction)
self.toolbar.addAction(self.gpsAction)
self.toolbar.insertWidget(self.syncAction, gpsspacewidget)
self.toolbar.insertSeparator(self.gpsAction)
self.extraaddtoolbar.addAction(self.addatgpsaction)
self.editingtoolbar.addAction(self.editattributesaction)
self.editingtoolbar.addAction(self.moveaction)
self.mapview = QAction(QIcon(":/icons/map"), "Map", self.menutoolbar)
self.mapview.setCheckable(True)
self.mapview.triggered.connect(functools.partial(self.stack.setCurrentIndex, 0))
self.help = QAction(QIcon(":/icons/help"), "Help", self.menutoolbar)
self.help.setCheckable(True)
self.help.triggered.connect(functools.partial(self.stack.setCurrentIndex, 2))
self.help.setVisible(False)
self.userlabel = QLabel("Current User <br> {user}".format(user=getpass.getuser()))
self.userlabel.setAlignment(Qt.AlignCenter)
self.userlabel.setStyleSheet("""
QLabel {
color: #8c8c8c;
font: 10px "Calibri" ;
}""")
self.quit = QAction(QIcon(":/icons/quit"), "Quit", self.menutoolbar)
self.quit.triggered.connect(self.iface.actionExit().trigger)
self.menuGroup.addAction(self.mapview)
self.menuGroup.addAction(self.openProjectAction)
self.menuGroup.addAction(self.help)
self.menutoolbar.addAction(self.mapview)
self.menutoolbar.addAction(self.openProjectAction)
self.menutoolbar.addAction(self.help)
self.menutoolbar.addAction(self.quit)
quitspacewidget = createSpacer()
quitspacewidget.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
labelaction = self.menutoolbar.insertWidget(self.quit, self.userlabel)
self.menutoolbar.insertWidget(labelaction, quitspacewidget)
self.setupIcons()
self.stack.currentChanged.connect(self.updateUIState)
def __init__(self,
iface,
qgis_utils,
conn_manager,
context,
selected_models=list(),
link_to_import_data=True):
QDialog.__init__(self)
self.iface = iface
self.conn_manager = conn_manager
self.selected_models = selected_models
self.link_to_import_data = link_to_import_data
self.logger = Logger()
self.java_utils = JavaUtils()
self.java_utils.download_java_completed.connect(
self.download_java_complete)
self.java_utils.download_java_progress_changed.connect(
self.download_java_progress_change)
self.db_source = context.get_db_sources()[0]
self.db = self.conn_manager.get_db_connector_from_source(
self.db_source)
self.qgis_utils = qgis_utils
self.base_configuration = BaseConfiguration()
self.ilicache = IliCache(self.base_configuration)
self._dbs_supported = ConfigDbSupported()
self._running_tool = False
# There may be two cases where we need to emit a db_connection_changed from the Schema Import dialog:
# 1) Connection Settings was opened and the DB conn was changed.
# 2) Connection Settings was never opened but the Schema Import ran successfully, in a way that new models may
# convert a db/schema LADM-COL compliant.
self._db_was_changed = False # To postpone calling refresh gui until we close this dialog instead of settings
# Similarly, we could call a refresh on layers and relations cache in two cases:
# 1) If the SI dialog was called for the COLLECTED source: opening Connection Settings and changing the DB
# connection.
# 2) Not opening the Connection Settings, but running a successful Schema Import on the COLLECTED DB, which
# invalidates the cache as models change.
self._schedule_layers_and_relations_refresh = False
self.setupUi(self)
self.validators = Validators()
self.update_import_models()
self.previous_item = QListWidgetItem()
self.connection_setting_button.clicked.connect(self.show_settings)
self.connection_setting_button.setText(
QCoreApplication.translate("DialogImportSchema",
"Connection Settings"))
# CRS Setting
self.epsg = DEFAULT_EPSG
self.crsSelector.crsChanged.connect(self.crs_changed)
# LOG
self.log_config.setTitle(
QCoreApplication.translate("DialogImportSchema", "Show log"))
self.buttonBox.accepted.disconnect()
self.buttonBox.clicked.connect(self.accepted_import_schema)
self.buttonBox.clear()
self.buttonBox.addButton(QDialogButtonBox.Cancel)
self._accept_button = self.buttonBox.addButton(
self.BUTTON_NAME_CREATE_STRUCTURE, QDialogButtonBox.AcceptRole)
self.buttonBox.addButton(QDialogButtonBox.Help)
self.buttonBox.helpRequested.connect(self.show_help)
self.import_models_list_widget.setDisabled(bool(
selected_models)) # If we got models from params, disable panel
self.update_connection_info()
self.restore_configuration()
self.bar = QgsMessageBar()
self.bar.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed)
self.layout().addWidget(self.bar, 0, 0, Qt.AlignTop)
def __init__(self):
super(ServerConnectionsWidget, self).__init__()
self.currentServer = None
self.setupUi(self)
self.addMenuToButtonNew()
self.addAuthWidgets()
self.buttonRemove.clicked.connect(self.buttonRemoveClicked)
self.populateServers()
self.listServers.currentItemChanged.connect(self.currentServerChanged)
self.bar = QgsMessageBar()
self.bar.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed)
self.layout().insertWidget(0, self.bar)
self.setCurrentServer(None)
self.buttonSave.clicked.connect(self.saveButtonClicked)
self.comboGeoserverDataStorage.currentIndexChanged.connect(
self.geoserverDatastorageChanged)
self.btnConnectGeoserver.clicked.connect(self.testConnectionGeoserver)
self.btnConnectPostgis.clicked.connect(self.testConnectionPostgis)
self.btnConnectGeocatLive.clicked.connect(
self.testConnectionGeocatLive)
self.btnConnectCsw.clicked.connect(self.testConnectionCsw)
self.btnAddDatastore.clicked.connect(self.addPostgisDatastore)
self.btnRefreshDatabases.clicked.connect(
self.populatePostgisComboWithGeoserverPostgisServers)
self.txtCswName.textChanged.connect(self._setCurrentServerHasChanges)
self.txtCswNode.textChanged.connect(self._setCurrentServerHasChanges)
self.txtGeoserverName.textChanged.connect(
self._setCurrentServerHasChanges)
self.txtPostgisName.textChanged.connect(
self._setCurrentServerHasChanges)
self.txtGeoserverUrl.textChanged.connect(
self._setCurrentServerHasChanges)
self.txtGeocatLiveName.textChanged.connect(
self._setCurrentServerHasChanges)
self.txtCswUrl.textChanged.connect(self._setCurrentServerHasChanges)
self.txtPostgisServerAddress.textChanged.connect(
self._setCurrentServerHasChanges)
self.txtPostgisPort.textChanged.connect(
self._setCurrentServerHasChanges)
self.txtPostgisSchema.textChanged.connect(
self._setCurrentServerHasChanges)
self.txtPostgisDatabase.textChanged.connect(
self._setCurrentServerHasChanges)
self.txtGeocatLiveIdentifier.textChanged.connect(
self._setCurrentServerHasChanges)
self.comboMetadataProfile.currentIndexChanged.connect(
self._setCurrentServerHasChanges)
self.comboGeoserverDatabase.currentIndexChanged.connect(
self._setCurrentServerHasChanges)
self.radioLocalPath.toggled.connect(self.mapserverStorageChanged)
self.fileMapserver.setStorageMode(QgsFileWidget.GetDirectory)
self.btnSaveServers.clicked.connect(self.saveServers)
self.btnLoadServers.clicked.connect(self.loadServers)
self.comboMetadataProfile.setVisible(False)
self.labelMetadataProfile.setVisible(False)
def __init__(self, iface, settings, parent=None):
"""Constructor."""
super(ImgSearchDialog, self).__init__(parent)
# Set up the user interface from Designer.
# After setupUI you can access any designer object by doing
# self.<objectname>, and you can use autoconnect slots - see
# http://qt-project.org/doc/qt-4.8/designer-using-a-ui-file.html
# #widgets-and-dialogs-with-auto-connect
self.iface = iface
self.setupUi(self)
self.settings = settings
self.setWindowFlags(Qt.WindowCloseButtonHint |
Qt.WindowMinimizeButtonHint)
# initialize GUI
self.initGui()
# self.buttonBox.button(QDialogButtonBox.Ok).setText('Save')
self.bar = QgsMessageBar()
self.bar.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed)
self.verticalLayoutListWidget.layout().addWidget(self.bar)
# event handling
self.pushButtonSearch.clicked.connect(self.startSearch)
# self.returnPressed.connect(self.startSearch)
# self.pushButtonSearchLatest.clicked.connect(self.searchLatest)
# self.pushButtonBrowseLocation.clicked.connect(self.browseLocation)
self.connect(self.listWidget, QtCore.SIGNAL(
"itemClicked(QListWidgetItem *)"),
self.browseThumbnailAndMeta)
self.pbSetDefault.clicked.connect(self.setDeafult)
self.pbLoadDefault.clicked.connect(self.loadDeafult)
"""
# self.buttonBox.clicked.connect(lambda: self.test(self.buttonBox))
self.connect(self.buttonBox,
QtCore.SIGNAL('accepted()'),
self.execOk)
self.connect(self.buttonBox,
QtCore.SIGNAL('rejected()'),
self.execCancel)
"""
# disable some GUIs
# self.pushButtonBrowseLocation.hide()
# self.pushButtonSearchLatest.hide()
# add objects for catalog access
self.settings.beginGroup("Storage")
if self.settings.value('CATALOG_URL') is None or \
str(self.settings.value('CATALOG_URL')) == '':
# self.catalogUrl = "https://oam-catalog.herokuapp.com"
self.catalogUrl = "http://api.openaerialmap.org"
else:
self.catalogUrl = str(self.settings.value('CATALOG_URL'))
self.settings.endGroup()
self.oamCatalogAccess = OAMCatalogAccess(self.catalogUrl)
catalogUrlLabel = self.catalog_url_label.text() + self.catalogUrl
self.catalog_url_label.setText(catalogUrlLabel)
self.imgBrowser = None
def __init__(self, iface, db, qgis_utils):
QDialog.__init__(self)
self.setupUi(self)
QgsGui.instance().enableAutoGeometryRestore(self)
self.iface = iface
self.db = db
self.qgis_utils = qgis_utils
self.base_configuration = BaseConfiguration()
self.ilicache = IliCache(self.base_configuration)
self.ilicache.refresh()
self._conf_db = ConfigDbSupported()
self._params = None
self._current_db = None
self.xtf_file_browse_button.clicked.connect(
make_save_file_selector(
self.xtf_file_line_edit,
title=QCoreApplication.translate("DialogExportData",
"Save in XTF Transfer File"),
file_filter=QCoreApplication.translate(
"DialogExportData",
"XTF Transfer File (*.xtf);;Interlis 1 Transfer File (*.itf);;XML (*.xml);;GML (*.gml)"
),
extension='.xtf',
extensions=['.' + ext for ext in self.ValidExtensions]))
self.xtf_file_browse_button.clicked.connect(
self.xtf_browser_opened_to_true)
self.xtf_browser_was_opened = False
self.validators = Validators()
fileValidator = FileValidator(
pattern=['*.' + ext for ext in self.ValidExtensions],
allow_non_existing=True)
self.xtf_file_line_edit.setPlaceholderText(
QCoreApplication.translate("DialogExportData",
"[Name of the XTF to be created]"))
self.xtf_file_line_edit.setValidator(fileValidator)
self.xtf_file_line_edit.textChanged.connect(
self.validators.validate_line_edits)
self.xtf_file_line_edit.textChanged.connect(
self.xtf_browser_opened_to_false)
self.xtf_file_line_edit.textChanged.emit(
self.xtf_file_line_edit.text())
self.connection_setting_button.clicked.connect(self.show_settings)
self.connection_setting_button.setText(
QCoreApplication.translate("DialogExportData",
"Connection Settings"))
# LOG
self.log_config.setTitle(
QCoreApplication.translate("DialogExportData", "Show log"))
self.log_config.setFlat(True)
self.bar = QgsMessageBar()
self.bar.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed)
self.layout().addWidget(self.bar, 0, 0, Qt.AlignTop)
self.buttonBox.accepted.disconnect()
self.buttonBox.accepted.connect(self.accepted)
self.buttonBox.clear()
self.buttonBox.addButton(QDialogButtonBox.Cancel)
self._accept_button = self.buttonBox.addButton(
QCoreApplication.translate("DialogExportData", "Export data"),
QDialogButtonBox.AcceptRole)
self.buttonBox.addButton(QDialogButtonBox.Help)
self.buttonBox.helpRequested.connect(self.show_help)
self.update_connection_info()
self.update_model_names()
self.restore_configuration()
def __init__(self, iface, parent=None):
super(GridExtractDialog, self).__init__(parent)
# Set up the user interface from Designer.
self.setupUi(self)
self.iface = iface
self.DISP_TEMP_LAYERS = read_setting(PLUGIN_NAME + '/DISP_TEMP_LAYERS',
bool)
self.DEBUG = config.get_debug_mode()
self.layers_df = None
self.pixel_size = ['0', 'm', '']
# Catch and redirect python errors directed at the log messages python error tab.
QgsApplication.messageLog().messageReceived.connect(errorCatcher)
if not os.path.exists(TEMPDIR):
os.mkdir(TEMPDIR)
# Setup for validation messagebar on gui-----------------------------
self.messageBar = QgsMessageBar(
self) # leave this message bar for bailouts
self.validationLayout = QtWidgets.QFormLayout(
self) # new layout to gui
if isinstance(self.layout(), QtWidgets.QFormLayout):
# create a validation layout so multiple messages can be added and cleaned up.
self.layout().insertRow(0, self.validationLayout)
self.layout().insertRow(0, self.messageBar)
else:
self.layout().insertWidget(
0,
self.messageBar) # for use with Vertical/horizontal layout box
# GUI Runtime Customisation -----------------------------------------------
self.mcboPointsLayer.setFilters(QgsMapLayerProxyModel.PointLayer)
self.mcboPointsLayer.setExcludedProviders(['wms'])
self.mcboRasterLayer.setFilters(QgsMapLayerProxyModel.RasterLayer)
self.mcboRasterLayer.setExcludedProviders(['wms'])
self.setMapLayers()
self.setWindowIcon(
QtGui.QIcon(':/plugins/pat/icons/icon_gridExtract.svg'))
self.chkgrpStatistics.setExclusive(False)
self.tabList.setColumnCount(2)
self.tabList.setHorizontalHeaderItem(0, QTableWidgetItem("ID"))
self.tabList.setHorizontalHeaderItem(1,
QTableWidgetItem("0 Raster(s)"))
self.tabList.horizontalHeader().setSectionResizeMode(
QtWidgets.QHeaderView.Stretch)
self.tabList.hideColumn(0) # don't need to display the unique layer ID
self.pixel_size = ['0', 'm', '']
self.statsMapping = {
'mean': np.nanmean,
'minimum': np.nanmin,
'maximum': np.nanmax,
'standard deviation': np.nanstd,
'coefficient of variation': raster_ops.nancv,
'pixel count': raster_ops.pixelcount,
}
def __init__(self, iface, parent=None):
"""Constructor."""
super().__init__(parent)
self.setupUi(self)
self.setObjectName('QQuakeDialog')
QgsGui.enableAutoGeometryRestore(self)
self.fsdn_event_filter = FilterParameterWidget(iface, SERVICE_MANAGER.FDSNEVENT)
vl = QVBoxLayout()
vl.setContentsMargins(0, 0, 0, 0)
vl.addWidget(self.fsdn_event_filter)
self.fsdn_event_filter_container.setLayout(vl)
self.earthquake_service_info_widget = ServiceInformationWidget(iface)
self.fsdn_by_id_filter = FilterByIdWidget(iface, SERVICE_MANAGER.FDSNEVENT)
vl = QVBoxLayout()
vl.setContentsMargins(0, 0, 0, 0)
vl.addWidget(self.fsdn_by_id_filter)
self.fsdn_by_id_container.setLayout(vl)
self.fdsn_by_url_widget = FetchByUrlWidget(iface, SERVICE_MANAGER.FDSNEVENT)
vl = QVBoxLayout()
vl.setContentsMargins(0, 0, 0, 0)
vl.addWidget(self.fdsn_by_url_widget)
self.fsdn_by_url_container.setLayout(vl)
vl = QVBoxLayout()
vl.setContentsMargins(0, 0, 0, 0)
vl.addWidget(self.earthquake_service_info_widget)
self.earthquake_service_info_container.setLayout(vl)
self.macro_filter = FilterParameterWidget(iface, SERVICE_MANAGER.MACROSEISMIC)
vl = QVBoxLayout()
vl.setContentsMargins(0, 0, 0, 0)
vl.addWidget(self.macro_filter)
self.macro_filter_container.setLayout(vl)
self.macro_by_id_filter = FilterByIdWidget(iface, SERVICE_MANAGER.MACROSEISMIC)
vl = QVBoxLayout()
vl.setContentsMargins(0, 0, 0, 0)
vl.addWidget(self.macro_by_id_filter)
self.macro_by_id_container.setLayout(vl)
self.macro_by_url_widget = FetchByUrlWidget(iface, SERVICE_MANAGER.MACROSEISMIC)
vl = QVBoxLayout()
vl.setContentsMargins(0, 0, 0, 0)
vl.addWidget(self.macro_by_url_widget)
self.macro_by_url_container.setLayout(vl)
self.macro_service_info_widget = ServiceInformationWidget(iface)
vl = QVBoxLayout()
vl.setContentsMargins(0, 0, 0, 0)
vl.addWidget(self.macro_service_info_widget)
self.macro_service_info_container.setLayout(vl)
self.station_filter = FilterParameterWidget(iface, SERVICE_MANAGER.FDSNSTATION)
vl = QVBoxLayout()
vl.setContentsMargins(0, 0, 0, 0)
vl.addWidget(self.station_filter)
self.station_filter_container.setLayout(vl)
self.station_by_id_filter = FilterStationByIdWidget(iface, SERVICE_MANAGER.FDSNSTATION)
vl = QVBoxLayout()
vl.setContentsMargins(0, 0, 0, 0)
vl.addWidget(self.station_by_id_filter)
self.station_by_id_container.setLayout(vl)
self.station_service_info_widget = ServiceInformationWidget(iface)
vl = QVBoxLayout()
vl.setContentsMargins(0, 0, 0, 0)
vl.addWidget(self.station_service_info_widget)
self.station_service_info_container.setLayout(vl)
self.ogc_service_widget = OgcServiceWidget(iface)
vl = QVBoxLayout()
vl.setContentsMargins(0, 0, 0, 0)
vl.addWidget(self.ogc_service_widget)
self.ogc_widget_container.setLayout(vl)
self.ogc_service_info_widget = ServiceInformationWidget(iface)
vl = QVBoxLayout()
vl.setContentsMargins(0, 0, 0, 0)
vl.addWidget(self.ogc_service_info_widget)
self.ogc_service_info_container.setLayout(vl)
self.message_bar = QgsMessageBar()
self.message_bar.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed)
self.verticalLayout.insertWidget(0, self.message_bar)
self.fsdn_event_url_text_browser.viewport().setAutoFillBackground(False)
self.fdsn_macro_url_text_browser.viewport().setAutoFillBackground(False)
self.fdsn_station_url_text_browser.viewport().setAutoFillBackground(False)
self.button_box.button(QDialogButtonBox.Ok).setText(self.tr('Fetch Data'))
self.button_box.rejected.connect(self._save_settings)
self.iface = iface
# OGC
self.ogc_combo.addItem(self.tr('Web Map Services (WMS)'), SERVICE_MANAGER.WMS)
self.ogc_combo.addItem(self.tr('Web Feature Services (WFS)'), SERVICE_MANAGER.WFS)
self.ogc_combo.currentIndexChanged.connect(self.refreshOgcWidgets)
self.ogc_list.currentRowChanged.connect(
self._ogc_service_changed)
self._refresh_services()
SERVICE_MANAGER.refreshed.connect(self._refresh_services)
# connect to refreshing function to refresh the UI depending on the WS
self._refresh_fdsnevent_widgets()
self.refreshFdsnMacroseismicWidgets()
self.refreshFdsnStationWidgets()
# change the UI parameter according to the web service chosen
self.fdsn_event_list.currentRowChanged.connect(
self._refresh_fdsnevent_widgets)
self.fdsn_macro_list.currentRowChanged.connect(
self.refreshFdsnMacroseismicWidgets)
self.fdsn_station_list.currentRowChanged.connect(
self.refreshFdsnStationWidgets)
self.fsdn_event_filter.changed.connect(lambda: self._refresh_url(SERVICE_MANAGER.FDSNEVENT))
self.fsdn_by_id_filter.changed.connect(lambda: self._refresh_url(SERVICE_MANAGER.FDSNEVENT))
self.fdsn_by_url_widget.changed.connect(lambda: self._refresh_url(SERVICE_MANAGER.FDSNEVENT))
self.fdsn_event_list.currentRowChanged.connect(lambda: self._refresh_url(SERVICE_MANAGER.FDSNEVENT))
self.macro_filter.changed.connect(lambda: self._refresh_url(SERVICE_MANAGER.MACROSEISMIC))
self.macro_by_id_filter.changed.connect(lambda: self._refresh_url(SERVICE_MANAGER.MACROSEISMIC))
self.macro_by_url_widget.changed.connect(lambda: self._refresh_url(SERVICE_MANAGER.MACROSEISMIC))
self.fdsn_macro_list.currentRowChanged.connect(lambda: self._refresh_url(SERVICE_MANAGER.MACROSEISMIC))
self.station_filter.changed.connect(lambda: self._refresh_url(SERVICE_MANAGER.FDSNSTATION))
self.station_by_id_filter.changed.connect(lambda: self._refresh_url(SERVICE_MANAGER.FDSNSTATION))
self.fdsn_station_list.currentRowChanged.connect(lambda: self._refresh_url(SERVICE_MANAGER.FDSNSTATION))
self.button_box.accepted.connect(self._getEventList)
self.service_tab_widget.currentChanged.connect(lambda: self._refresh_url(None))
self.fetcher = None
QgsGui.enableAutoGeometryRestore(self)
self.fdsn_tab_widget.currentChanged.connect(lambda: self._refresh_url(SERVICE_MANAGER.FDSNEVENT))
self.macro_tab_widget.currentChanged.connect(lambda: self._refresh_url(SERVICE_MANAGER.MACROSEISMIC))
self.fdsnstation_tab_widget.currentChanged.connect(lambda: self._refresh_url(SERVICE_MANAGER.FDSNSTATION))
for b in [self.button_fdsn_new_service, self.button_macro_new_service,
self.button_station_new_service, self.button_ogc_new_service]:
self._build_add_service_menu(b)
for b in [self.button_fdsn_edit_service, self.button_macro_edit_service,
self.button_station_edit_service, self.button_ogc_edit_service]:
b.clicked.connect(self._edit_service)
for b in [self.button_fdsn_rename_service, self.button_macro_rename_service,
self.button_station_rename_service, self.button_ogc_rename_service]:
b.clicked.connect(self._rename_service)
for b in [self.button_fdsn_remove_service, self.button_macro_remove_service,
self.button_station_remove_service, self.button_ogc_remove_service]:
b.clicked.connect(self._remove_service)
for b in [self.button_fdsn_export_service, self.button_macro_export_service,
self.button_station_export_service, self.button_ogc_export_service]:
b.clicked.connect(self._export_service)
self._restore_settings()
self._refresh_url(SERVICE_MANAGER.FDSNEVENT)
self._refresh_url(SERVICE_MANAGER.MACROSEISMIC)
self._refresh_url(SERVICE_MANAGER.FDSNSTATION)
def __init__(self, iface, base_config, parent=None):
QDialog.__init__(self, parent)
self.setupUi(self)
self.iface = iface
self.db_simple_factory = DbSimpleFactory()
QgsGui.instance().enableAutoGeometryRestore(self)
self.create_text = self.tr('Create')
self.set_button_to_create_action = QAction(self.create_text, None)
self.set_button_to_create_action.triggered.connect(self.set_button_to_create)
self.create_without_constraints_text = self.tr('Create without constraints')
self.set_button_to_create_without_constraints_action = QAction(self.create_without_constraints_text, None)
self.set_button_to_create_without_constraints_action.triggered.connect(self.set_button_to_create_without_constraints)
self.edit_command_action = QAction(self.tr('Edit ili2db command'), None)
self.edit_command_action.triggered.connect(self.edit_command)
self.create_tool_button.addAction(self.set_button_to_create_without_constraints_action)
self.create_tool_button.addAction(self.edit_command_action)
self.create_tool_button.setText(self.create_text)
self.create_tool_button.clicked.connect(self.accepted)
self.buttonBox.accepted.disconnect()
self.buttonBox.clear()
self.buttonBox.addButton(QDialogButtonBox.Cancel)
self.create_constraints = True
self.create_button.setText(self.tr('Create'))
self.create_button.clicked.connect(self.accepted)
self.ili_file_browse_button.clicked.connect(
make_file_selector(self.ili_file_line_edit, title=self.tr('Open Interlis Model'),
file_filter=self.tr('Interlis Model File (*.ili *.ILI)')))
self.buttonBox.addButton(QDialogButtonBox.Help)
self.buttonBox.helpRequested.connect(self.help_requested)
self.crs = QgsCoordinateReferenceSystem()
self.ili2db_options = Ili2dbOptionsDialog()
self.ili2db_options_button.clicked.connect(self.ili2db_options.open)
self.ili2db_options.finished.connect(self.fill_toml_file_info_label)
self.multiple_models_dialog = MultipleModelsDialog(self)
self.multiple_models_button.clicked.connect(
self.multiple_models_dialog.open)
self.multiple_models_dialog.accepted.connect(
self.fill_models_line_edit)
self.type_combo_box.clear()
self._lst_panel = dict()
for db_id in self.db_simple_factory.get_db_list(True):
self.type_combo_box.addItem(displayDbIliMode[db_id], db_id)
for db_id in self.db_simple_factory.get_db_list(False):
db_factory = self.db_simple_factory.create_factory(db_id)
item_panel = db_factory.get_config_panel(self, DbActionType.GENERATE)
self._lst_panel[db_id] = item_panel
self.db_layout.addWidget(item_panel)
self.type_combo_box.currentIndexChanged.connect(self.type_changed)
self.txtStdout.anchorClicked.connect(self.link_activated)
self.crsSelector.crsChanged.connect(self.crs_changed)
self.base_configuration = base_config
self.bar = QgsMessageBar()
self.bar.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed)
self.txtStdout.setLayout(QGridLayout())
self.txtStdout.layout().setContentsMargins(0, 0, 0, 0)
self.txtStdout.layout().addWidget(self.bar, 0, 0, Qt.AlignTop)
self.validators = Validators()
nonEmptyValidator = NonEmptyStringValidator()
fileValidator = FileValidator(pattern=['*.' + ext for ext in self.ValidExtensions], allow_empty=True)
self.restore_configuration()
self.ili_models_line_edit.setValidator(nonEmptyValidator)
self.ili_file_line_edit.setValidator(fileValidator)
self.ili_models_line_edit.textChanged.connect(
self.validators.validate_line_edits)
self.ili_models_line_edit.textChanged.emit(
self.ili_models_line_edit.text())
self.ili_models_line_edit.textChanged.connect(self.on_model_changed)
self.ili_models_line_edit.textChanged.connect(self.complete_models_completer)
self.ili_models_line_edit.punched.connect(self.complete_models_completer)
self.ilicache = IliCache(self.base_configuration)
self.refresh_ili_cache()
self.ili_models_line_edit.setPlaceholderText(self.tr('[Search model from repository]'))
self.ili_file_line_edit.textChanged.connect(
self.validators.validate_line_edits)
self.ili_file_line_edit.textChanged.connect(self.ili_file_changed)
self.ili_file_line_edit.textChanged.emit(
self.ili_file_line_edit.text())
def __init__(self):
super(TestSelector, self).__init__()
self.setupUi(self)
self.tests = None
self.bar = QgsMessageBar()
self.bar.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed)
self.layout().insertWidget(1, self.bar)
allTests = defaultdict(list)
for test in tests.tests:
allTests[test.group].append(test)
for group, groupTests in iteritems(allTests):
groupItem = QTreeWidgetItem()
groupItem.setText(0, group)
groupItem.setFlags(groupItem.flags() | Qt.ItemIsTristate)
unitItem = QTreeWidgetItem()
unitItem.setText(0, "Fully automated tests")
unitItem.setFlags(unitItem.flags() | Qt.ItemIsTristate)
manualItem = QTreeWidgetItem()
manualItem.setText(0, "Manual and semi-automated tests")
manualItem.setFlags(manualItem.flags() | Qt.ItemIsTristate)
unitTestsByCategories = defaultdict(list)
manualTestsByCategories = defaultdict(list)
for test in groupTests:
if isinstance(test, UnitTestWrapper):
unitTestsByCategories[test.category].append(test)
else:
manualTestsByCategories[test.category].append(test)
for testsList, parentItem in [(unitTestsByCategories, unitItem),
(manualTestsByCategories, manualItem)
]:
for cat, catTests in iteritems(testsList):
categoryItem = QTreeWidgetItem()
categoryItem.setText(0, cat)
categoryItem.setFlags(manualItem.flags()
| Qt.ItemIsTristate)
for test in catTests:
testItem = QTreeWidgetItem()
testItem.setFlags(testItem.flags()
| Qt.ItemIsUserCheckable)
testItem.setCheckState(0, Qt.Unchecked)
testItem.test = test
testItem.setText(0, test.name)
categoryItem.addChild(testItem)
parentItem.addChild(categoryItem)
if manualItem.childCount():
groupItem.addChild(manualItem)
if unitItem.childCount():
groupItem.addChild(unitItem)
self.testsTree.addTopLevelItem(groupItem)
groupItem.setExpanded(True)
self.buttonBox.button(
QDialogButtonBox.Ok).setText("Run selected tests")
self.buttonBox.accepted.connect(self.okPressed)
self.buttonBox.rejected.connect(self.cancelPressed)
self.selectAllLabel.linkActivated.connect(
lambda: self.checkTests(lambda t: Qt.Checked))
self.unselectAllLabel.linkActivated.connect(
lambda: self.checkTests(lambda t: Qt.Unchecked))
def _onlyManual(t):
if isinstance(t, UnitTestWrapper):
return Qt.Unchecked
else:
return Qt.Checked
self.onlyManualLabel.linkActivated.connect(
lambda: self.checkTests(_onlyManual))
def _onlyUnit(t):
if isinstance(t, UnitTestWrapper):
return Qt.Checked
else:
return Qt.Unchecked
self.onlyUnitLabel.linkActivated.connect(
lambda: self.checkTests(_onlyUnit))
filepath = os.path.expanduser("~/.testerplugin/failed.txt")
if os.path.exists(filepath):
with open(filepath) as f:
failed = json.load(f)
else:
failed = []
def _onlyLastFailures(t):
if t.group in failed and t.name in failed[t.group]:
return Qt.Checked
else:
return Qt.Unchecked
self.onlyLastFailuresLabel.linkActivated.connect(
lambda: self.checkTests(_onlyLastFailures))
self.exportButton.clicked.connect(self.export)
def __init__(self, iface, db, qgis_utils, parent=None):
QDialog.__init__(self)
self.setupUi(self)
self.iface = iface
self.log = QgsApplication.messageLog()
self._la_group_party_table = None
self._members_table = None
self._fraction_table = None
self._col_party_layer = None
self._db = db
self.qgis_utils = qgis_utils
self.help_strings = HelpStrings()
self.data = {} # {t_id: [display_text, denominator, numerator]}
self.current_selected_parties = [] # [t_ids]
self.parties_to_group = {} # {t_id: [denominator, numerator]}
# Fill combo of types
la_group_party_type_table = self.qgis_utils.get_layer(
self._db, LA_GROUP_PARTY_TYPE_TABLE, None, True)
if la_group_party_type_table is None:
self.iface.messageBar().pushMessage(
"Asistente LADM_COL",
QCoreApplication.translate(
"CreateGroupPartyCadastreWizard",
"Group Party Type Table couldn't be found... {}").format(
self._db.get_description()), Qgis.Warning)
return
domain_key_index = la_group_party_type_table.fields().indexOf(
DOMAIN_KEY_FIELD[self._db.mode])
domain_keys = list(
la_group_party_type_table.uniqueValues(domain_key_index))
domain_keys.sort()
self.cbo_group_type.addItems(domain_keys)
self.txt_search_party.setText("")
self.btn_select.setEnabled(False)
self.btn_deselect.setEnabled(False)
self.tbl_selected_parties.setColumnCount(3)
self.tbl_selected_parties.setColumnWidth(0, 140)
self.tbl_selected_parties.setColumnWidth(1, 90)
self.tbl_selected_parties.setColumnWidth(2, 90)
self.tbl_selected_parties.sortItems(0, Qt.AscendingOrder)
self.txt_search_party.textEdited.connect(self.search)
self.lst_all_parties.itemSelectionChanged.connect(
self.selection_changed_all)
self.tbl_selected_parties.itemSelectionChanged.connect(
self.selection_changed_selected)
self.tbl_selected_parties.cellChanged.connect(self.valueEdited)
self.btn_select_all.clicked.connect(self.select_all)
self.btn_deselect_all.clicked.connect(self.deselect_all)
self.btn_select.clicked.connect(self.select)
self.btn_deselect.clicked.connect(self.deselect)
self.bar = QgsMessageBar()
self.bar.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed)
self.setLayout(QGridLayout())
self.layout().addWidget(self.bar, 0, 0, Qt.AlignTop)
class Authenticator(QObject):
"""Basic class to manage user authentication to Isogeo's API :
- Getting credentials from oAuth2 file or QGIS Settings
- Storing credentials
- Displaying authentication form
:param str auth_folder: the path to the plugin/_auth subfolder
where oAuth2 file is stored.
"""
auth_sig = pyqtSignal(str)
ask_shares = pyqtSignal()
# ui reference - authentication form
ui_auth_form = IsogeoAuthentication()
# display messages to the user
msgbar = QgsMessageBar(ui_auth_form)
ui_auth_form.msgbar_vlayout.addWidget(msgbar)
# api parameters
api_params = {
"app_id": "",
"app_secret": "",
"url_base": "https://v1.api.isogeo.com/",
"url_auth": "https://id.api.isogeo.com/oauth/authorize",
"url_token": "https://id.api.isogeo.com/oauth/token",
"url_redirect": "http://localhost:5000/callback",
}
# plugin credentials storage parameters
credentials_location = {"QSettings": 0, "oAuth2_file": 0}
def __init__(self):
# inheritance
super().__init__()
# API URLs - Prod
(
self.platform,
self.api_url,
self.app_url,
self.csw_url,
self.mng_url,
self.oc_url,
self.ssl,
) = plg_tools.set_base_url("prod")
# credentials storage folder
self.auth_folder = plugin_dir / "_auth"
self.cred_filepath = self.auth_folder / "client_secrets.json"
# translation
self.tr = object
self.lang = str
# inform user
self.informer = object
self.first_auth = bool
# MANAGER -----------------------------------------------------------------
def manage_api_initialization(self):
"""Perform several operations to use Isogeo API:
1. check if existing credentials are stored into QGIS or a file
2. gettings credentials from there storage location (QGIS settings or file)
3. display auth form if no credentials are found
:returns: True and a dictionnary containing api parameters nessary for the
instanciation of the ApiRequester class if credentials are found. False and
None if no credentials are found.
:rtype: bool, dict
"""
# try to retrieve existing credentials from potential sources
self.credentials_location[
"QSettings"] = self.credentials_check_qsettings()
self.credentials_location["oAuth2_file"] = self.credentials_check_file(
)
# update class attributes from credentials found
if self.credentials_location.get("QSettings"):
self.credentials_update("QSettings")
elif self.credentials_location.get("oAuth2_file"):
self.credentials_update("oAuth2_file")
else:
logger.info("No credentials found. ")
self.first_auth = True
self.display_auth_form()
return False, None
return True, self.api_params
# CREDENTIALS LOCATORS ----------------------------------------------------
def credentials_check_qsettings(self):
"""Retrieve Isogeo API credentials within QGIS QSettings."""
if "isogeo-plugin" in qsettings.childGroups():
logger.warning(
"Old credentials found and removed in QGIS QSettings: isogeo-plugin"
)
qsettings.remove("isogeo-plugin")
return False
elif "isogeo" in qsettings.childGroups():
# looking in child groups and clean a little if needed
qsettings.beginGroup("isogeo")
if "app_auth" in qsettings.childGroups():
qsettings.remove("isogeo/app_auth")
logger.debug("QSettings clean up - app_auth")
pass
if "api_auth" in qsettings.childGroups():
qsettings.remove("isogeo/api_auth")
logger.debug("QSettings clean up - api_auth")
pass
if "auth" in qsettings.childGroups(
) and not qsettings.contains("auth/app_id"):
qsettings.remove("isogeo/auth")
logger.debug("QSettings clean up - bad formatted auth")
pass
if "auth" in qsettings.childGroups() and qsettings.contains(
"auth/app_id"):
logger.debug(
"Credentials found within QGIS QSettings: isogeo/")
pass
qsettings.endGroup()
return True
else:
logger.debug("No Isogeo credentials found within QGIS QSettings.")
pass
return False
def credentials_check_file(self):
"""Retrieve Isogeo API credentials from a file stored inside the
plugin/_auth subfolder.
return: True if credentials can be retrieved from oAuth2 file.
False if the file doesn't exists or if credentials can't be retrieved.
:rtype: bool
"""
credentials_filepath = self.cred_filepath
# check if a client_secrets.json file is stored inside the _auth subfolder
if not credentials_filepath.is_file():
logger.debug(
"No credential files found: {}".format(credentials_filepath))
return False
else:
pass
# check file structure
try:
plg_tools.credentials_loader(credentials_filepath)
logger.debug(
"Credentials found in {}".format(credentials_filepath))
except Exception as e:
logger.debug(e)
return False
# end of method
return True
# CREDENTIALS SAVER -------------------------------------------------------
def credentials_storer(self, store_location: str = "QSettings"):
"""Store class attributes (API parameters) into the specified store_location.
:param str store_location: name of targetted store location. Options:
- QSettings
"""
if store_location == "QSettings":
qsettings.setValue("isogeo/auth/app_id", self.api_params["app_id"])
qsettings.setValue("isogeo/auth/app_secret",
self.api_params["app_secret"])
qsettings.setValue("isogeo/auth/url_base",
self.api_params["url_base"])
qsettings.setValue("isogeo/auth/url_auth",
self.api_params["url_auth"])
qsettings.setValue("isogeo/auth/url_token",
self.api_params["url_token"])
qsettings.setValue("isogeo/auth/url_redirect",
self.api_params["url_redirect"])
else:
pass
logger.debug("Credentials stored into: {}".format(store_location))
def credentials_update(self, credentials_source: str = "QSettings"):
"""Update class attributes (API parameters) from specified credentials source.
:param str credentials_source: name of targetted credentials source. Options:
- QSettings
- oAuth2_file
"""
# update class attributes
if credentials_source == "QSettings":
self.api_params["app_id"] = qsettings.value(
"isogeo/auth/app_id", "")
self.api_params["app_secret"] = qsettings.value(
"isogeo/auth/app_secret", "")
self.api_params["url_base"] = qsettings.value(
"isogeo/auth/url_base", "https://v1.api.isogeo.com/")
self.api_params["url_auth"] = qsettings.value(
"isogeo/auth/url_auth",
"https://id.api.isogeo.com/oauth/authorize")
self.api_params["url_token"] = qsettings.value(
"isogeo/auth/url_token",
"https://id.api.isogeo.com/oauth/token")
self.api_params["url_redirect"] = qsettings.value(
"isogeo/auth/url_redirect", "http://localhost:5000/callback")
elif credentials_source == "oAuth2_file":
creds = plg_tools.credentials_loader(self.cred_filepath)
self.api_params["app_id"] = creds.get("client_id")
self.api_params["app_secret"] = creds.get("client_secret")
self.api_params["url_base"] = creds.get("uri_base")
self.api_params["url_auth"] = creds.get("uri_auth")
self.api_params["url_token"] = creds.get("uri_token")
self.api_params["url_redirect"] = creds.get("uri_redirect")
self.credentials_storer(store_location="QSettings")
else:
pass
logger.debug(
"Credentials updated from: {}. Application ID used: {}".format(
credentials_source, self.api_params["app_id"]))
# AUTHENTICATION FORM -----------------------------------------------------
def display_auth_form(self):
"""Show authentication form with prefilled fields and connected widgets."""
self.informer = UserInformer(message_bar=self.msgbar, trad=self.tr)
self.auth_sig.connect(self.informer.authentication_slot)
self.ui_auth_form.chb_isogeo_editor.stateChanged.connect(
lambda: qsettings.setValue(
"isogeo/user/editor",
int(self.ui_auth_form.chb_isogeo_editor.isChecked()),
))
self.ui_auth_form.btn_free_test.pressed.connect(
partial(plg_tools.open_pipedrive_test_form, lang=self.lang))
self.ui_auth_form.btn_rdv_isogeo.pressed.connect(
partial(plg_tools.open_pipedrive_rdv_form, lang=self.lang))
self.ui_auth_form.btn_browse_credentials.fileChanged.connect(
self.credentials_uploader)
self.ui_auth_form.btn_ok_cancel.buttons()[0].setEnabled(False)
# fillfull auth form fields from stored settings
self.ui_auth_form.ent_app_id.setText(self.api_params["app_id"])
self.ui_auth_form.ent_app_secret.setText(self.api_params["app_secret"])
self.ui_auth_form.lbl_api_url_value.setText(
self.api_params["url_base"])
self.ui_auth_form.chb_isogeo_editor.setChecked(
int(qsettings.value("isogeo/user/editor", 0)))
# display
logger.debug("Authentication form filled and ready to be launched.")
self.ui_auth_form.show()
if self.first_auth:
pass
else:
self.ask_shares.emit()
pass
def credentials_uploader(self):
"""Get file selected by the user and loads API credentials into plugin.
If the selected is compliant, credentials are loaded from then it's
moved inside plugin/_auth subfolder. auth_sig is emitted to inform the user
about indicated file's accessibility and format validity.
"""
self.ui_auth_form.btn_browse_credentials.fileChanged.disconnect()
# test file structure
selected_file = Path(
self.ui_auth_form.btn_browse_credentials.filePath())
logger.debug(
"Loading credentials from file indicated by the user : {}".format(
selected_file))
try:
api_credentials = plg_tools.credentials_loader(
self.ui_auth_form.btn_browse_credentials.filePath())
except IOError as e:
self.auth_sig.emit("path")
logger.error(
"Fail to load credentials from authentication file. IOError : {}"
.format(e))
self.ui_auth_form.btn_browse_credentials.fileChanged.connect(
self.credentials_uploader)
self.ui_auth_form.btn_ok_cancel.buttons()[0].setEnabled(False)
return False
except ValueError as e:
self.auth_sig.emit("file")
logger.error(
"Fail to load credentials from authentication file. ValueError : {}"
.format(e))
self.ui_auth_form.btn_browse_credentials.fileChanged.connect(
self.credentials_uploader)
self.ui_auth_form.btn_ok_cancel.buttons()[0].setEnabled(False)
return False
# rename existing credentials file with prefix 'old_' and datetime as suffix
dest_path = self.cred_filepath
if dest_path.is_file():
logger.debug("client_secrets.json already existed. "
"Previous file has been renamed.")
old_file_renamed = self.auth_folder / "old_client_secrets_{}.json".format(
int(time.time()))
dest_path.rename(old_file_renamed)
else:
pass
# mave new credentials file to the _auth subfolder
try:
selected_file.rename(dest_path) # using pathlib.Path (= os.rename)
logger.debug(
"Selected credentials file has been moved into plugin _auth subfolder"
)
except OSError as exc:
logger.error(
"Move new file raised: {}. Maybe because of moving from a "
"different disk drive. Trying with lower-level lib... "
"See: https://github.com/isogeo/isogeo-plugin-qgis/issues/291 "
.format(exc))
shutil.move(selected_file, dest_path)
except Exception as exc:
logger.error("Failed to move authentication file: {}".format(exc))
self.auth_sig.emit("path")
self.ui_auth_form.btn_browse_credentials.fileChanged.connect(
self.credentials_uploader)
self.ui_auth_form.btn_ok_cancel.buttons()[0].setEnabled(False)
return False
# set form
self.ui_auth_form.ent_app_id.setText(api_credentials.get("client_id"))
self.ui_auth_form.ent_app_secret.setText(
api_credentials.get("client_secret"))
self.ui_auth_form.lbl_api_url_value.setText(
api_credentials.get("uri_auth"))
# update class attributes from file
self.credentials_update(credentials_source="oAuth2_file")
# store into QSettings if existing
self.credentials_storer(store_location="QSettings")
self.ui_auth_form.btn_browse_credentials.fileChanged.connect(
self.credentials_uploader)
self.auth_sig.emit("ok")
return True
def setupUi(self):
self.setWindowTitle(self.tr("DB Manager"))
self.setWindowIcon(QIcon(":/db_manager/icon"))
self.resize(QSize(700, 500).expandedTo(self.minimumSizeHint()))
# create central tab widget and add the first 3 tabs: info, table and preview
self.tabs = QTabWidget()
self.info = InfoViewer(self)
self.tabs.addTab(self.info, self.tr("Info"))
self.table = TableViewer(self)
self.tabs.addTab(self.table, self.tr("Table"))
self.preview = LayerPreview(self)
self.tabs.addTab(self.preview, self.tr("Preview"))
self.setCentralWidget(self.tabs)
# display close button for all tabs but the first 3 ones, i.e.
# HACK: just hide the close button where not needed (GS)
self.tabs.setTabsClosable(True)
self.tabs.tabCloseRequested.connect(self.close_tab)
tabbar = self.tabs.tabBar()
for i in range(3):
btn = tabbar.tabButton(i, QTabBar.RightSide) if tabbar.tabButton(
i, QTabBar.RightSide) else tabbar.tabButton(
i, QTabBar.LeftSide)
btn.resize(0, 0)
btn.hide()
# Creates layout for message bar
self.layout = QGridLayout(self.info)
self.layout.setContentsMargins(0, 0, 0, 0)
spacerItem = QSpacerItem(20, 40, QSizePolicy.Minimum,
QSizePolicy.Expanding)
self.layout.addItem(spacerItem, 1, 0, 1, 1)
# init messageBar instance
self.infoBar = QgsMessageBar(self.info)
sizePolicy = QSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed)
self.infoBar.setSizePolicy(sizePolicy)
self.layout.addWidget(self.infoBar, 0, 0, 1, 1)
# create database tree
self.dock = QDockWidget("Tree", self)
self.dock.setObjectName("DB_Manager_DBView")
self.dock.setFeatures(QDockWidget.DockWidgetMovable)
self.tree = DBTree(self)
self.dock.setWidget(self.tree)
self.addDockWidget(Qt.LeftDockWidgetArea, self.dock)
# create status bar
self.statusBar = QStatusBar(self)
self.setStatusBar(self.statusBar)
# create menus
self.menuBar = QMenuBar(self)
self.menuDb = QMenu(self.tr("&Database"), self)
self.menuBar.addMenu(self.menuDb)
self.menuSchema = QMenu(self.tr("&Schema"), self)
actionMenuSchema = self.menuBar.addMenu(self.menuSchema)
self.menuTable = QMenu(self.tr("&Table"), self)
actionMenuTable = self.menuBar.addMenu(self.menuTable)
self.menuHelp = None # QMenu(self.tr("&Help"), self)
# actionMenuHelp = self.menuBar.addMenu(self.menuHelp)
self.setMenuBar(self.menuBar)
# create toolbar
self.toolBar = QToolBar("Default", self)
self.toolBar.setObjectName("DB_Manager_ToolBar")
self.addToolBar(self.toolBar)
# create menus' actions
# menu DATABASE
sep = self.menuDb.addSeparator()
sep.setObjectName("DB_Manager_DbMenu_placeholder")
sep.setVisible(False)
self.actionRefresh = self.menuDb.addAction(
QIcon(":/db_manager/actions/refresh"), self.tr("&Refresh"),
self.refreshActionSlot, QKeySequence("F5"))
self.actionSqlWindow = self.menuDb.addAction(
QIcon(":/db_manager/actions/sql_window"), self.tr("&SQL window"),
self.runSqlWindow, QKeySequence("F2"))
self.menuDb.addSeparator()
self.actionClose = self.menuDb.addAction(QIcon(), self.tr("&Exit"),
self.close,
QKeySequence("CTRL+Q"))
# menu SCHEMA
sep = self.menuSchema.addSeparator()
sep.setObjectName("DB_Manager_SchemaMenu_placeholder")
sep.setVisible(False)
actionMenuSchema.setVisible(False)
# menu TABLE
sep = self.menuTable.addSeparator()
sep.setObjectName("DB_Manager_TableMenu_placeholder")
sep.setVisible(False)
self.actionImport = self.menuTable.addAction(
QIcon(":/db_manager/actions/import"),
self.tr("&Import layer/file"), self.importActionSlot)
self.actionExport = self.menuTable.addAction(
QIcon(":/db_manager/actions/export"), self.tr("&Export to file"),
self.exportActionSlot)
self.menuTable.addSeparator()
#self.actionShowSystemTables = self.menuTable.addAction(self.tr("Show system tables/views"), self.showSystemTables)
#self.actionShowSystemTables.setCheckable(True)
#self.actionShowSystemTables.setChecked(True)
actionMenuTable.setVisible(False)
# add actions to the toolbar
self.toolBar.addAction(self.actionRefresh)
self.toolBar.addAction(self.actionSqlWindow)
self.toolBar.addAction(self.actionImport)
self.toolBar.addAction(self.actionExport)
def __init__(self, iface, db, qgis_utils):
QDialog.__init__(self)
self.setupUi(self)
QgsGui.instance().enableAutoGeometryRestore(self)
self.iface = iface
self.db = db
self.qgis_utils = qgis_utils
self.base_configuration = BaseConfiguration()
self.ilicache = IliCache(self.base_configuration)
self.ilicache.refresh()
self._conf_db = ConfigDbSupported()
self._params = None
self._current_db = None
self.xtf_file_browse_button.clicked.connect(
make_file_selector(
self.xtf_file_line_edit,
title=QCoreApplication.translate(
"DialogImportData", 'Open Transfer or Catalog File'),
file_filter=QCoreApplication.translate(
"DialogImportData",
'Transfer File (*.xtf *.itf);;Catalogue File (*.xml *.xls *.xlsx)'
)))
self.validators = Validators()
self.xtf_file_line_edit.setPlaceholderText(
QCoreApplication.translate("DialogImportData",
"[Name of the XTF to be created]"))
fileValidator = FileValidator(pattern=['*.xtf', '*.itf', '*.xml'])
self.xtf_file_line_edit.setValidator(fileValidator)
self.xtf_file_line_edit.textChanged.connect(self.update_import_models)
self.xtf_file_line_edit.textChanged.emit(
self.xtf_file_line_edit.text())
# db
self.connection_setting_button.clicked.connect(self.show_settings)
self.connection_setting_button.setText(
QCoreApplication.translate("DialogImportData",
'Connection Settings'))
# LOG
self.log_config.setTitle(
QCoreApplication.translate("DialogImportData", "Show log"))
self.bar = QgsMessageBar()
self.bar.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed)
self.layout().addWidget(self.bar, 0, 0, Qt.AlignTop)
self.buttonBox.accepted.disconnect()
self.buttonBox.accepted.connect(self.accepted)
self.buttonBox.clear()
self.buttonBox.addButton(QDialogButtonBox.Cancel)
self._accept_button = self.buttonBox.addButton(
QCoreApplication.translate("DialogImportData", "Import data"),
QDialogButtonBox.AcceptRole)
self.buttonBox.addButton(QDialogButtonBox.Help)
self.buttonBox.helpRequested.connect(self.show_help)
self.update_connection_info()
self.restore_configuration()
def __init__(self, parent=None, qgis_utils=None, conn_manager=None):
QDialog.__init__(self, parent)
self.setupUi(self)
self.logger = Logger()
self.conn_manager = conn_manager
self._db = None
self.qgis_utils = qgis_utils
self.db_source = COLLECTED_DB_SOURCE # default db source
self._required_models = list()
self._tab_pages_list = list()
self.init_db_engine = None
self._action_type = None
self.dbs_supported = ConfigDbSupported()
self.online_models_radio_button.setChecked(True)
self.online_models_radio_button.toggled.connect(
self.model_provider_toggle)
self.custom_model_directories_line_edit.setText("")
self.custom_models_dir_button.clicked.connect(
self.show_custom_model_dir)
self.custom_model_directories_line_edit.setVisible(False)
self.custom_models_dir_button.setVisible(False)
# Set connections
self.buttonBox.accepted.disconnect()
self.buttonBox.accepted.connect(self.accepted)
self.buttonBox.helpRequested.connect(self.show_help)
self.finished.connect(self.finished_slot)
self.btn_test_connection.clicked.connect(self.test_connection)
self.btn_test_ladm_col_structure.clicked.connect(
self.test_ladm_col_structure)
self.btn_test_service.clicked.connect(self.test_service)
self.btn_test_service_transitional_system.clicked.connect(
self.test_service_transitional_system)
self.btn_default_value_sources.clicked.connect(
self.set_default_value_source_service)
self.btn_default_value_transitional_system.clicked.connect(
self.set_default_value_transitional_system_service)
self.chk_use_roads.toggled.connect(self.update_images_state)
self.bar = QgsMessageBar()
self.bar.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed)
self.layout().addWidget(self.bar, 0, 0, Qt.AlignTop)
self.cbo_db_engine.clear()
self._lst_db = self.dbs_supported.get_db_factories()
self._lst_panel = dict()
for key, value in self._lst_db.items():
self.cbo_db_engine.addItem(value.get_name(), key)
self._lst_panel[key] = value.get_config_panel(self)
self._lst_panel[key].notify_message_requested.connect(
self.show_message)
self.db_layout.addWidget(self._lst_panel[key])
self.db_engine_changed()
# Trigger some default behaviours
self.restore_db_source_settings(
) # restore settings with default db source
self.restore_settings()
self.roles = Role_Registry()
self.load_roles()
self.cbo_db_engine.currentIndexChanged.connect(self.db_engine_changed)
self.rejected.connect(self.close_dialog)
def __init__(self, alg=None):
super(ModelerDialog, self).__init__(None)
self.setupUi(self)
self.bar = QgsMessageBar()
self.bar.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed)
self.layout().insertWidget(1, self.bar)
self.zoom = 1
self.setWindowFlags(Qt.WindowMinimizeButtonHint
| Qt.WindowMaximizeButtonHint
| Qt.WindowCloseButtonHint)
settings = QSettings()
self.splitter.restoreState(
settings.value("/Processing/splitterModeler", QByteArray()))
self.restoreGeometry(
settings.value("/Processing/geometryModeler", QByteArray()))
self.tabWidget.setCurrentIndex(0)
self.scene = ModelerScene(self)
self.scene.setSceneRect(
QRectF(0, 0, self.CANVAS_SIZE, self.CANVAS_SIZE))
self.view.setScene(self.scene)
self.view.setAcceptDrops(True)
self.view.ensureVisible(0, 0, 10, 10)
def _dragEnterEvent(event):
if event.mimeData().hasText():
event.acceptProposedAction()
else:
event.ignore()
def _dropEvent(event):
if event.mimeData().hasText():
text = event.mimeData().text()
if text in ModelerParameterDefinitionDialog.paramTypes:
self.addInputOfType(text, event.pos())
else:
alg = algList.getAlgorithm(text)
if alg is not None:
self._addAlgorithm(alg.getCopy(), event.pos())
event.accept()
else:
event.ignore()
def _dragMoveEvent(event):
if event.mimeData().hasText():
event.accept()
else:
event.ignore()
def _wheelEvent(event):
self.view.setTransformationAnchor(QGraphicsView.AnchorUnderMouse)
settings = QSettings()
factor = settings.value('/qgis/zoom_favor', 2.0)
if (event.modifiers() == Qt.ControlModifier):
factor = 1.0 + (factor - 1.0) / 20.0
if event.angleDelta().y() < 0:
factor = 1 / factor
self.view.scale(factor, factor)
self.repaintModel()
def _enterEvent(e):
QGraphicsView.enterEvent(self.view, e)
self.view.viewport().setCursor(Qt.ArrowCursor)
def _mousePressEvent(e):
QGraphicsView.mousePressEvent(self.view, e)
self.view.viewport().setCursor(Qt.ArrowCursor)
def _mouseReleaseEvent(e):
QGraphicsView.mouseReleaseEvent(self.view, e)
self.view.viewport().setCursor(Qt.ArrowCursor)
def _mousePressEvent(e):
if e.button() == Qt.MidButton:
self.previousMousePos = e.pos()
else:
QGraphicsView.mousePressEvent(self.view, e)
def _mouseMoveEvent(e):
if e.buttons() == Qt.MidButton:
offset = self.previousMousePos - e.pos()
self.previousMousePos = e.pos()
self.view.verticalScrollBar().setValue(
self.view.verticalScrollBar().value() + offset.y())
self.view.horizontalScrollBar().setValue(
self.view.horizontalScrollBar().value() + offset.x())
else:
QGraphicsView.mouseMoveEvent(self.view, e)
self.view.setDragMode(QGraphicsView.ScrollHandDrag)
self.view.dragEnterEvent = _dragEnterEvent
self.view.dropEvent = _dropEvent
self.view.dragMoveEvent = _dragMoveEvent
self.view.wheelEvent = _wheelEvent
self.view.enterEvent = _enterEvent
self.view.mousePressEvent = _mousePressEvent
self.view.mousePressEvent = _mousePressEvent
self.view.mouseMoveEvent = _mouseMoveEvent
def _mimeDataInput(items):
mimeData = QMimeData()
text = items[0].text(0)
mimeData.setText(text)
return mimeData
self.inputsTree.mimeData = _mimeDataInput
self.inputsTree.setDragDropMode(QTreeWidget.DragOnly)
self.inputsTree.setDropIndicatorShown(True)
def _mimeDataAlgorithm(items):
item = items[0]
if isinstance(item, TreeAlgorithmItem):
mimeData = QMimeData()
mimeData.setText(item.alg.commandLineName())
return mimeData
self.algorithmTree.mimeData = _mimeDataAlgorithm
self.algorithmTree.setDragDropMode(QTreeWidget.DragOnly)
self.algorithmTree.setDropIndicatorShown(True)
# Set icons
self.btnOpen.setIcon(
QgsApplication.getThemeIcon('/mActionFileOpen.svg'))
self.btnSave.setIcon(
QgsApplication.getThemeIcon('/mActionFileSave.svg'))
self.btnSaveAs.setIcon(
QgsApplication.getThemeIcon('/mActionFileSaveAs.svg'))
self.btnExportImage.setIcon(
QgsApplication.getThemeIcon('/mActionSaveMapAsImage.svg'))
self.btnExportPython.setIcon(
QgsApplication.getThemeIcon('/console/iconSaveAsConsole.png'))
self.btnEditHelp.setIcon(
QIcon(os.path.join(pluginPath, 'images', 'edithelp.png')))
self.btnRun.setIcon(
QIcon(os.path.join(pluginPath, 'images', 'runalgorithm.png')))
if hasattr(self.searchBox, 'setPlaceholderText'):
self.searchBox.setPlaceholderText(self.tr('Search...'))
if hasattr(self.textName, 'setPlaceholderText'):
self.textName.setPlaceholderText(
self.tr('[Enter model name here]'))
if hasattr(self.textGroup, 'setPlaceholderText'):
self.textGroup.setPlaceholderText(
self.tr('[Enter group name here]'))
# Connect signals and slots
self.inputsTree.doubleClicked.connect(self.addInput)
self.searchBox.textChanged.connect(self.fillAlgorithmTree)
self.algorithmTree.doubleClicked.connect(self.addAlgorithm)
self.btnOpen.clicked.connect(self.openModel)
self.btnSave.clicked.connect(self.save)
self.btnSaveAs.clicked.connect(self.saveAs)
self.btnExportImage.clicked.connect(self.exportAsImage)
self.btnExportPython.clicked.connect(self.exportAsPython)
self.btnEditHelp.clicked.connect(self.editHelp)
self.btnRun.clicked.connect(self.runModel)
if alg is not None:
self.alg = alg
self.textGroup.setText(alg.group)
self.textName.setText(alg.name)
self.repaintModel()
else:
self.alg = ModelerAlgorithm()
self.alg.modelerdialog = self
self.fillInputsTree()
self.fillAlgorithmTree()
self.view.centerOn(0, 0)
self.alg.setModelerView(self)
self.help = None
self.hasChanged = False
def setupUi(self):
self.labels = {}
self.widgets = {}
self.checkBoxes = {}
self.showAdvanced = False
self.wrappers = {}
self.valueItems = {}
self.dependentItems = {}
self.resize(650, 450)
self.buttonBox = QDialogButtonBox()
self.buttonBox.setOrientation(Qt.Horizontal)
self.buttonBox.setStandardButtons(QDialogButtonBox.Cancel
| QDialogButtonBox.Ok
| QDialogButtonBox.Help)
self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.verticalLayout = QVBoxLayout()
self.verticalLayout.setSpacing(5)
self.verticalLayout.setMargin(20)
self.bar = QgsMessageBar()
self.bar.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed)
self.verticalLayout.addWidget(self.bar)
hLayout = QHBoxLayout()
hLayout.setSpacing(5)
hLayout.setMargin(0)
descriptionLabel = QLabel(self.tr("Description"))
self.descriptionBox = QLineEdit()
self.descriptionBox.setText(self._alg.displayName())
hLayout.addWidget(descriptionLabel)
hLayout.addWidget(self.descriptionBox)
self.verticalLayout.addLayout(hLayout)
line = QFrame()
line.setFrameShape(QFrame.HLine)
line.setFrameShadow(QFrame.Sunken)
self.verticalLayout.addWidget(line)
for param in self._alg.parameterDefinitions():
if param.flags() & QgsProcessingParameterDefinition.FlagAdvanced:
self.advancedButton = QPushButton()
self.advancedButton.setText(
self.tr('Show advanced parameters'))
self.advancedButton.clicked.connect(
self.showAdvancedParametersClicked)
advancedButtonHLayout = QHBoxLayout()
advancedButtonHLayout.addWidget(self.advancedButton)
advancedButtonHLayout.addStretch()
self.verticalLayout.addLayout(advancedButtonHLayout)
break
for param in self._alg.parameterDefinitions():
if param.isDestination(
) or param.flags() & QgsProcessingParameterDefinition.FlagHidden:
continue
desc = param.description()
if isinstance(param, QgsProcessingParameterExtent):
desc += self.tr('(xmin, xmax, ymin, ymax)')
if isinstance(param, QgsProcessingParameterPoint):
desc += self.tr('(x, y)')
if param.flags() & QgsProcessingParameterDefinition.FlagOptional:
desc += self.tr(' [optional]')
label = QLabel(desc)
self.labels[param.name()] = label
wrapper = WidgetWrapperFactory.create_wrapper(param, self)
self.wrappers[param.name()] = wrapper
widget = wrapper.widget
if widget is not None:
self.valueItems[param.name()] = widget
tooltip = param.description()
label.setToolTip(tooltip)
widget.setToolTip(tooltip)
if param.flags(
) & QgsProcessingParameterDefinition.FlagAdvanced:
label.setVisible(self.showAdvanced)
widget.setVisible(self.showAdvanced)
self.widgets[param.name()] = widget
self.verticalLayout.addWidget(label)
self.verticalLayout.addWidget(widget)
for dest in self._alg.destinationParameterDefinitions():
if dest.flags() & QgsProcessingParameterDefinition.FlagHidden:
continue
if isinstance(dest, (QgsProcessingParameterRasterDestination,
QgsProcessingParameterFeatureSink,
QgsProcessingParameterFileDestination,
QgsProcessingParameterFolderDestination)):
label = QLabel(dest.description())
item = QgsFilterLineEdit()
if hasattr(item, 'setPlaceholderText'):
item.setPlaceholderText(ModelerParametersDialog.ENTER_NAME)
self.verticalLayout.addWidget(label)
self.verticalLayout.addWidget(item)
self.valueItems[dest.name()] = item
label = QLabel(' ')
self.verticalLayout.addWidget(label)
label = QLabel(self.tr('Parent algorithms'))
self.dependenciesPanel = self.getDependenciesPanel()
self.verticalLayout.addWidget(label)
self.verticalLayout.addWidget(self.dependenciesPanel)
self.verticalLayout.addStretch(1000)
self.setPreviousValues()
self.setWindowTitle(self._alg.displayName())
self.verticalLayout2 = QVBoxLayout()
self.verticalLayout2.setSpacing(2)
self.verticalLayout2.setMargin(0)
self.paramPanel = QWidget()
self.paramPanel.setLayout(self.verticalLayout)
self.scrollArea = QgsScrollArea()
self.scrollArea.setWidget(self.paramPanel)
self.scrollArea.setWidgetResizable(True)
self.verticalLayout2.addWidget(self.scrollArea)
self.verticalLayout2.addWidget(self.buttonBox)
self.setLayout(self.verticalLayout2)
self.buttonBox.accepted.connect(self.okPressed)
self.buttonBox.rejected.connect(self.cancelPressed)
self.buttonBox.helpRequested.connect(self.openHelp)
QMetaObject.connectSlotsByName(self)
for wrapper in list(self.wrappers.values()):
wrapper.postInitialize(list(self.wrappers.values()))
def __init__(self, parent, geometryWin, numWin):
def populateStatusBar():
statusBar = self.statusBar()
w = QCheckBox("Render", self)
w.setObjectName('renderCheck')
w.setToolTip("Toggle map rendering")
w.setChecked(True)
statusBar.addPermanentWidget(w)
w = QCheckBox("Marker", self)
w.setObjectName('markerCheck')
w.setToolTip("Toggle marker with cursor position from main map")
w.setChecked(False)
statusBar.addPermanentWidget(w, 1)
w = QCheckBox("Extent", self)
w.setObjectName('extentCheck')
w.setToolTip("Show extent of main map")
w.setChecked(False)
statusBar.addPermanentWidget(w, 1)
w = QToolButton(self)
w.setObjectName('highlightBtn')
w.setToolTip("Highlight extent in main map")
w.setText("Highlight")
statusBar.addPermanentWidget(w, 1)
w = QLabel("Scale factor:", self)
w.setObjectName('scaleFactorLabel')
w.setAlignment(Qt.AlignRight | Qt.AlignVCenter)
statusBar.addPermanentWidget(w, 1)
w = QDoubleSpinBox(self)
w.setObjectName('scaleFactorSpin')
w.setToolTip("Current scale factor of main map")
w.setMinimum(0.0)
w.setMaximum(1000.0)
w.setDecimals(3)
w.setValue(1)
w.setSingleStep(.05)
statusBar.addPermanentWidget(w, 1)
w = QToolButton(self)
w.setObjectName('scaleBtn')
w.setToolTip("Set scale for main map")
w.setText("Scale: ")
statusBar.addPermanentWidget(w, 1)
def setupUi():
self.setObjectName("AuxiliaryWindow")
self.setGeometry(geometryWin)
self.addDockWidget(Qt.LeftDockWidgetArea, self.dockLegend)
self.actLegend = self.menuBar().addAction("")
self.actLegend.triggered.connect(self.onActionLegend)
self.canvas.setMapTool(self.toolPan)
self.canvas.setCanvasColor(QColor(255, 255, 255))
self.canvas.enableAntiAliasing(False)
self.canvas.useImageToRender(False)
self.canvas.setWheelAction(QgsMapCanvas.WheelZoom)
self.setCentralWidget(centralWidget)
self.messageBar.setSizePolicy(QSizePolicy.Minimum,
QSizePolicy.Fixed)
layout = QGridLayout()
layout.setContentsMargins(0, 0, 0, 0)
layout.addWidget(self.canvas, 0, 0, 2, 1)
layout.addWidget(self.messageBar, 0, 0, 1, 1)
centralWidget.setLayout(layout)
super(AuxiliaryWindow, self).__init__(parent)
centralWidget = QWidget(self)
self.canvas = QgsMapCanvas(centralWidget)
self.messageBar = QgsMessageBar(centralWidget)
self.toolPan = QgsMapToolPan(self.canvas)
self.qgisCanvas = qgis.utils.iface.mapCanvas()
self.qgisTView = qgis.utils.iface.layerTreeView()
self.qgisSyncGroup = None
self.numWin = numWin
self.ltg = QgsLayerTreeGroup('', Qt.Unchecked)
self.dockLegend = AuxiliaryLegend(self, numWin)
self.root = QgsProject.instance().layerTreeRoot()
self.extent = self.actLegend = None
self.marker = MarkerWindow(self.canvas)
setupUi()
populateStatusBar()
self.onCurrentLayerChanged(None)
self.onDestinationCrsChanged_MapUnitsChanged()
self.onHasCrsTransformEnabledChanged(
self.qgisCanvas.hasCrsTransformEnabled())
def __init__(self, model=None):
super().__init__(None)
self.setAttribute(Qt.WA_DeleteOnClose)
self.setupUi(self)
# LOTS of bug reports when we include the dock creation in the UI file
# see e.g. #16428, #19068
# So just roll it all by hand......!
self.propertiesDock = QgsDockWidget(self)
self.propertiesDock.setFeatures(QDockWidget.DockWidgetFloatable
| QDockWidget.DockWidgetMovable)
self.propertiesDock.setObjectName("propertiesDock")
propertiesDockContents = QWidget()
self.verticalDockLayout_1 = QVBoxLayout(propertiesDockContents)
self.verticalDockLayout_1.setContentsMargins(0, 0, 0, 0)
self.verticalDockLayout_1.setSpacing(0)
self.scrollArea_1 = QgsScrollArea(propertiesDockContents)
sizePolicy = QSizePolicy(QSizePolicy.MinimumExpanding,
QSizePolicy.MinimumExpanding)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(
self.scrollArea_1.sizePolicy().hasHeightForWidth())
self.scrollArea_1.setSizePolicy(sizePolicy)
self.scrollArea_1.setFocusPolicy(Qt.WheelFocus)
self.scrollArea_1.setFrameShape(QFrame.NoFrame)
self.scrollArea_1.setFrameShadow(QFrame.Plain)
self.scrollArea_1.setWidgetResizable(True)
self.scrollAreaWidgetContents_1 = QWidget()
self.gridLayout = QGridLayout(self.scrollAreaWidgetContents_1)
self.gridLayout.setContentsMargins(6, 6, 6, 6)
self.gridLayout.setSpacing(4)
self.label_1 = QLabel(self.scrollAreaWidgetContents_1)
self.gridLayout.addWidget(self.label_1, 0, 0, 1, 1)
self.textName = QLineEdit(self.scrollAreaWidgetContents_1)
self.gridLayout.addWidget(self.textName, 0, 1, 1, 1)
self.label_2 = QLabel(self.scrollAreaWidgetContents_1)
self.gridLayout.addWidget(self.label_2, 1, 0, 1, 1)
self.textGroup = QLineEdit(self.scrollAreaWidgetContents_1)
self.gridLayout.addWidget(self.textGroup, 1, 1, 1, 1)
self.label_1.setText(self.tr("Name"))
self.textName.setToolTip(self.tr("Enter model name here"))
self.label_2.setText(self.tr("Group"))
self.textGroup.setToolTip(self.tr("Enter group name here"))
self.scrollArea_1.setWidget(self.scrollAreaWidgetContents_1)
self.verticalDockLayout_1.addWidget(self.scrollArea_1)
self.propertiesDock.setWidget(propertiesDockContents)
self.addDockWidget(Qt.DockWidgetArea(1), self.propertiesDock)
self.propertiesDock.setWindowTitle(self.tr("Model properties"))
self.inputsDock = QgsDockWidget(self)
self.inputsDock.setFeatures(QDockWidget.DockWidgetFloatable
| QDockWidget.DockWidgetMovable)
self.inputsDock.setObjectName("inputsDock")
self.inputsDockContents = QWidget()
self.verticalLayout_3 = QVBoxLayout(self.inputsDockContents)
self.verticalLayout_3.setContentsMargins(0, 0, 0, 0)
self.scrollArea_2 = QgsScrollArea(self.inputsDockContents)
sizePolicy.setHeightForWidth(
self.scrollArea_2.sizePolicy().hasHeightForWidth())
self.scrollArea_2.setSizePolicy(sizePolicy)
self.scrollArea_2.setFocusPolicy(Qt.WheelFocus)
self.scrollArea_2.setFrameShape(QFrame.NoFrame)
self.scrollArea_2.setFrameShadow(QFrame.Plain)
self.scrollArea_2.setWidgetResizable(True)
self.scrollAreaWidgetContents_2 = QWidget()
self.verticalLayout = QVBoxLayout(self.scrollAreaWidgetContents_2)
self.verticalLayout.setContentsMargins(0, 0, 0, 0)
self.verticalLayout.setSpacing(0)
self.inputsTree = QTreeWidget(self.scrollAreaWidgetContents_2)
self.inputsTree.setAlternatingRowColors(True)
self.inputsTree.header().setVisible(False)
self.verticalLayout.addWidget(self.inputsTree)
self.scrollArea_2.setWidget(self.scrollAreaWidgetContents_2)
self.verticalLayout_3.addWidget(self.scrollArea_2)
self.inputsDock.setWidget(self.inputsDockContents)
self.addDockWidget(Qt.DockWidgetArea(1), self.inputsDock)
self.inputsDock.setWindowTitle(self.tr("Inputs"))
self.algorithmsDock = QgsDockWidget(self)
self.algorithmsDock.setFeatures(QDockWidget.DockWidgetFloatable
| QDockWidget.DockWidgetMovable)
self.algorithmsDock.setObjectName("algorithmsDock")
self.algorithmsDockContents = QWidget()
self.verticalLayout_4 = QVBoxLayout(self.algorithmsDockContents)
self.verticalLayout_4.setContentsMargins(0, 0, 0, 0)
self.scrollArea_3 = QgsScrollArea(self.algorithmsDockContents)
sizePolicy.setHeightForWidth(
self.scrollArea_3.sizePolicy().hasHeightForWidth())
self.scrollArea_3.setSizePolicy(sizePolicy)
self.scrollArea_3.setFocusPolicy(Qt.WheelFocus)
self.scrollArea_3.setFrameShape(QFrame.NoFrame)
self.scrollArea_3.setFrameShadow(QFrame.Plain)
self.scrollArea_3.setWidgetResizable(True)
self.scrollAreaWidgetContents_3 = QWidget()
self.verticalLayout_2 = QVBoxLayout(self.scrollAreaWidgetContents_3)
self.verticalLayout_2.setContentsMargins(0, 0, 0, 0)
self.verticalLayout_2.setSpacing(4)
self.searchBox = QgsFilterLineEdit(self.scrollAreaWidgetContents_3)
self.verticalLayout_2.addWidget(self.searchBox)
self.algorithmTree = QgsProcessingToolboxTreeView(
None, QgsApplication.processingRegistry())
self.algorithmTree.setAlternatingRowColors(True)
self.algorithmTree.header().setVisible(False)
self.verticalLayout_2.addWidget(self.algorithmTree)
self.scrollArea_3.setWidget(self.scrollAreaWidgetContents_3)
self.verticalLayout_4.addWidget(self.scrollArea_3)
self.algorithmsDock.setWidget(self.algorithmsDockContents)
self.addDockWidget(Qt.DockWidgetArea(1), self.algorithmsDock)
self.algorithmsDock.setWindowTitle(self.tr("Algorithms"))
self.searchBox.setToolTip(
self.tr("Enter algorithm name to filter list"))
self.searchBox.setShowSearchIcon(True)
self.bar = QgsMessageBar()
self.bar.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed)
self.centralWidget().layout().insertWidget(0, self.bar)
try:
self.setDockOptions(self.dockOptions()
| QMainWindow.GroupedDragging)
except:
pass
if iface is not None:
self.mToolbar.setIconSize(iface.iconSize())
self.setStyleSheet(iface.mainWindow().styleSheet())
self.mActionOpen.setIcon(
QgsApplication.getThemeIcon('/mActionFileOpen.svg'))
self.mActionSave.setIcon(
QgsApplication.getThemeIcon('/mActionFileSave.svg'))
self.mActionSaveAs.setIcon(
QgsApplication.getThemeIcon('/mActionFileSaveAs.svg'))
self.mActionSaveInProject.setIcon(
QgsApplication.getThemeIcon('/mAddToProject.svg'))
self.mActionZoomActual.setIcon(
QgsApplication.getThemeIcon('/mActionZoomActual.svg'))
self.mActionZoomIn.setIcon(
QgsApplication.getThemeIcon('/mActionZoomIn.svg'))
self.mActionZoomOut.setIcon(
QgsApplication.getThemeIcon('/mActionZoomOut.svg'))
self.mActionExportImage.setIcon(
QgsApplication.getThemeIcon('/mActionSaveMapAsImage.svg'))
self.mActionZoomToItems.setIcon(
QgsApplication.getThemeIcon('/mActionZoomFullExtent.svg'))
self.mActionExportPdf.setIcon(
QgsApplication.getThemeIcon('/mActionSaveAsPDF.svg'))
self.mActionExportSvg.setIcon(
QgsApplication.getThemeIcon('/mActionSaveAsSVG.svg'))
#self.mActionExportPython.setIcon(
# QgsApplication.getThemeIcon('/mActionSaveAsPython.svg'))
self.mActionEditHelp.setIcon(
QgsApplication.getThemeIcon('/mActionEditHelpContent.svg'))
self.mActionRun.setIcon(
QgsApplication.getThemeIcon('/mActionStart.svg'))
self.addDockWidget(Qt.LeftDockWidgetArea, self.propertiesDock)
self.addDockWidget(Qt.LeftDockWidgetArea, self.inputsDock)
self.addDockWidget(Qt.LeftDockWidgetArea, self.algorithmsDock)
self.tabifyDockWidget(self.inputsDock, self.algorithmsDock)
self.inputsDock.raise_()
self.zoom = 1
self.setWindowFlags(Qt.WindowMinimizeButtonHint
| Qt.WindowMaximizeButtonHint
| Qt.WindowCloseButtonHint)
settings = QgsSettings()
self.restoreState(
settings.value("/Processing/stateModeler", QByteArray()))
self.restoreGeometry(
settings.value("/Processing/geometryModeler", QByteArray()))
self.scene = ModelerScene(self, dialog=self)
self.scene.setSceneRect(
QRectF(0, 0, self.CANVAS_SIZE, self.CANVAS_SIZE))
self.view.setScene(self.scene)
self.view.setAcceptDrops(True)
self.view.ensureVisible(0, 0, 10, 10)
def _dragEnterEvent(event):
if event.mimeData().hasText() or event.mimeData().hasFormat(
'application/x-vnd.qgis.qgis.algorithmid'):
event.acceptProposedAction()
else:
event.ignore()
def _dropEvent(event):
if event.mimeData().hasFormat(
'application/x-vnd.qgis.qgis.algorithmid'):
data = event.mimeData().data(
'application/x-vnd.qgis.qgis.algorithmid')
stream = QDataStream(data, QIODevice.ReadOnly)
algorithm_id = stream.readQString()
alg = QgsApplication.processingRegistry().createAlgorithmById(
algorithm_id)
if alg is not None:
self._addAlgorithm(alg, event.pos())
else:
assert False, algorithm_id
elif event.mimeData().hasText():
itemId = event.mimeData().text()
if itemId in [
param.id() for param in QgsApplication.instance().
processingRegistry().parameterTypes()
]:
self.addInputOfType(itemId, event.pos())
event.accept()
else:
event.ignore()
def _dragMoveEvent(event):
if event.mimeData().hasText() or event.mimeData().hasFormat(
'application/x-vnd.qgis.qgis.algorithmid'):
event.accept()
else:
event.ignore()
def _wheelEvent(event):
self.view.setTransformationAnchor(QGraphicsView.AnchorUnderMouse)
settings = QgsSettings()
factor = settings.value('/qgis/zoom_favor', 2.0)
# "Normal" mouse has an angle delta of 120, precision mouses provide data
# faster, in smaller steps
factor = 1.0 + (factor - 1.0) / 120.0 * abs(event.angleDelta().y())
if (event.modifiers() == Qt.ControlModifier):
factor = 1.0 + (factor - 1.0) / 20.0
if event.angleDelta().y() < 0:
factor = 1 / factor
self.view.scale(factor, factor)
def _enterEvent(e):
QGraphicsView.enterEvent(self.view, e)
self.view.viewport().setCursor(Qt.ArrowCursor)
def _mouseReleaseEvent(e):
QGraphicsView.mouseReleaseEvent(self.view, e)
self.view.viewport().setCursor(Qt.ArrowCursor)
def _mousePressEvent(e):
if e.button() == Qt.MidButton:
self.previousMousePos = e.pos()
else:
QGraphicsView.mousePressEvent(self.view, e)
def _mouseMoveEvent(e):
if e.buttons() == Qt.MidButton:
offset = self.previousMousePos - e.pos()
self.previousMousePos = e.pos()
self.view.verticalScrollBar().setValue(
self.view.verticalScrollBar().value() + offset.y())
self.view.horizontalScrollBar().setValue(
self.view.horizontalScrollBar().value() + offset.x())
else:
QGraphicsView.mouseMoveEvent(self.view, e)
self.view.setDragMode(QGraphicsView.ScrollHandDrag)
self.view.dragEnterEvent = _dragEnterEvent
self.view.dropEvent = _dropEvent
self.view.dragMoveEvent = _dragMoveEvent
self.view.wheelEvent = _wheelEvent
self.view.enterEvent = _enterEvent
self.view.mousePressEvent = _mousePressEvent
self.view.mouseMoveEvent = _mouseMoveEvent
def _mimeDataInput(items):
mimeData = QMimeData()
text = items[0].data(0, Qt.UserRole)
mimeData.setText(text)
return mimeData
self.inputsTree.mimeData = _mimeDataInput
self.inputsTree.setDragDropMode(QTreeWidget.DragOnly)
self.inputsTree.setDropIndicatorShown(True)
self.algorithms_model = ModelerToolboxModel(
self, QgsApplication.processingRegistry())
self.algorithmTree.setToolboxProxyModel(self.algorithms_model)
self.algorithmTree.setDragDropMode(QTreeWidget.DragOnly)
self.algorithmTree.setDropIndicatorShown(True)
self.algorithmTree.setFilters(
QgsProcessingToolboxProxyModel.FilterModeler)
if hasattr(self.searchBox, 'setPlaceholderText'):
self.searchBox.setPlaceholderText(
QCoreApplication.translate('ModelerDialog', 'Search…'))
if hasattr(self.textName, 'setPlaceholderText'):
self.textName.setPlaceholderText(self.tr('Enter model name here'))
if hasattr(self.textGroup, 'setPlaceholderText'):
self.textGroup.setPlaceholderText(self.tr('Enter group name here'))
# Connect signals and slots
self.inputsTree.doubleClicked.connect(self.addInput)
self.searchBox.textChanged.connect(self.algorithmTree.setFilterString)
self.algorithmTree.doubleClicked.connect(self.addAlgorithm)
# Ctrl+= should also trigger a zoom in action
ctrlEquals = QShortcut(QKeySequence("Ctrl+="), self)
ctrlEquals.activated.connect(self.zoomIn)
self.mActionOpen.triggered.connect(self.openModel)
self.mActionSave.triggered.connect(self.save)
self.mActionSaveAs.triggered.connect(self.saveAs)
self.mActionSaveInProject.triggered.connect(self.saveInProject)
self.mActionZoomIn.triggered.connect(self.zoomIn)
self.mActionZoomOut.triggered.connect(self.zoomOut)
self.mActionZoomActual.triggered.connect(self.zoomActual)
self.mActionZoomToItems.triggered.connect(self.zoomToItems)
self.mActionExportImage.triggered.connect(self.exportAsImage)
self.mActionExportPdf.triggered.connect(self.exportAsPdf)
self.mActionExportSvg.triggered.connect(self.exportAsSvg)
#self.mActionExportPython.triggered.connect(self.exportAsPython)
self.mActionEditHelp.triggered.connect(self.editHelp)
self.mActionRun.triggered.connect(self.runModel)
if model is not None:
self.model = model.create()
self.model.setSourceFilePath(model.sourceFilePath())
self.textGroup.setText(self.model.group())
self.textName.setText(self.model.displayName())
self.repaintModel()
else:
self.model = QgsProcessingModelAlgorithm()
self.model.setProvider(
QgsApplication.processingRegistry().providerById('model'))
self.fillInputsTree()
self.view.centerOn(0, 0)
self.help = None
self.hasChanged = False
def setupUi(self, ui_main_window):
ui_main_window.setObjectName("ui_main_window")
ui_main_window.setWindowModality(QtCore.Qt.WindowModal)
ui_main_window.resize(820, 620)
ui_main_window.setWindowTitle("QuickOSM")
self.horizontalLayout = QtWidgets.QHBoxLayout(ui_main_window)
self.horizontalLayout.setContentsMargins(0, 0, 0, 0)
self.horizontalLayout.setSpacing(0)
self.horizontalLayout.setObjectName("horizontalLayout")
self.listWidget = QtWidgets.QListWidget(ui_main_window)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Minimum,
QtWidgets.QSizePolicy.Expanding)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(
self.listWidget.sizePolicy().hasHeightForWidth())
self.listWidget.setSizePolicy(sizePolicy)
self.listWidget.setMinimumSize(QtCore.QSize(100, 200))
self.listWidget.setMaximumSize(QtCore.QSize(153, 16777215))
self.listWidget.setStyleSheet(
"QListWidget{\n"
" background-color: rgb(69, 69, 69, 220);\n"
" outline: 0;\n"
"}\n"
"QListWidget::item {\n"
" color: white;\n"
" padding: 3px;\n"
"}\n"
"QListWidget::item::selected {\n"
" color: black;\n"
" background-color:palette(Window);\n"
" padding-right: 0px;\n"
"}")
self.listWidget.setFrameShape(QtWidgets.QFrame.Box)
self.listWidget.setLineWidth(0)
self.listWidget.setIconSize(QtCore.QSize(32, 32))
self.listWidget.setUniformItemSizes(True)
self.listWidget.setObjectName("listWidget")
item = QtWidgets.QListWidgetItem()
self.listWidget.addItem(item)
item = QtWidgets.QListWidgetItem()
self.listWidget.addItem(item)
item = QtWidgets.QListWidgetItem()
self.listWidget.addItem(item)
item = QtWidgets.QListWidgetItem()
self.listWidget.addItem(item)
item = QtWidgets.QListWidgetItem()
self.listWidget.addItem(item)
self.horizontalLayout.addWidget(self.listWidget)
self.verticalLayout_13 = QtWidgets.QVBoxLayout()
self.verticalLayout_13.setObjectName("verticalLayout_13")
self.messageBar = QgsMessageBar(ui_main_window)
self.messageBar.setObjectName("messageBar")
self.verticalLayout_13.addWidget(self.messageBar)
self.stackedWidget = QtWidgets.QStackedWidget(ui_main_window)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Preferred,
QtWidgets.QSizePolicy.Preferred)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(
self.stackedWidget.sizePolicy().hasHeightForWidth())
self.stackedWidget.setSizePolicy(sizePolicy)
self.stackedWidget.setMinimumSize(QtCore.QSize(300, 200))
self.stackedWidget.setObjectName("stackedWidget")
self.quick_query = QuickQueryWidget()
self.quick_query.setObjectName("quick_query")
self.stackedWidget.addWidget(self.quick_query)
self.query = QueryWidget()
self.query.setObjectName("query")
self.stackedWidget.addWidget(self.query)
self.osm_file = OsmFileWidget()
self.osm_file.setObjectName("osm_file")
self.stackedWidget.addWidget(self.osm_file)
self.parameters = QtWidgets.QWidget()
self.parameters.setObjectName("parameters")
self.verticalLayout_2 = QtWidgets.QVBoxLayout(self.parameters)
self.verticalLayout_2.setObjectName("verticalLayout_2")
self.groupBox = QtWidgets.QGroupBox(self.parameters)
self.groupBox.setObjectName("groupBox")
self.verticalLayout = QtWidgets.QVBoxLayout(self.groupBox)
self.verticalLayout.setObjectName("verticalLayout")
self.horizontalLayout_8 = QtWidgets.QHBoxLayout()
self.horizontalLayout_8.setObjectName("horizontalLayout_8")
self.comboBox_default_OAPI = QtWidgets.QComboBox(self.groupBox)
self.comboBox_default_OAPI.setObjectName("comboBox_default_OAPI")
self.horizontalLayout_8.addWidget(self.comboBox_default_OAPI)
self.verticalLayout.addLayout(self.horizontalLayout_8)
self.timestamp_group = QtWidgets.QGroupBox(self.groupBox)
self.timestamp_group.setObjectName("timestamp_group")
self.verticalLayout_3 = QtWidgets.QVBoxLayout(self.timestamp_group)
self.verticalLayout_3.setObjectName("verticalLayout_3")
self.horizontalLayout_2 = QtWidgets.QHBoxLayout()
self.horizontalLayout_2.setObjectName("horizontalLayout_2")
self.pushButton_OAPI_timestamp = QtWidgets.QPushButton(
self.timestamp_group)
self.pushButton_OAPI_timestamp.setObjectName(
"pushButton_OAPI_timestamp")
self.horizontalLayout_2.addWidget(self.pushButton_OAPI_timestamp)
self.label_timestamp_oapi = QtWidgets.QLabel(self.timestamp_group)
self.label_timestamp_oapi.setObjectName("label_timestamp_oapi")
self.horizontalLayout_2.addWidget(self.label_timestamp_oapi)
self.verticalLayout_3.addLayout(self.horizontalLayout_2)
self.verticalLayout.addWidget(self.timestamp_group)
self.verticalLayout_2.addWidget(self.groupBox)
self.restore_queries_group = QtWidgets.QGroupBox(self.parameters)
self.restore_queries_group.setEnabled(False)
self.restore_queries_group.setObjectName("restore_queries_group")
self.verticalLayout_10 = QtWidgets.QVBoxLayout(
self.restore_queries_group)
self.verticalLayout_10.setObjectName("verticalLayout_10")
self.horizontalLayout_7 = QtWidgets.QHBoxLayout()
self.horizontalLayout_7.setObjectName("horizontalLayout_7")
self.pushButton_restoreQueries = QtWidgets.QPushButton(
self.restore_queries_group)
self.pushButton_restoreQueries.setObjectName(
"pushButton_restoreQueries")
self.horizontalLayout_7.addWidget(self.pushButton_restoreQueries)
spacerItem = QtWidgets.QSpacerItem(40, 20,
QtWidgets.QSizePolicy.Expanding,
QtWidgets.QSizePolicy.Minimum)
self.horizontalLayout_7.addItem(spacerItem)
self.verticalLayout_10.addLayout(self.horizontalLayout_7)
self.verticalLayout_2.addWidget(self.restore_queries_group)
self.output_format_option = QtWidgets.QGroupBox(self.parameters)
self.output_format_option.setObjectName("output_format_option")
self.verticalLayout_11 = QtWidgets.QVBoxLayout(
self.output_format_option)
self.verticalLayout_11.setObjectName("verticalLayout_11")
self.radioButton_outputJson = QtWidgets.QRadioButton(
self.output_format_option)
self.radioButton_outputJson.setObjectName("radioButton_outputJson")
self.verticalLayout_11.addWidget(self.radioButton_outputJson)
self.radioButton_outputShape = QtWidgets.QRadioButton(
self.output_format_option)
self.radioButton_outputShape.setObjectName("radioButton_outputShape")
self.verticalLayout_11.addWidget(self.radioButton_outputShape)
self.verticalLayout_2.addWidget(self.output_format_option)
spacerItem1 = QtWidgets.QSpacerItem(20, 40,
QtWidgets.QSizePolicy.Minimum,
QtWidgets.QSizePolicy.Expanding)
self.verticalLayout_2.addItem(spacerItem1)
self.stackedWidget.addWidget(self.parameters)
self.about = QtWidgets.QWidget()
self.about.setObjectName("about")
self.verticalLayout_4 = QtWidgets.QVBoxLayout(self.about)
self.verticalLayout_4.setObjectName("verticalLayout_4")
self.scrollArea_2 = QtWidgets.QScrollArea(self.about)
self.scrollArea_2.setWidgetResizable(True)
self.scrollArea_2.setObjectName("scrollArea_2")
self.scrollAreaWidgetContents_2 = QtWidgets.QWidget()
self.scrollAreaWidgetContents_2.setGeometry(
QtCore.QRect(0, 0, 645, 592))
self.scrollAreaWidgetContents_2.setObjectName(
"scrollAreaWidgetContents_2")
self.verticalLayout_9 = QtWidgets.QVBoxLayout(
self.scrollAreaWidgetContents_2)
self.verticalLayout_9.setObjectName("verticalLayout_9")
self.groupBox_2 = QtWidgets.QGroupBox(self.scrollAreaWidgetContents_2)
self.groupBox_2.setObjectName("groupBox_2")
self.horizontalLayout_6 = QtWidgets.QHBoxLayout(self.groupBox_2)
self.horizontalLayout_6.setObjectName("horizontalLayout_6")
self.horizontalLayout_5 = QtWidgets.QHBoxLayout()
self.horizontalLayout_5.setObjectName("horizontalLayout_5")
self.label_13 = QtWidgets.QLabel(self.groupBox_2)
self.label_13.setMaximumSize(QtCore.QSize(16777215, 16777215))
self.label_13.setText(
"<html><head/><body><p>Etienne Trimaille</p></body></html>")
self.label_13.setScaledContents(False)
self.label_13.setOpenExternalLinks(True)
self.label_13.setObjectName("label_13")
self.horizontalLayout_5.addWidget(self.label_13)
self.label_14 = QtWidgets.QLabel(self.groupBox_2)
self.label_14.setText(
"<a href=\"mailto:[email protected]?subject=Plugin QuickOSM - About\" style=\"color:#7BA11A;text-decoration:none;\">[email protected]</a>"
)
self.label_14.setOpenExternalLinks(True)
self.label_14.setObjectName("label_14")
self.horizontalLayout_5.addWidget(self.label_14)
self.horizontalLayout_6.addLayout(self.horizontalLayout_5)
self.verticalLayout_9.addWidget(self.groupBox_2)
self.groupBox_8 = QtWidgets.QGroupBox(self.scrollAreaWidgetContents_2)
self.groupBox_8.setObjectName("groupBox_8")
self.horizontalLayout_9 = QtWidgets.QHBoxLayout(self.groupBox_8)
self.horizontalLayout_9.setObjectName("horizontalLayout_9")
self.verticalLayout_12 = QtWidgets.QVBoxLayout()
self.verticalLayout_12.setObjectName("verticalLayout_12")
self.label_18 = QtWidgets.QLabel(self.groupBox_8)
self.label_18.setScaledContents(True)
self.label_18.setWordWrap(True)
self.label_18.setObjectName("label_18")
self.verticalLayout_12.addWidget(self.label_18)
self.horizontalLayout_14 = QtWidgets.QHBoxLayout()
self.horizontalLayout_14.setObjectName("horizontalLayout_14")
self.label_21 = QtWidgets.QLabel(self.groupBox_8)
self.label_21.setObjectName("label_21")
self.horizontalLayout_14.addWidget(self.label_21)
self.label_22 = QtWidgets.QLabel(self.groupBox_8)
self.label_22.setText("Antony Bartolo")
self.label_22.setObjectName("label_22")
self.horizontalLayout_14.addWidget(self.label_22)
self.verticalLayout_12.addLayout(self.horizontalLayout_14)
self.horizontalLayout_15 = QtWidgets.QHBoxLayout()
self.horizontalLayout_15.setObjectName("horizontalLayout_15")
self.label_23 = QtWidgets.QLabel(self.groupBox_8)
self.label_23.setObjectName("label_23")
self.horizontalLayout_15.addWidget(self.label_23)
self.label_24 = QtWidgets.QLabel(self.groupBox_8)
self.label_24.setText("Kari Salovaara")
self.label_24.setObjectName("label_24")
self.horizontalLayout_15.addWidget(self.label_24)
self.verticalLayout_12.addLayout(self.horizontalLayout_15)
self.horizontalLayout_13 = QtWidgets.QHBoxLayout()
self.horizontalLayout_13.setObjectName("horizontalLayout_13")
self.label_17 = QtWidgets.QLabel(self.groupBox_8)
self.label_17.setObjectName("label_17")
self.horizontalLayout_13.addWidget(self.label_17)
self.label_9 = QtWidgets.QLabel(self.groupBox_8)
self.label_9.setText("Etienne Trimaille")
self.label_9.setObjectName("label_9")
self.horizontalLayout_13.addWidget(self.label_9)
self.verticalLayout_12.addLayout(self.horizontalLayout_13)
self.horizontalLayout_12 = QtWidgets.QHBoxLayout()
self.horizontalLayout_12.setObjectName("horizontalLayout_12")
self.label_6 = QtWidgets.QLabel(self.groupBox_8)
self.label_6.setObjectName("label_6")
self.horizontalLayout_12.addWidget(self.label_6)
self.label_5 = QtWidgets.QLabel(self.groupBox_8)
self.label_5.setText("Thomas Moenkemeier")
self.label_5.setObjectName("label_5")
self.horizontalLayout_12.addWidget(self.label_5)
self.verticalLayout_12.addLayout(self.horizontalLayout_12)
self.horizontalLayout_11 = QtWidgets.QHBoxLayout()
self.horizontalLayout_11.setObjectName("horizontalLayout_11")
self.label_8 = QtWidgets.QLabel(self.groupBox_8)
self.label_8.setObjectName("label_8")
self.horizontalLayout_11.addWidget(self.label_8)
self.label_7 = QtWidgets.QLabel(self.groupBox_8)
self.label_7.setText("Francesco Bisantis")
self.label_7.setObjectName("label_7")
self.horizontalLayout_11.addWidget(self.label_7)
self.verticalLayout_12.addLayout(self.horizontalLayout_11)
self.horizontalLayout_10 = QtWidgets.QHBoxLayout()
self.horizontalLayout_10.setObjectName("horizontalLayout_10")
self.label_4 = QtWidgets.QLabel(self.groupBox_8)
self.label_4.setObjectName("label_4")
self.horizontalLayout_10.addWidget(self.label_4)
self.label_3 = QtWidgets.QLabel(self.groupBox_8)
self.label_3.setText(
"<a href=\"https://github.com/freeExec\" style=\"color:#7BA11A;text-decoration:none;\">freeExec</a>"
)
self.label_3.setObjectName("label_3")
self.horizontalLayout_10.addWidget(self.label_3)
self.verticalLayout_12.addLayout(self.horizontalLayout_10)
self.horizontalLayout_16 = QtWidgets.QHBoxLayout()
self.horizontalLayout_16.setObjectName("horizontalLayout_16")
self.label_26 = QtWidgets.QLabel(self.groupBox_8)
self.label_26.setObjectName("label_26")
self.horizontalLayout_16.addWidget(self.label_26)
self.label_25 = QtWidgets.QLabel(self.groupBox_8)
self.label_25.setText("Supaplextw")
self.label_25.setObjectName("label_25")
self.horizontalLayout_16.addWidget(self.label_25)
self.verticalLayout_12.addLayout(self.horizontalLayout_16)
self.horizontalLayout_9.addLayout(self.verticalLayout_12)
self.verticalLayout_9.addWidget(self.groupBox_8)
self.groupBox_6 = QtWidgets.QGroupBox(self.scrollAreaWidgetContents_2)
self.groupBox_6.setObjectName("groupBox_6")
self.verticalLayout_8 = QtWidgets.QVBoxLayout(self.groupBox_6)
self.verticalLayout_8.setObjectName("verticalLayout_8")
self.gridLayout_4 = QtWidgets.QGridLayout()
self.gridLayout_4.setObjectName("gridLayout_4")
self.label_19 = QtWidgets.QLabel(self.groupBox_6)
self.label_19.setObjectName("label_19")
self.gridLayout_4.addWidget(self.label_19, 0, 0, 1, 1)
self.label_20 = QtWidgets.QLabel(self.groupBox_6)
self.label_20.setText(
"<a href=\"https://github.com/3liz/QgisQuickOSMPlugin\" style=\"color:#7BA11A;text-decoration:none;\">https://github.com/3liz/QgisQuickOSMPlugin</a>"
)
self.label_20.setOpenExternalLinks(True)
self.label_20.setObjectName("label_20")
self.gridLayout_4.addWidget(self.label_20, 0, 1, 1, 1)
self.verticalLayout_8.addLayout(self.gridLayout_4)
self.verticalLayout_9.addWidget(self.groupBox_6)
self.groupBox_4 = QtWidgets.QGroupBox(self.scrollAreaWidgetContents_2)
self.groupBox_4.setObjectName("groupBox_4")
self.verticalLayout_6 = QtWidgets.QVBoxLayout(self.groupBox_4)
self.verticalLayout_6.setObjectName("verticalLayout_6")
self.gridLayout_3 = QtWidgets.QGridLayout()
self.gridLayout_3.setObjectName("gridLayout_3")
self.label = QtWidgets.QLabel(self.groupBox_4)
self.label.setText("OpenStreetMap")
self.label.setObjectName("label")
self.gridLayout_3.addWidget(self.label, 2, 0, 1, 1)
self.label_gnu = QtWidgets.QLabel(self.groupBox_4)
self.label_gnu.setText("")
self.label_gnu.setAlignment(QtCore.Qt.AlignCenter)
self.label_gnu.setOpenExternalLinks(True)
self.label_gnu.setObjectName("label_gnu")
self.gridLayout_3.addWidget(self.label_gnu, 1, 1, 1, 1)
self.label_15 = QtWidgets.QLabel(self.groupBox_4)
self.label_15.setText("Plugin : Licence GPL Version 2")
self.label_15.setObjectName("label_15")
self.gridLayout_3.addWidget(self.label_15, 1, 0, 1, 1)
self.label_2 = QtWidgets.QLabel(self.groupBox_4)
self.label_2.setText(
"<html><head/><body><p>ODBL : © OpenStreetMap\'s contributors </p><p><a href=\"http://www.openstreetmap.org/copyright\"><span style=\" text-decoration: underline; color:#0057ae;\">http://www.openstreetmap.org/copyright</span></a></p></body></html>"
)
self.label_2.setObjectName("label_2")
self.gridLayout_3.addWidget(self.label_2, 2, 1, 1, 1)
self.verticalLayout_6.addLayout(self.gridLayout_3)
self.verticalLayout_9.addWidget(self.groupBox_4)
self.scrollArea_2.setWidget(self.scrollAreaWidgetContents_2)
self.verticalLayout_4.addWidget(self.scrollArea_2)
self.stackedWidget.addWidget(self.about)
self.verticalLayout_13.addWidget(self.stackedWidget)
self.horizontalLayout.addLayout(self.verticalLayout_13)
self.retranslateUi(ui_main_window)
self.listWidget.setCurrentRow(-1)
self.stackedWidget.setCurrentIndex(3)
self.listWidget.currentRowChanged['int'].connect(
self.stackedWidget.setCurrentIndex)
QtCore.QMetaObject.connectSlotsByName(ui_main_window)
ui_main_window.setTabOrder(self.pushButton_OAPI_timestamp,
self.listWidget)
