def __init__(self, project, parent=None):
'''
Setup dialog widgets with the project properties
'''
super(PosiviewProperties, self).__init__("PosiViewProperties", parent)
self.setupUi(self)
self.groupBox_6.hide()
self.initOptionsBase(False)
self.restoreOptionsBaseUi()
self.comboBoxParser.addItems(PARSERS)
self.comboBoxProviderType.addItems(DEVICE_TYPES)
self.project = project
self.projectProperties = project.properties()
self.mToolButtonLoad.setDefaultAction(self.actionLoadConfiguration)
self.mToolButtonSave.setDefaultAction(self.actionSaveConfiguration)
self.mobileModel = QStringListModel()
self.mobileListModel = QStringListModel()
self.mMobileListView.setModel(self.mobileListModel)
self.mobileProviderModel = QStandardItemModel()
self.mobileProviderModel.setHorizontalHeaderLabels(
('Provider', 'Filter'))
self.mMobileProviderTableView.setModel(self.mobileProviderModel)
self.providerListModel = QStringListModel()
self.mDataProviderListView.setModel(self.providerListModel)
self.comboBoxProviders.setModel(self.providerListModel)
self.setupModelData(self.projectProperties)
self.setupGeneralData(self.projectProperties)
def set_completer(self, tablename, widget, field_search, color='black'):
""" Set autocomplete of widget @table_object + "_id"
getting id's from selected @table_object
"""
if not widget:
return
# Set SQL
sql = (f"SELECT DISTINCT({field_search})"
f" FROM {tablename}"
f" ORDER BY {field_search}")
row = self.controller.get_rows(sql, commit=True)
for i in range(0, len(row)):
aux = row[i]
row[i] = str(aux[0])
# Set completer and model: add autocomplete in the widget
self.completer = QCompleter()
self.completer.setCaseSensitivity(Qt.CaseInsensitive)
self.completer.setCompletionMode(0)
self.completer.popup().setStyleSheet("color: " + color + ";")
widget.setCompleter(self.completer)
model = QStringListModel()
model.setStringList(row)
self.completer.setModel(model)
def createEditor(self, parent, option, index):
if index.column() == 0:
keys = list(self.osm_keys.keys())
keys.append('') # All keys request #118
keys.sort()
keys_completer = QCompleter(keys)
key_editor = QComboBox(parent)
key_editor.setEditable(True)
key_editor.addItems(keys)
key_editor.setCompleter(keys_completer)
key_editor.completer().setCompletionMode(
QCompleter.PopupCompletion)
key_editor.lineEdit().setPlaceholderText(
self.tr('Query on all keys'))
return key_editor
elif index.column() == 1:
model = QStringListModel(parent)
model.setStringList(['11111', '22222', '33333'])
value_editor = QComboBox(parent)
value_editor.setEditable(True)
value_editor.setModel(model)
value_editor.lineEdit().setPlaceholderText(
self.tr('Query on all values'))
return value_editor
def set_completer_object(self, tablename, widget, field_id):
""" Set autocomplete of widget @table_object + "_id"
getting id's from selected @table_object
"""
if not widget:
return
sql = (f"SELECT DISTINCT({field_id}) "
f"FROM {tablename} "
f"ORDER BY {field_id}")
rows = self.controller.get_rows(sql)
if rows is None:
return
for i in range(0, len(rows)):
aux = rows[i]
rows[i] = str(aux[0])
# Set completer and model: add autocomplete in the widget
self.completer = QCompleter()
self.completer.setCaseSensitivity(Qt.CaseInsensitive)
widget.setCompleter(self.completer)
model = QStringListModel()
model.setStringList(rows)
self.completer.setModel(model)
def __init__(self, project, parent=None):
'''
Setup dialog widgets with the project properties
'''
super(PosiviewProperties, self).__init__("PosiViewProperties", parent)
self.setupUi(self)
if not self.PROVIDER_FLAGS:
self.PROVIDER_FLAGS[FILTER_FLAGS[0]] = self.tr('ignore heading')
self.PROVIDER_FLAGS[FILTER_FLAGS[1]] = self.tr('ignore position')
self.PROVIDER_FLAGS[FILTER_FLAGS[2]] = self.tr('course as heading')
self.comboBoxProviderFlags.addItems(list(self.PROVIDER_FLAGS.values()))
self.groupBox_6.hide()
self.initOptionsBase(False)
self.restoreOptionsBaseUi()
self.comboBoxParser.addItems(PARSERS)
self.comboBoxProviderType.addItems(DEVICE_TYPES)
self.project = project
self.projectProperties = project.properties()
self.mToolButtonLoad.setDefaultAction(self.actionLoadConfiguration)
self.mToolButtonSave.setDefaultAction(self.actionSaveConfiguration)
self.mobileListModel = QStringListModel()
self.mMobileListView.setModel(self.mobileListModel)
self.mobileProviderModel = QStandardItemModel()
self.mobileProviderModel.setHorizontalHeaderLabels(
(self.tr('Provider'), self.tr('Filter'),
self.tr('Advanced Filter')))
self.mMobileProviderTableView.setModel(self.mobileProviderModel)
self.providerListModel = QStringListModel()
self.mDataProviderListView.setModel(self.providerListModel)
self.comboBoxProviders.setModel(self.providerListModel)
self.setupModelData(self.projectProperties)
self.setupGeneralData(self.projectProperties)
def set_completer_result(self, widget, viewname, field_name):
""" Set autocomplete of widget 'feature_id'
getting id's from selected @viewname
"""
result_name = qt_tools.getWidgetText(self.dlg_go2epa,
self.dlg_go2epa.txt_result_name)
# Adding auto-completion to a QLineEdit
self.completer = QCompleter()
self.completer.setCaseSensitivity(Qt.CaseInsensitive)
widget.setCompleter(self.completer)
model = QStringListModel()
sql = f"SELECT {field_name} FROM {viewname}"
rows = self.controller.get_rows(sql)
if rows:
for i in range(0, len(rows)):
aux = rows[i]
rows[i] = str(aux[0])
model.setStringList(rows)
self.completer.setModel(model)
if result_name in rows:
self.dlg_go2epa.chk_only_check.setEnabled(True)
def setCompleter(self, values, wgt):
completer = QCompleter(self)
completerModel = QStringListModel(self)
wgt.setCompleter(completer)
completer.setModel(completerModel)
completer.setCaseSensitivity(False)
completerModel.setStringList(values)
def set_completer_object(self, dialog, table_object):
""" Set autocomplete of widget @table_object + "_id"
getting id's from selected @table_object
"""
widget = utils_giswater.getWidget(dialog, table_object + "_id")
if not widget:
return
# Set SQL
field_object_id = "id"
if table_object == "element":
field_object_id = table_object + "_id"
sql = (f"SELECT DISTINCT({field_object_id})"
f" FROM {table_object}")
rows = self.controller.get_rows(sql, commit=self.autocommit)
if rows is None:
return
for i in range(0, len(rows)):
aux = rows[i]
rows[i] = str(aux[0])
# Set completer and model: add autocomplete in the widget
self.completer = QCompleter()
self.completer.setCaseSensitivity(Qt.CaseInsensitive)
widget.setCompleter(self.completer)
model = QStringListModel()
model.setStringList(rows)
self.completer.setModel(model)
def set_completer(self):
""" Set autocompleters of the form """
# Adding auto-completion to a QLineEdit - visit_id
self.completer = QCompleter()
self.dlg_work.arc_id.setCompleter(self.completer)
model = QStringListModel()
model.setStringList(self.selected_list)
self.completer.setModel(model)
def _initGui(self):
"""setup the user interface"""
self.ui = Ui_geopunt4QgisDataCatalogDlg()
self.ui.setupUi(self)
# get settings
self.s = QSettings()
self.loadSettings()
self.gh = geometryHelper(self.iface)
# setup a message bar
self.bar = QgsMessageBar()
self.bar.setSizePolicy( QSizePolicy.Minimum, QSizePolicy.Fixed)
self.ui.verticalLayout.addWidget(self.bar)
self.ui.buttonBox.addButton(QPushButton("Sluiten"), QDialogButtonBox.RejectRole)
for btn in self.ui.buttonBox.buttons():
btn.setAutoDefault(0)
# vars
self.firstShow = True
self.wms = None
self.wfs = None
self.dl = None
self.zoek = ''
self.bronnen = None
self.model = QStandardItemModel(self)
self.proxyModel = QSortFilterProxyModel(self)
self.proxyModel.setSourceModel(self.model)
self.ui.resultView.setModel(self.proxyModel)
self.completer = QCompleter(self)
self.completerModel = QStringListModel(self)
self.ui.zoekTxt.setCompleter(self.completer)
self.completer.setModel(self.completerModel)
# eventhandlers
self.ui.zoekBtn.clicked.connect(self.onZoekClicked)
self.ui.addWMSbtn.clicked.connect(self.addWMS)
self.ui.addWFSbtn.clicked.connect(self.addWFS)
self.ui.DLbtn.clicked.connect(lambda: self.openUrl(self.dl))
self.ui.resultView.clicked.connect(self.resultViewClicked)
self.ui.modelFilterCbx.currentIndexChanged.connect(self.modelFilterCbxIndexChanged)
self.ui.filterWgt.setHidden(1)
self.ui.buttonBox.helpRequested.connect(self.openHelp)
self.finished.connect(self.clean)
def set_completer_lineedit(qlineedit, list_items):
""" Set a completer into a QLineEdit
:param qlineedit: Object where to set the completer (QLineEdit)
:param list_items: List of items to set into the completer (List)["item1","item2","..."]
"""
completer = QCompleter()
completer.setCaseSensitivity(Qt.CaseInsensitive)
completer.setMaxVisibleItems(10)
completer.setCompletionMode(0)
completer.setFilterMode(Qt.MatchContains)
completer.popup().setStyleSheet("color: black;")
qlineedit.setCompleter(completer)
model = QStringListModel()
model.setStringList(list_items)
completer.setModel(model)
def set_model_by_list(string_list, widget, proxy_model):
""" Set the model according to the list """
model = QStringListModel()
model.setStringList(string_list)
proxy_model.setSourceModel(model)
proxy_model.setFilterKeyColumn(0)
proxy_model_aux = QSortFilterProxyModel()
proxy_model_aux.setSourceModel(model)
proxy_model_aux.setFilterKeyColumn(0)
widget.setModel(proxy_model_aux)
widget.setModelColumn(0)
completer = QCompleter()
completer.setModel(proxy_model)
completer.setCompletionColumn(0)
completer.setCompletionMode(QCompleter.UnfilteredPopupCompletion)
widget.setCompleter(completer)
def set_completers(self, widget, table_name):
""" Set autocompleters of the form """
# Adding auto-completion to a QLineEdit - visit_id
self.completer = QCompleter()
widget.setCompleter(self.completer)
model = QStringListModel()
sql = f"SELECT DISTINCT(id) FROM {table_name}"
rows = self.controller.get_rows(sql, commit=self.autocommit)
values = []
if rows:
for row in rows:
values.append(str(row[0]))
model.setStringList(values)
self.completer.setModel(model)
def manage_delete_feature(self):
# Create the dialog and signals
self.dlg_delete_feature = DelFeature()
self.load_settings(self.dlg_delete_feature)
# Populate combo feature type
sql = 'SELECT DISTINCT(feature_type) AS id, feature_type AS idval FROM cat_feature'
rows = self.controller.get_rows(sql)
utils_giswater.set_item_data(self.dlg_delete_feature.feature_type,
rows, 1)
# Set active layer
layer_name = 'v_edit_' + utils_giswater.getWidgetText(
self.dlg_delete_feature,
self.dlg_delete_feature.feature_type).lower()
layer = self.controller.get_layer_by_tablename(layer_name)
self.iface.setActiveLayer(layer)
self.controller.set_layer_visible(layer)
# Disable button delete feature
self.dlg_delete_feature.btn_delete.setEnabled(False)
# Configure feature_id as typeahead
completer = QCompleter()
model = QStringListModel()
self.filter_typeahead(self.dlg_delete_feature.feature_id, completer,
model)
# Set listeners
self.dlg_delete_feature.feature_id.textChanged.connect(
partial(self.filter_typeahead, self.dlg_delete_feature.feature_id,
completer, model))
# Set button snapping
self.dlg_delete_feature.btn_snapping.clicked.connect(
partial(self.set_active_layer))
self.dlg_delete_feature.btn_snapping.clicked.connect(
partial(self.selection_init, self.dlg_delete_feature))
self.set_icon(self.dlg_delete_feature.btn_snapping, "137")
# Set listeners
self.dlg_delete_feature.btn_cancel.clicked.connect(
partial(self.close_dialog, self.dlg_delete_feature))
self.dlg_delete_feature.rejected.connect(
self.disconnect_signal_selection_changed)
self.dlg_delete_feature.rejected.connect(
partial(self.save_settings, self.dlg_delete_feature))
self.dlg_delete_feature.btn_relations.clicked.connect(
partial(self.show_feature_relation))
self.dlg_delete_feature.btn_delete.clicked.connect(
partial(self.delete_feature_relation))
self.dlg_delete_feature.feature_type.currentIndexChanged.connect(
partial(self.set_active_layer))
# Open dialog
self.open_dialog(self.dlg_delete_feature)
def _initGui(self):
"""setup the user interface"""
self.ui = Ui_geopunt4Qgis()
self.ui.setupUi(self)
#get settings
self.s = QSettings()
self.loadSettings()
#setup geometryHelper object
self.gh = geometryHelper(self.iface)
#create graphicsLayer
self.graphicsLayer = []
self.firstShow = True
self.completer = QCompleter(self)
self.completerModel = QStringListModel(self)
self.ui.gemeenteBox.setCompleter(self.completer)
self.completer.setModel(self.completerModel)
self.completer.setCaseSensitivity(False)
#setup a message bar
self.bar = QgsMessageBar()
self.bar.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed)
self.ui.verticalLayout.addWidget(self.bar)
self.ui.buttonBox.addButton(QPushButton("Sluiten"),
QDialogButtonBox.RejectRole)
for btn in self.ui.buttonBox.buttons():
btn.setAutoDefault(0)
#event handlers
if self.adresSearchOnEnter:
self.ui.zoekText.returnPressed.connect(self.onZoekActivated)
else:
self.ui.zoekText.textEdited.connect(self.onZoekActivated)
self.ui.gemeenteBox.currentIndexChanged.connect(self.onZoekActivated)
self.ui.resultLijst.itemDoubleClicked.connect(self.onItemActivated)
self.ui.resultLijst.itemClicked.connect(self.onItemClick)
self.ui.ZoomKnop.clicked.connect(self.onZoomKnopClick)
self.ui.Add2mapKnop.clicked.connect(self.onAdd2mapKnopClick)
self.ui.buttonBox.helpRequested.connect(self.openHelp)
self.finished.connect(self.clean)
def set_completer_feature_id(self, widget, geom_type, viewname):
""" Set autocomplete of widget 'feature_id'. Getting id's from selected @viewname """
# Adding auto-completion to a QLineEdit
self.completer = QCompleter()
self.completer.setCaseSensitivity(Qt.CaseInsensitive)
widget.setCompleter(self.completer)
model = QStringListModel()
sql = (f"SELECT {geom_type}_id" f" FROM {viewname}")
row = self.controller.get_rows(sql, commit=self.autocommit)
if row:
for i in range(0, len(row)):
aux = row[i]
row[i] = str(aux[0])
model.setStringList(row)
self.completer.setModel(model)
def populate_comboline(self, dialog, widget, completer):
_filter = utils_giswater.getWidgetText(dialog, widget)
sql = (f"SELECT node_id FROM v_edit_node "
f" WHERE node_id ILIKE '%{_filter}%'")
rows = self.controller.get_rows(sql, log_sql=True)
list_items = [row[0] for row in rows]
model = QStringListModel()
self.set_completer_object(completer, model, widget, list_items)
def set_typeahead_completer(self, widget, completer=None):
""" Set completer and add listeners """
if completer:
model = QStringListModel()
completer.highlighted.connect(partial(self.check_tab, completer))
self.make_list(completer, model, widget)
widget.textChanged.connect(partial(self.make_list, completer, model, widget))
return widget
def testSetModel(self):
view = QgsLayerTreeView()
# should not work
string_list_model = QStringListModel()
view.setModel(string_list_model)
self.assertFalse(view.model())
# should work
view.setModel(self.model)
self.assertEqual(view.model(), self.model)
def set_completer_rows(widget, rows):
""" Set a completer into a widget
:param widget: Object where to set the completer (QLineEdit)
:param rows: rows to set into the completer (List)["item1","item2","..."]
"""
if rows is None:
return
list_values = []
for row in rows:
list_values.append(str(row[0]))
# Set completer and model: add autocomplete in the widget
completer = QCompleter()
completer.setCaseSensitivity(Qt.CaseInsensitive)
widget.setCompleter(completer)
model = QStringListModel()
model.setStringList(list_values)
completer.setModel(model)
def _set_completer_result(self, widget, viewname, field_name):
""" Set autocomplete of widget 'feature_id'
getting id's from selected @viewname
"""
# Adding auto-completion to a QLineEdit
self.completer = QCompleter()
self.completer.setCaseSensitivity(Qt.CaseInsensitive)
widget.setCompleter(self.completer)
model = QStringListModel()
sql = f"SELECT {field_name} FROM {viewname}"
rows = tools_db.get_rows(sql)
if rows:
for i in range(0, len(rows)):
aux = rows[i]
rows[i] = str(aux[0])
model.setStringList(rows)
self.completer.setModel(model)
def setupCompleter(self):
# set up string list for completer
TOMsMessageLog.logMessage("In setupCompleter:", level=Qgis.Info)
lookupStringSet = set()
# https://gis.stackexchange.com/questions/155805/qstringlist-error-in-plugin-of-qgis-2-10
self.GazetteerLayer = QgsProject.instance().mapLayersByName("StreetGazetteerRecords")[0]
for row in self.GazetteerLayer.getFeatures():
streetName = row.attribute("Descriptor_")
locality = row.attribute("Locality")
nameString = streetName
if locality:
nameString = nameString + ", " + locality
if nameString:
TOMsMessageLog.logMessage("In setupCompleter: nameString: " + nameString, level=Qgis.Info)
lookupStringSet.add(nameString)
# self.gazetteerStringList.append((nameString))
completer = QCompleter()
completer.setCaseSensitivity(Qt.CaseInsensitive)
completer.setFilterMode(Qt.MatchContains)
self.searchTextbox.setCompleter(completer)
model = QStringListModel()
completer.setModel(model)
model.setStringList(self.gazetteerStringList)
model.setStringList(sorted(lookupStringSet))
def set_completer_feature_id(widget, geom_type, viewname):
""" Set autocomplete of widget 'feature_id'
getting id's from selected @viewname
"""
if geom_type == '':
return
# Adding auto-completion to a QLineEdit
completer = QCompleter()
completer.setCaseSensitivity(Qt.CaseInsensitive)
widget.setCompleter(completer)
model = QStringListModel()
sql = (f"SELECT {geom_type}_id" f" FROM {viewname}")
row = global_vars.controller.get_rows(sql)
if row:
for i in range(0, len(row)):
aux = row[i]
row[i] = str(aux[0])
model.setStringList(row)
completer.setModel(model)
def testSetModel(self):
view = QgsLayerTreeView()
# should not work
string_list_model = QStringListModel()
view.setModel(string_list_model)
self.assertFalse(view.model())
# should work
view.setModel(self.model)
if USE_MODEL_TESTER:
proxy_tester = QAbstractItemModelTester(view.model())
self.assertEqual(view.layerTreeModel(), self.model)
def setData(self, index, role, data):
if role == Qt.CheckStateRole:
self._checked_models[self.data(index, Qt.DisplayRole)] = data
else:
QStringListModel.setData(self, index, role, data)
def data(self, index, role):
if role == Qt.CheckStateRole:
return self._checked_models[self.data(index, Qt.DisplayRole)]
else:
return QStringListModel.data(self, index, role)
class geopunt4QgisAdresDialog(QDialog):
def __init__(self, iface):
QDialog.__init__(self, None)
self.setWindowFlags(self.windowFlags()
& ~Qt.WindowContextHelpButtonHint)
self.iface = iface
# initialize locale
locale = QSettings().value("locale/userLocale", "nl")
if not locale: locale == 'nl'
else: locale = locale[0:2]
localePath = os.path.join(os.path.dirname(__file__), 'i18n',
'geopunt4qgis_{}.qm'.format(locale))
if os.path.exists(localePath):
self.translator = QTranslator()
self.translator.load(localePath)
QCoreApplication.installTranslator(self.translator)
self._initGui()
def _initGui(self):
"""setup the user interface"""
self.ui = Ui_geopunt4Qgis()
self.ui.setupUi(self)
#get settings
self.s = QSettings()
self.loadSettings()
#setup geometryHelper object
self.gh = geometryHelper(self.iface)
#create graphicsLayer
self.graphicsLayer = []
self.firstShow = True
self.completer = QCompleter(self)
self.completerModel = QStringListModel(self)
self.ui.gemeenteBox.setCompleter(self.completer)
self.completer.setModel(self.completerModel)
self.completer.setCaseSensitivity(False)
#setup a message bar
self.bar = QgsMessageBar()
self.bar.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed)
self.ui.verticalLayout.addWidget(self.bar)
self.ui.buttonBox.addButton(QPushButton("Sluiten"),
QDialogButtonBox.RejectRole)
for btn in self.ui.buttonBox.buttons():
btn.setAutoDefault(0)
#event handlers
if self.adresSearchOnEnter:
self.ui.zoekText.returnPressed.connect(self.onZoekActivated)
else:
self.ui.zoekText.textEdited.connect(self.onZoekActivated)
self.ui.gemeenteBox.currentIndexChanged.connect(self.onZoekActivated)
self.ui.resultLijst.itemDoubleClicked.connect(self.onItemActivated)
self.ui.resultLijst.itemClicked.connect(self.onItemClick)
self.ui.ZoomKnop.clicked.connect(self.onZoomKnopClick)
self.ui.Add2mapKnop.clicked.connect(self.onAdd2mapKnopClick)
self.ui.buttonBox.helpRequested.connect(self.openHelp)
self.finished.connect(self.clean)
def loadSettings(self):
self.saveToFile = int(self.s.value("geopunt4qgis/adresSavetoFile", 1))
layerName = self.s.value("geopunt4qgis/adreslayerText", "")
if layerName:
self.layerName = layerName
self.adresSearchOnEnter = int(
self.s.value("geopunt4qgis/adresSearchOnEnter", 0))
self.timeout = int(self.s.value("geopunt4qgis/timeout", 15))
if settings().proxyUrl:
self.proxy = settings().proxyUrl
else:
self.proxy = ""
self.startDir = self.s.value("geopunt4qgis/startDir",
os.path.expanduser("~"))
self.gp = Adres(self.timeout, self.proxy)
# overwrite
def show(self):
QDialog.show(self)
self.setWindowModality(0)
arUrl = "http://loc.api.geopunt.be/"
inet = internet_on(proxyUrl=self.proxy,
timeout=self.timeout,
testSite=arUrl)
if not inet:
msg = "Kan geen verbing maken met de site van Geopunt: {} \nMogelijke is deze site niet bereikbaar, dan zal deze tool ook niet werken.\nProbeer later opnieuw. Indien dit probleem zich blijft voordoen contacteer informatie Vlaanderen.".format(
arUrl)
QMessageBox.warning(self.iface.mainWindow(),
"Waarschuwing: kan geen verbinding maken", msg)
self.bar.pushMessage(QCoreApplication.translate(
"geopunt4QgisPoidialog", "Waarschuwing"),
msg,
level=Qgis.Warning,
duration=3)
return
if self.firstShow:
self.am = basisregisters.adresMatch(self.timeout, self.proxy)
gemeenteNamen = [n["Naam"] for n in self.am.gemeenten()]
self.ui.gemeenteBox.addItems(gemeenteNamen)
self.completerModel.setStringList(gemeenteNamen)
self.ui.gemeenteBox.setEditText(
QCoreApplication.translate("geopunt4QgisAdresDialog",
"gemeente"))
self.ui.gemeenteBox.setStyleSheet('QComboBox {color: #808080}')
self.ui.gemeenteBox.setFocus()
self.firstShow = False
def openHelp(self):
webbrowser.open_new_tab(
"http://www.geopunt.be/voor-experts/geopunt-plug-ins/functionaliteiten/zoek-een-adres"
)
def onZoekActivated(self):
self._clearGraphicsLayer()
self.bar.clearWidgets()
gemeente = self.ui.gemeenteBox.currentText()
if gemeente != QCoreApplication.translate("geopunt4QgisAdresDialog",
"gemeente"):
self.ui.gemeenteBox.setStyleSheet('QComboBox {color: #000000}')
txt = self.ui.zoekText.text() + ", " + gemeente
suggesties = self.gp.fetchSuggestion(txt, 25)
self.ui.resultLijst.clear()
if type(suggesties) is list and len(suggesties) != 0:
self.ui.resultLijst.addItems(suggesties)
if len(suggesties) == 1:
self.ui.resultLijst.setCurrentRow(0)
def onItemActivated(self, item):
txt = item.text()
self._zoomLoc(txt)
def onItemClick(self, item):
txt = item.text()
streetNr = txt.split(",")[:-1]
self.ui.zoekText.setText(",".join(streetNr))
def onZoomKnopClick(self):
item = self.ui.resultLijst.currentItem()
if item:
self._zoomLoc(item.text())
def onAdd2mapKnopClick(self):
item = self.ui.resultLijst.currentItem()
if item:
self._addToMap(item.text())
def _clearGraphicsLayer(self):
for graphic in self.graphicsLayer:
self.iface.mapCanvas().scene().removeItem(graphic)
self.graphicsLayer = []
def _zoomLoc(self, txt):
self._clearGraphicsLayer()
locations = self.gp.fetchLocation(txt)
if type(locations) is list and len(locations):
loc = locations[0]
LowerLeftX = loc['BoundingBox']['LowerLeft']['X_Lambert72']
LowerLeftY = loc['BoundingBox']['LowerLeft']['Y_Lambert72']
UpperRightX = loc['BoundingBox']['UpperRight']['X_Lambert72']
UpperRightY = loc['BoundingBox']['UpperRight']['Y_Lambert72']
self.gh.zoomtoRec(QgsPointXY(LowerLeftX, LowerLeftY),
QgsPointXY(UpperRightX, UpperRightY), 31370)
xlb, ylb = loc["Location"]["X_Lambert72"], loc["Location"][
"Y_Lambert72"]
x, y = self.gh.prjPtToMapCrs(QgsPointXY(xlb, ylb), 31370)
m = QgsVertexMarker(self.iface.mapCanvas())
self.graphicsLayer.append(m)
m.setCenter(QgsPointXY(x, y))
m.setColor(QColor(255, 255, 0))
m.setIconSize(1)
m.setIconType(QgsVertexMarker.ICON_BOX)
m.setPenWidth(9)
elif type(locations) is str:
self.bar.pushMessage(QCoreApplication.translate(
"geopunt4QgisAdresDialog", "Waarschuwing"),
locations,
level=Qgis.Warning,
duration=3)
else:
self.bar.pushMessage("Error",
QCoreApplication.translate(
"geopunt4QgisAdresDialog",
"onbekende fout"),
level=Qgis.Critical,
duration=3)
def _addToMap(self, txt):
if not self.layernameValid(): return
locations = self.gp.fetchLocation(txt)
if type(locations) is list and len(locations):
loc = locations[0]
x, y = loc["Location"]["X_Lambert72"], loc["Location"][
"Y_Lambert72"]
adres = loc["FormattedAddress"]
LocationType = loc["LocationType"]
pt = self.gh.prjPtToMapCrs(QgsPointXY(x, y), 31370)
self.gh.save_adres_point(pt,
adres,
typeAddress=LocationType,
layername=self.layerName,
saveToFile=self.saveToFile,
sender=self,
startFolder=os.path.join(
self.startDir, self.layerName))
def layernameValid(self):
if not hasattr(self, 'layerName'):
layerName, accept = QInputDialog.getText(
None,
QCoreApplication.translate("geopunt4Qgis", 'Laag toevoegen'),
QCoreApplication.translate("geopunt4Qgis",
'Geef een naam voor de laag op:'))
if accept == False:
return False
else:
self.layerName = layerName
return True
def clean(self):
self.bar.clearWidgets()
self.ui.resultLijst.clear()
self.ui.zoekText.setText("")
self.ui.gemeenteBox.setEditText(
QCoreApplication.translate("geopunt4QgisAdresDialog", "gemeente"))
self.ui.gemeenteBox.setStyleSheet('QComboBox {color: #808080}')
self._clearGraphicsLayer()
def clicked_event(self):
# Create the dialog and signals
self.dlg_feature_delete = GwFeatureDeleteUi()
tools_gw.load_settings(self.dlg_feature_delete)
# Populate combo feature type
sql = 'SELECT DISTINCT(feature_type) AS id, feature_type AS idval FROM cat_feature'
rows = tools_db.get_rows(sql)
tools_qt.fill_combo_values(self.dlg_feature_delete.feature_type, rows,
1)
# Set active layer
layer_name = 'v_edit_' + tools_qt.get_text(
self.dlg_feature_delete,
self.dlg_feature_delete.feature_type).lower()
layer = tools_qgis.get_layer_by_tablename(layer_name)
self.iface.setActiveLayer(layer)
tools_qgis.set_layer_visible(layer)
# Disable button delete feature
self.dlg_feature_delete.btn_delete.setEnabled(False)
# Hide button delete another feature
self.dlg_feature_delete.btn_delete_another.setVisible(False)
# Disable tab log
tools_gw.disable_tab_log(self.dlg_feature_delete)
# Configure feature_id as typeahead
completer = QCompleter()
model = QStringListModel()
self._filter_typeahead(self.dlg_feature_delete.feature_id, completer,
model)
# Set listeners
self.dlg_feature_delete.feature_id.textChanged.connect(
partial(self._filter_typeahead, self.dlg_feature_delete.feature_id,
completer, model))
# Set button snapping
self.dlg_feature_delete.btn_snapping.clicked.connect(
partial(self._set_active_layer))
self.dlg_feature_delete.btn_snapping.clicked.connect(
partial(self._selection_init))
tools_gw.add_icon(self.dlg_feature_delete.btn_snapping, "137")
# Set listeners
self.dlg_feature_delete.btn_cancel.clicked.connect(
partial(tools_gw.close_dialog, self.dlg_feature_delete))
self.dlg_feature_delete.rejected.connect(
partial(tools_gw.disconnect_signal, 'feature_delete'))
self.dlg_feature_delete.rejected.connect(
partial(tools_gw.save_settings, self.dlg_feature_delete))
self.dlg_feature_delete.btn_delete_another.clicked.connect(
partial(self._delete_another_feature))
self.dlg_feature_delete.btn_relations.clicked.connect(
partial(self._show_feature_relation))
self.dlg_feature_delete.btn_delete.clicked.connect(
partial(self._delete_feature_relation))
self.dlg_feature_delete.feature_type.currentIndexChanged.connect(
partial(self._set_active_layer))
# Open dialog
tools_gw.open_dialog(self.dlg_feature_delete,
dlg_name='feature_delete')
def mg_mincut_management(self):
""" Button 27: Mincut management """
self.action = "mg_mincut_management"
# Create the dialog and signals
self.dlg_min_edit = MincutManagerUi()
self.load_settings(self.dlg_min_edit)
self.set_dates_from_to(self.dlg_min_edit.date_from,
self.dlg_min_edit.date_to, 'om_mincut',
'forecast_start, exec_start',
'forecast_end, exec_end')
self.dlg_min_edit.date_from.setEnabled(False)
self.dlg_min_edit.date_to.setEnabled(False)
self.set_icon(self.dlg_min_edit.btn_selector_mincut, "191")
self.tbl_mincut_edit = self.dlg_min_edit.findChild(
QTableView, "tbl_mincut_edit")
self.txt_mincut_id = self.dlg_min_edit.findChild(
QLineEdit, "txt_mincut_id")
self.tbl_mincut_edit.setSelectionBehavior(QAbstractItemView.SelectRows)
# Adding auto-completion to a QLineEdit
self.completer = QCompleter()
self.txt_mincut_id.setCompleter(self.completer)
model = QStringListModel()
sql = "SELECT DISTINCT(id) FROM om_mincut WHERE id > 0 "
rows = self.controller.get_rows(sql)
values = []
if rows:
for row in rows:
values.append(str(row[0]))
model.setStringList(values)
self.completer.setModel(model)
self.txt_mincut_id.textChanged.connect(
partial(self.filter_by_id, self.tbl_mincut_edit))
self.dlg_min_edit.date_from.dateChanged.connect(
partial(self.filter_by_id, self.tbl_mincut_edit))
self.dlg_min_edit.date_to.dateChanged.connect(
partial(self.filter_by_id, self.tbl_mincut_edit))
self.dlg_min_edit.cmb_expl.currentIndexChanged.connect(
partial(self.filter_by_id, self.tbl_mincut_edit))
self.dlg_min_edit.spn_next_days.setRange(-9999, 9999)
self.dlg_min_edit.btn_next_days.clicked.connect(self.filter_by_days)
self.dlg_min_edit.spn_next_days.valueChanged.connect(
self.filter_by_days)
self.dlg_min_edit.btn_cancel_mincut.clicked.connect(
self.set_state_cancel_mincut)
self.dlg_min_edit.tbl_mincut_edit.doubleClicked.connect(
self.open_mincut)
self.dlg_min_edit.btn_cancel.clicked.connect(
partial(self.close_dialog, self.dlg_min_edit))
self.dlg_min_edit.rejected.connect(
partial(self.close_dialog, self.dlg_min_edit))
self.dlg_min_edit.btn_delete.clicked.connect(
partial(self.delete_mincut_management, self.tbl_mincut_edit,
"om_mincut", "id"))
self.dlg_min_edit.btn_selector_mincut.clicked.connect(
partial(self.mincut_selector, self.tbl_mincut_edit, 'id'))
self.btn_notify = self.dlg_min_edit.findChild(QPushButton,
"btn_notify")
self.btn_notify.clicked.connect(
partial(self.get_clients_codes, self.dlg_min_edit.tbl_mincut_edit))
self.set_icon(self.btn_notify, "307")
try:
row = self.controller.get_config('om_mincut_enable_alerts',
'value', 'config_param_system')
if row:
self.custom_action_sms = json.loads(
row[0], object_pairs_hook=OrderedDict)
self.btn_notify.setVisible(
self.custom_action_sms['show_mincut_sms'])
except KeyError:
self.btn_notify.setVisible(False)
self.populate_combos()
self.dlg_min_edit.state_edit.activated.connect(
partial(self.filter_by_id, self.tbl_mincut_edit))
# Set a model with selected filter. Attach that model to selected table
self.fill_table_mincut_management(self.tbl_mincut_edit,
self.schema_name + ".v_ui_mincut")
self.set_table_columns(self.dlg_min_edit, self.tbl_mincut_edit,
"v_ui_mincut")
#self.mincut.set_table_columns(self.tbl_mincut_edit, "v_ui_mincut")
# Open the dialog
self.open_dialog(self.dlg_min_edit, dlg_name='mincut_manager')
def construct_form_param_user(self, row, pos):
widget = None
for field in row[pos]['fields']:
if field['label']:
lbl = QLabel()
lbl.setObjectName('lbl' + field['widgetname'])
lbl.setText(field['label'])
lbl.setMinimumSize(160, 0)
lbl.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Preferred)
lbl.setToolTip(field['tooltip'])
chk = QCheckBox()
chk.setObjectName('chk_' + field['widgetname'])
if field['checked'] in ('true', 'True', 'TRUE', True):
chk.setChecked(True)
elif field['checked'] in ('false', 'False', 'FALSE', False):
chk.setChecked(False)
chk.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
if field['widgettype'] == 'text' or field[
'widgettype'] == 'linetext' or field[
'widgettype'] == 'typeahead':
widget = QLineEdit()
widget.setText(field['value'])
widget.editingFinished.connect(
partial(self.get_values_changed_param_user, chk,
widget, field))
widget.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Fixed)
if field['widgettype'] == 'typeahead':
completer = QCompleter()
if 'dv_querytext' in field or 'dv_querytext_filterc' in field:
widget.setProperty('typeahead', True)
model = QStringListModel()
widget.textChanged.connect(
partial(self.populate_typeahead, completer,
model, field, self.dlg_config, widget))
elif field['widgettype'] == 'textarea':
widget = QTextEdit()
widget.setText(field['value'])
widget.editingFinished.connect(
partial(self.get_values_changed_param_user, chk,
widget, field))
widget.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Fixed)
elif field['widgettype'] == 'combo':
widget = QComboBox()
self.populate_combo(widget, field)
widget.currentIndexChanged.connect(
partial(self.get_values_changed_param_user, chk,
widget, field))
widget.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Fixed)
elif field['widgettype'] == 'check':
widget = chk
widget.stateChanged.connect(
partial(self.get_values_changed_param_user, chk, chk,
field))
widget.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
elif field['widgettype'] == 'datetime':
widget = QgsDateTimeEdit()
widget.setAllowNull(True)
widget.setCalendarPopup(True)
widget.setDisplayFormat('dd/MM/yyyy')
if field['value']:
field['value'] = field['value'].replace('/', '-')
date = QDate.fromString(field['value'], 'yyyy-MM-dd')
if date:
widget.setDate(date)
else:
widget.clear()
widget.dateChanged.connect(
partial(self.get_values_changed_param_user, chk,
widget, field))
widget.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Fixed)
elif field['widgettype'] == 'spinbox':
widget = QDoubleSpinBox()
if 'value' in field and field['value'] is not None:
value = float(str(field['value']))
widget.setValue(value)
widget.valueChanged.connect(
partial(self.get_values_changed_param_user, chk,
widget, field))
widget.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Fixed)
else:
pass
widget.setObjectName(field['widgetname'])
# Set signals
chk.stateChanged.connect(
partial(self.get_values_checked_param_user, chk, widget,
field))
if field['layoutname'] == 'lyt_basic':
self.order_widgets(field, self.basic_form, lbl, chk,
widget)
elif field['layoutname'] == 'lyt_om':
self.order_widgets(field, self.om_form, lbl, chk, widget)
elif field['layoutname'] == 'lyt_inventory':
self.order_widgets(field, self.inventory_form, lbl, chk,
widget)
elif field['layoutname'] == 'lyt_mapzones':
self.order_widgets(field, self.mapzones_form, lbl, chk,
widget)
elif field['layoutname'] == 'lyt_edit':
self.order_widgets(field, self.cad_form, lbl, chk, widget)
elif field['layoutname'] == 'lyt_epa':
self.order_widgets(field, self.epa_form, lbl, chk, widget)
elif field['layoutname'] == 'lyt_masterplan':
self.order_widgets(field, self.masterplan_form, lbl, chk,
widget)
elif field['layoutname'] == 'lyt_other':
self.order_widgets(field, self.other_form, lbl, chk,
widget)
elif field['layoutname'] == 'lyt_node_vdef':
self.order_widgets(field, self.node_type_form, lbl, chk,
widget)
elif field['layoutname'] == 'lyt_arc_vdef':
self.order_widgets(field, self.cat_form, lbl, chk, widget)
elif field['layoutname'] == 'lyt_utils_vdef':
self.order_widgets(field, self.utils_form, lbl, chk,
widget)
elif field['layoutname'] == 'lyt_connec_vdef':
self.order_widgets(field, self.connec_form, lbl, chk,
widget)
elif field['layoutname'] == 'lyt_gully_vdef':
self.order_widgets(field, self.gully_form, lbl, chk,
widget)
elif field['layoutname'] == 'lyt_fluid_type':
self.order_widgets(field, self.fluid_type_form, lbl, chk,
widget)
elif field['layoutname'] == 'lyt_location_type':
self.order_widgets(field, self.location_type_form, lbl,
chk, widget)
elif field['layoutname'] == 'lyt_category_type':
self.order_widgets(field, self.category_type_form, lbl,
chk, widget)
elif field['layoutname'] == 'lyt_function_type':
self.order_widgets(field, self.function_type_form, lbl,
chk, widget)
elif field['layoutname'] == 'lyt_addfields':
self.order_widgets(field, self.addfields_form, lbl, chk,
widget)
