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, iface):
# TODO: We are going to let the user set this up in a future iteration
self.iface = iface
self.proj = QgsProject.instance()
self.toolbar = self.iface.addToolBar(u'MapTiler')
self.toolbar.setObjectName(u'MapTiler')
# init QCompleter
self.completer = QCompleter([])
self.completer.setCaseSensitivity(Qt.CaseInsensitive)
self.completer.setMaxVisibleItems(30)
self.completer.setModelSorting(QCompleter.UnsortedModel)
self.completer.setCompletionMode(QCompleter.UnfilteredPopupCompletion)
self.completer.activated[QModelIndex].connect(self.on_result_clicked)
# init LineEdit of searchword
self.search_line_edit = QLineEdit()
self.search_line_edit.setPlaceholderText('MapTiler Geocoding API')
self.search_line_edit.setMaximumWidth(300)
self.search_line_edit.setClearButtonEnabled(True)
self.search_line_edit.setCompleter(self.completer)
self.search_line_edit.textEdited.connect(self.on_searchword_edited)
self.search_line_edit.returnPressed.connect(
self.on_searchword_returned)
self.toolbar.addWidget(self.search_line_edit)
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 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 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 __init__(self, autocomplete, parent=None):
QCompleter.__init__(
self,
list(autocomplete["clsdict"].keys()) +
list(autocomplete["propdict"].keys()), parent)
self.setCompletionMode(QCompleter.PopupCompletion)
self.setFilterMode(Qt.MatchContains)
self.highlighted.connect(self.setHighlighted)
def prepararCompleterNumero(self):
self.dictNumerosFiltre = self.dictNumeros[self.codiCarrer]
self.completerNumero = QCompleter(
self.dictNumerosFiltre, self.leNumero)
self.completerNumero.activated.connect(self.activatNumero)
self.completerNumero.setFilterMode(QtCore.Qt.MatchStartsWith)
self.completerNumero.setCaseSensitivity(QtCore.Qt.CaseInsensitive)
self.leNumero.setCompleter(self.completerNumero)
def completer_box(self):
"""Box automatic completion"""
reasons = self.db.execute_return(bulk_load_select.deletion_description_value)
reason_list = [row[0] for row in reasons.fetchall()]
# Fill the search box
self.completer = QCompleter(reason_list)
self.completer.setCompletionMode(QCompleter.UnfilteredPopupCompletion)
self.completer.setCaseSensitivity(Qt.CaseInsensitive)
self.le_deletion_reason.setCompleter(self.completer)
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 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 __init__(self, parent=None):
super(ExtendedComboBox, self).__init__(parent)
self.setFocusPolicy(Qt.StrongFocus)
self.setEditable(True)
self.pFilterModel = QSortFilterProxyModel(self)
self.pFilterModel.setFilterCaseSensitivity(Qt.CaseInsensitive)
self.pFilterModel.setSourceModel(self.model())
self.completer = QCompleter(self.pFilterModel, self)
self.completer.setCompletionMode(QCompleter.UnfilteredPopupCompletion)
self.completer.popup().setStyleSheet('min-height: 150px')
self.completer.popup().setAlternatingRowColors(True)
self.setCompleter(self.completer)
self.lineEdit().textEdited[str].connect(self.pFilterModel.setFilterFixedString)
def update_models_completer(self):
completer = QCompleter(self.ilicache.model, self.ili_models_line_edit)
completer.setCaseSensitivity(Qt.CaseInsensitive)
completer.setFilterMode(Qt.MatchContains)
self.delegate = ModelCompleterDelegate()
completer.popup().setItemDelegate(self.delegate)
self.ili_models_line_edit.setCompleter(completer)
self.multiple_models_dialog.models_line_edit.setCompleter(completer)
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 key_edited(self, row: int = None):
"""Add values to the combobox according to the key."""
if row is None:
selection = self.table.selectedIndexes()
if selection:
row = selection[0].row()
else:
row = 0
key_field = self.table.cellWidget(row, 1)
value_field = self.table.cellWidget(row, 2)
value_field.clear()
value_field.setCompleter(None)
try:
current_values = self.couple[key_field.currentText()]
except KeyError:
self.update_friendly()
return
except AttributeError:
self.update_friendly()
return
if len(current_values) == 0:
current_values.insert(0, '')
if len(current_values) > 1 and current_values[0] != '':
current_values.insert(0, '')
current_values.sort()
values_completer = QCompleter(current_values)
value_field.setCompleter(values_completer)
value_field.addItems(current_values)
self.update_friendly()
def key_edited(self):
"""
Disable show and run buttons if the key is empty
and add values to the combobox
"""
if self.comboBox_key.currentText():
self.pushButton_runQuery.setDisabled(False)
self.pushButton_showQuery.setDisabled(False)
# else:
# self.pushButton_runQuery.setDisabled(True)
# self.pushButton_showQuery.setDisabled(True)
self.comboBox_value.clear()
self.comboBox_value.setCompleter(None)
try:
current_values = self.osmKeys[str(self.comboBox_key.currentText())]
except KeyError:
return
except AttributeError:
return
if current_values[0] != "":
current_values.insert(0, "")
values_completer = QCompleter(current_values)
self.comboBox_value.setCompleter(values_completer)
self.comboBox_value.addItems(current_values)
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 open_form(self):
self.previous_map_tool = self.canvas.mapTool()
# Get layers of every geom_type
self.reset_lists()
self.reset_layers()
self.geom_type = 'node'
layer = self.controller.get_layer_by_tablename('v_edit_node')
if not layer:
self.last_error = self.tr("Layer not found") + ": v_edit_node"
return None
self.layers['node'] = [layer]
self.visible_layers = self.get_visible_layers()
self.remove_selection()
self.dlg_unit = PlaningUnit()
self.load_settings(self.dlg_unit)
self.set_icon(self.dlg_unit.btn_insert, "111")
self.set_icon(self.dlg_unit.btn_delete, "112")
self.set_icon(self.dlg_unit.btn_snapping, "137")
validator = QIntValidator(1, 9999999)
self.dlg_unit.txt_times.setValidator(validator)
utils_giswater.set_qtv_config(self.dlg_unit.tbl_unit, edit_triggers=QTableView.DoubleClicked)
sql = "SELECT id, name FROM cat_campaign"
rows = self.controller.get_rows(sql, log_sql=True)
utils_giswater.set_item_data(self.dlg_unit.cmb_campaign, rows, 1)
sql = "SELECT id, name FROM cat_work"
rows = self.controller.get_rows(sql, add_empty_row=True)
utils_giswater.set_item_data(self.dlg_unit.cmb_work, rows, 1)
self.load_default_values()
table_name = "v_ui_planning_unit"
self.update_table(self.dlg_unit, self.dlg_unit.tbl_unit, table_name, self.dlg_unit.cmb_campaign, self.dlg_unit.cmb_work)
# Signals
self.dlg_unit.cmb_campaign.currentIndexChanged.connect(
partial(self.update_table, self.dlg_unit, self.dlg_unit.tbl_unit, table_name, self.dlg_unit.cmb_campaign, self.dlg_unit.cmb_work))
self.dlg_unit.cmb_work.currentIndexChanged.connect(
partial(self.update_table, self.dlg_unit, self.dlg_unit.tbl_unit, table_name, self.dlg_unit.cmb_campaign, self.dlg_unit.cmb_work))
completer = QCompleter()
self.dlg_unit.txt_id.textChanged.connect(
partial(self.populate_comboline, self.dlg_unit,self.dlg_unit.txt_id, completer))
self.dlg_unit.btn_close.clicked.connect(partial(self.save_default_values))
self.dlg_unit.btn_close.clicked.connect(partial(self.close_dialog, self.dlg_unit))
self.dlg_unit.btn_close.clicked.connect(partial(self.remove_selection))
self.dlg_unit.rejected.connect(partial(self.save_default_values))
self.dlg_unit.rejected.connect(partial(self.close_dialog, self.dlg_unit))
self.dlg_unit.rejected.connect(partial(self.remove_selection))
self.dlg_unit.btn_snapping.clicked.connect(partial(self.selection_init, self.dlg_unit.tbl_unit))
self.dlg_unit.btn_insert.clicked.connect(partial(self.insert_single, self.dlg_unit, self.dlg_unit.txt_id))
self.dlg_unit.btn_delete.clicked.connect(partial(self.delete_row, self.dlg_unit.tbl_unit, table_name))
self.open_dialog(self.dlg_unit)
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 _update_completer(self, values):
# Get the items in a tuple and put them in a list
# Store display and actual values in a
# model for easier mapping and
# retrieval when carrying out searches
model_attr_mapping = []
# Check if there are formaters specified
# for the current field name
for mv in values:
f_model_values = []
m_val = mv[0]
if m_val is not None:
col_label = self.currentFieldName()
if col_label in self.config.LookupFormatters:
formatter = self.config.LookupFormatters[col_label]
if formatter.column.TYPE_INFO == 'LOOKUP':
m_val = formatter.code_value(m_val)[0]
else:
m_val = formatter.format_column_value(m_val)
f_model_values.extend([m_val, m_val])
model_attr_mapping.append(f_model_values)
self._completer_model = BaseSTDMTableModel(model_attr_mapping,
["", ""], self)
# We will use the QSortFilterProxyModel for filtering purposes
self._proxy_completer_model = QSortFilterProxyModel()
self._proxy_completer_model.setDynamicSortFilter(True)
self._proxy_completer_model.setSourceModel(self._completer_model)
self._proxy_completer_model.setSortCaseSensitivity(Qt.CaseInsensitive)
self._proxy_completer_model.setFilterKeyColumn(0)
# Configure completer
mod_completer = QCompleter(self._completer_model, self)
mod_completer.setCaseSensitivity(Qt.CaseInsensitive)
mod_completer.setCompletionMode(QCompleter.PopupCompletion)
mod_completer.setCompletionColumn(0)
mod_completer.setCompletionRole(Qt.DisplayRole)
self.txtFilterPattern.setCompleter(mod_completer)
def _set_widgets(self, dialog, db_return, field):
widget = None
label = None
if field['label']:
label = QLabel()
label.setObjectName('lbl_' + field['widgetname'])
label.setText(field['label'].capitalize())
if 'stylesheet' in field and field[
'stylesheet'] is not None and 'label' in field[
'stylesheet']:
label = tools_gw.set_stylesheet(field, label)
if 'tooltip' in field:
label.setToolTip(field['tooltip'])
else:
label.setToolTip(field['label'].capitalize())
if field['widgettype'] == 'text' or field['widgettype'] == 'typeahead':
completer = QCompleter()
widget = tools_gw.add_lineedit(field)
widget = tools_gw.set_widget_size(widget, field)
widget = tools_gw.set_data_type(field, widget)
if field['widgettype'] == 'typeahead':
widget = tools_gw.set_typeahead(field, dialog, widget,
completer)
elif field['widgettype'] == 'combo':
widget = tools_gw.add_combo(field)
widget = tools_gw.set_widget_size(widget, field)
elif field['widgettype'] == 'check':
widget = tools_gw.add_checkbox(field)
elif field['widgettype'] == 'datetime':
widget = tools_gw.add_calendar(dialog, field)
elif field['widgettype'] == 'button':
widget = tools_gw.add_button(dialog, field)
widget = tools_gw.set_widget_size(widget, field)
elif field['widgettype'] == 'hyperlink':
widget = tools_gw.add_hyperlink(field)
widget = tools_gw.set_widget_size(widget, field)
elif field['widgettype'] == 'hspacer':
widget = tools_qt.add_horizontal_spacer()
elif field['widgettype'] == 'vspacer':
widget = tools_qt.add_verticalspacer()
elif field['widgettype'] == 'textarea':
widget = tools_gw.add_textarea(field)
elif field['widgettype'] in 'spinbox':
widget = tools_gw.add_spinbox(field)
elif field['widgettype'] == 'tableview':
widget = tools_gw.add_tableview(db_return, field)
widget = tools_gw.add_tableview_header(widget, field)
widget = tools_gw.fill_tableview_rows(widget, field)
widget = tools_gw.set_tablemodel_config(dialog,
widget,
field['widgetname'],
sort_order=1,
isQStandardItemModel=True)
tools_qt.set_tableview_config(widget)
widget.setObjectName(widget.property('columnname'))
return label, widget
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 set_widgets(self, dialog, db_return, field):
widget = None
label = None
if field['label']:
label = QLabel()
label.setObjectName('lbl_' + field['widgetname'])
label.setText(field['label'].capitalize())
if field['stylesheet'] is not None and 'label' in field[
'stylesheet']:
label = self.set_setStyleSheet(field, label)
if 'tooltip' in field:
label.setToolTip(field['tooltip'])
else:
label.setToolTip(field['label'].capitalize())
if field['widgettype'] == 'text' or field['widgettype'] == 'typeahead':
completer = QCompleter()
widget = self.add_lineedit(field)
widget = self.set_widget_size(widget, field)
widget = self.set_data_type(field, widget)
if field['widgettype'] == 'typeahead':
widget = self.manage_lineedit(field, dialog, widget, completer)
elif field['widgettype'] == 'combo':
widget = self.add_combobox(field)
widget = self.set_widget_size(widget, field)
elif field['widgettype'] == 'check':
widget = self.add_checkbox(field)
elif field['widgettype'] == 'datetime':
widget = self.add_calendar(dialog, field)
elif field['widgettype'] == 'button':
widget = self.add_button(dialog, field)
widget = self.set_widget_size(widget, field)
elif field['widgettype'] == 'hyperlink':
widget = self.add_hyperlink(field)
widget = self.set_widget_size(widget, field)
elif field['widgettype'] == 'hspacer':
widget = self.add_horizontal_spacer()
elif field['widgettype'] == 'vspacer':
widget = self.add_verical_spacer()
elif field['widgettype'] == 'textarea':
widget = self.add_textarea(field)
elif field['widgettype'] in ('spinbox'):
widget = self.add_spinbox(field)
elif field['widgettype'] == 'tableview':
widget = self.add_tableview(db_return, field)
widget = self.set_headers(widget, field)
widget = self.populate_table(widget, field)
widget = self.set_columns_config(widget,
field['widgetname'],
sort_order=1,
isQStandardItemModel=True)
utils_giswater.set_qtv_config(widget)
widget.setObjectName(widget.property('columnname'))
return label, widget
def __init__(self, parent=None):
"""
QuickQueryWidget constructor
"""
QuickOSMWidget.__init__(self, parent)
self.setupUi(self)
self.init()
# Setup UI
# Query type
self.cb_query_type.addItem(tr('In'), 'in')
self.cb_query_type.addItem(tr('Around'), 'around')
self.cb_query_type.addItem(tr('Canvas Extent'), 'canvas')
self.cb_query_type.addItem(tr('Layer Extent'), 'layer')
self.cb_query_type.addItem(tr('Not Spatial'), 'attributes')
self.cb_query_type.currentIndexChanged.connect(self.query_type_updated)
self.label_progress.setText("")
self.lineEdit_filePrefix.setDisabled(True)
# self.activate_extent_layer()
# connect
self.pushButton_runQuery.clicked.connect(self.run_query)
self.pushButton_showQuery.clicked.connect(self.show_query)
self.comboBox_key.editTextChanged.connect(self.key_edited)
self.pushButton_mapFeatures.clicked.connect(self.open_map_features)
self.buttonBox.button(QDialogButtonBox.Reset).clicked.connect(
self.reset_form)
# Setup auto completion
map_features_json_file = join(dirname(dirname(abspath(__file__))),
'mapFeatures.json')
if isfile(map_features_json_file):
with open(map_features_json_file) as f:
self.osmKeys = load(f)
keys = list(self.osmKeys.keys())
keys.append('') # All keys request #118
keys.sort()
keys_completer = QCompleter(keys)
self.comboBox_key.addItems(keys)
self.comboBox_key.setCompleter(keys_completer)
self.comboBox_key.completer().setCompletionMode(
QCompleter.PopupCompletion)
self.comboBox_key.lineEdit().setPlaceholderText(
'Query on all keys')
self.comboBox_value.lineEdit().setPlaceholderText(
'Query on all values')
self.key_edited()
self.query_type_updated()
self.init_nominatim_autofill()
def set_ui_quick_query_panel(self):
"""Setup the UI for the QuickQuery."""
# Query type
self.combo_query_type_qq.addItem(tr('In'), 'in')
self.combo_query_type_qq.addItem(tr('Around'), 'around')
self.combo_query_type_qq.addItem(tr('Canvas Extent'), 'canvas')
self.combo_query_type_qq.addItem(tr('Layer Extent'), 'layer')
self.combo_query_type_qq.addItem(tr('Not Spatial'), 'attributes')
# self.cb_query_type_qq.setItemIcon(
# 0, QIcon(resources_path('in.svg')))
# self.cb_query_type_qq.setItemIcon(
# 1, QIcon(resources_path('around.svg')))
# self.cb_query_type_qq.setItemIcon(
# 2, QIcon(resources_path('map_canvas.svg')))
# self.cb_query_type_qq.setItemIcon(
# 3, QIcon(resources_path('extent.svg')))
# self.cb_query_type_qq.setItemIcon(
# 4, QIcon(resources_path('mIconTableLayer.svg')))
self.combo_query_type_qq.currentIndexChanged.connect(
self.query_type_updated_qq)
self.line_file_prefix_qq.setDisabled(True)
self.button_run_query_qq.clicked.connect(self.run_quick_query)
# TODO self.button_show_query.clicked.connect(self.show_query)
self.combo_key.editTextChanged.connect(self.key_edited)
self.button_map_features.clicked.connect(open_map_features)
self.button_box_qq.button(QDialogButtonBox.Reset).clicked.connect(
self.reset_form)
# Setup auto completion
map_features_json_file = resources_path('json', 'map_features.json')
if isfile(map_features_json_file):
with open(map_features_json_file) as f:
self.osm_keys = load(f)
keys = list(self.osm_keys.keys())
keys.append('') # All keys request #118
keys.sort()
keys_completer = QCompleter(keys)
self.combo_key.addItems(keys)
self.combo_key.setCompleter(keys_completer)
self.combo_key.completer().setCompletionMode(
QCompleter.PopupCompletion)
self.combo_key.lineEdit().setPlaceholderText(
tr('Query on all keys'))
self.combo_value.lineEdit().setPlaceholderText(
tr('Query on all values'))
self.key_edited()
self.query_type_updated_qq()
self.init_nominatim_autofill()
def __init__(self, parent=None):
super(FilteredComboBox, self).__init__(parent)
self.setFocusPolicy(Qt.StrongFocus)
self.setSizeAdjustPolicy(QComboBox.AdjustToMinimumContentsLength)
self.setEditable(True)
self.filter_proxy_model = QSortFilterProxyModel(self)
self.filter_proxy_model.setFilterCaseSensitivity(Qt.CaseInsensitive)
self.filter_proxy_model.setSortCaseSensitivity(Qt.CaseInsensitive)
self.filter_proxy_model.setSourceModel(self.model())
self.completer = QCompleter(self.filter_proxy_model, self)
self.completer.setCompletionMode(QCompleter.UnfilteredPopupCompletion)
self.setCompleter(self.completer)
self.setMinimumSize(150, 25)
self.setFont(QFont("Segoe UI", 10))
self.setStyleSheet("QComboBox {background-color: white;}")
self.setMaxVisibleItems(10)
self.completer.activated.connect(self.on_completer_activated)
self.lineEdit().textEdited.connect(
self.filter_proxy_model.setFilterFixedString)
def __init__(self, parent, title):
QWizardPage.__init__(self, parent)
self.workflow_wizard = parent
self.setupUi(self)
self.setTitle(title)
self.workflow_wizard = parent
self.is_complete = True
self.model_list_view.setModel(self.workflow_wizard.import_models_model)
self.model_list_view.clicked.connect(
self.workflow_wizard.import_models_model.check)
self.model_list_view.space_pressed.connect(
self.workflow_wizard.import_models_model.check)
self.model_list_view.model().modelReset.connect(
self._update_models_dependent_info)
self.crs = QgsCoordinateReferenceSystem()
self.ili2db_options = Ili2dbOptionsDialog(self)
self.ili2db_options_button.clicked.connect(self.ili2db_options.open)
self.ili2db_options.finished.connect(self._fill_toml_file_info_label)
self.crsSelector.crsChanged.connect(self._crs_changed)
self.ilimetaconfigcache = IliDataCache(
self.workflow_wizard.import_schema_configuration.base_configuration
)
self.metaconfig_delegate = MetaConfigCompleterDelegate()
self.metaconfig = configparser.ConfigParser()
self.current_models = None
self.current_metaconfig_id = None
self.ili_metaconfig_line_edit.setPlaceholderText(
self.tr("[Search metaconfig / topping from UsabILIty Hub]"))
self.ili_metaconfig_line_edit.setEnabled(False)
completer = QCompleter(self.ilimetaconfigcache.model,
self.ili_metaconfig_line_edit)
completer.setCaseSensitivity(Qt.CaseInsensitive)
completer.setFilterMode(Qt.MatchContains)
completer.popup().setItemDelegate(self.metaconfig_delegate)
self.ili_metaconfig_line_edit.setCompleter(completer)
self.ili_metaconfig_line_edit.textChanged.emit(
self.ili_metaconfig_line_edit.text())
self.ili_metaconfig_line_edit.textChanged.connect(
self._complete_metaconfig_completer)
self.ili_metaconfig_line_edit.punched.connect(
self._complete_metaconfig_completer)
self.ili_metaconfig_line_edit.textChanged.connect(
self._on_metaconfig_completer_activated)
self.workflow_wizard.ilireferencedatacache.model_refreshed.connect(
self._update_linked_models)
def __init__(self, parent=None):
super(DsgCustomComboBox, self).__init__(parent=parent)
self.setFocusPolicy(Qt.StrongFocus)
self.setEditable(True)
# add a filter model to filter matching items
self.pFilterModel = QSortFilterProxyModel(self)
self.pFilterModel.setFilterCaseSensitivity(Qt.CaseInsensitive)
self.pFilterModel.setSourceModel(self.model())
# add a completer, which uses the filter model
self.completer = QCompleter(self.pFilterModel, self)
# always show all (filtered) completions
self.completer.setCompletionMode(QCompleter.UnfilteredPopupCompletion)
self.setCompleter(self.completer)
# connect signals
self.lineEdit().textEdited[str].connect(
self.pFilterModel.setFilterFixedString)
self.completer.activated.connect(self.on_completer_activated)
def api_search(self):
# Dialog
self.dlg_search = ApiSearchUi()
self.load_settings(self.dlg_search)
self.dlg_search.lbl_msg.setStyleSheet("QLabel{color:red;}")
self.dlg_search.lbl_msg.setVisible(False)
# Make it dockable in left dock widget area
self.iface.addDockWidget(Qt.LeftDockWidgetArea, self.dlg_search)
body = self.create_body()
function_name = "gw_api_getsearch"
row = self.controller.execute_api_function(function_name, body)
if not row:
return False
complet_list = [json.loads(row[0], object_pairs_hook=OrderedDict)]
main_tab = self.dlg_search.findChild(QTabWidget, 'main_tab')
first_tab = None
self.lineedit_list = []
for tab in complet_list[0]["form"]:
if first_tab is None:
first_tab = tab['tabName']
tab_widget = QWidget(main_tab)
tab_widget.setObjectName(tab['tabName'])
main_tab.addTab(tab_widget, tab['tabtext'])
gridlayout = QGridLayout()
tab_widget.setLayout(gridlayout)
x = 0
for field in tab['fields']:
label = QLabel()
label.setObjectName('lbl_' + field['label'])
label.setText(field['label'].capitalize())
if field['widgettype'] == 'typeahead':
completer = QCompleter()
widget = self.add_lineedit(field)
widget = self.set_completer(widget, completer)
self.lineedit_list.append(widget)
elif field['widgettype'] == 'combo':
widget = self.add_combobox(field)
gridlayout.addWidget(label, x, 0)
gridlayout.addWidget(widget, x, 1)
x += 1
vertical_spacer1 = QSpacerItem(20, 40, QSizePolicy.Minimum,
QSizePolicy.Expanding)
gridlayout.addItem(vertical_spacer1)
self.dlg_search.dlg_closed.connect(self.rubber_polygon.reset)
def __init__(self, parent=None):
super(ExtendedComboBox, self).__init__(parent)
self.setFocusPolicy(Qt.StrongFocus)
self.setEditable(True)
self.pFilterModel = QSortFilterProxyModel(self)
self.pFilterModel.setFilterCaseSensitivity(Qt.CaseInsensitive)
self.pFilterModel.setSourceModel(self.model())
self.completer = QCompleter(self.pFilterModel, self)
self.completer.setCompletionMode(QCompleter.UnfilteredPopupCompletion)
self.completer.popup().setStyleSheet('min-height: 150px')
self.completer.popup().setAlternatingRowColors(True)
self.setCompleter(self.completer)
self.lineEdit().textEdited[str].connect(self.pFilterModel.setFilterFixedString)
