class GroupSelectParameterWidget(GenericParameterWidget):
"""Widget class for Group Select Parameter."""
def __init__(self, parameter, parent=None):
"""Constructor.
:param parameter: A GroupSelectParameter object.
:type parameter: GroupSelectParameter
"""
QWidget.__init__(self, parent)
self._parameter = parameter
# Store spin box
self.spin_boxes = {}
# Create elements
# Label (name)
self.label = QLabel(self._parameter.name)
# Layouts
self.main_layout = QVBoxLayout()
self.input_layout = QVBoxLayout()
# _inner_input_layout must be filled with widget in the child class
self.inner_input_layout = QVBoxLayout()
self.radio_button_layout = QGridLayout()
# Create radio button group
self.input_button_group = QButtonGroup()
# List widget
self.list_widget = QListWidget()
self.list_widget.setSelectionMode(QAbstractItemView.ExtendedSelection)
self.list_widget.setDragDropMode(QAbstractItemView.DragDrop)
self.list_widget.setDefaultDropAction(Qt.MoveAction)
self.list_widget.setEnabled(False)
self.list_widget.setSizePolicy(QSizePolicy.Maximum,
QSizePolicy.Expanding)
for i, key in enumerate(self._parameter.options):
value = self._parameter.options[key]
radio_button = QRadioButton(value.get('label'))
self.radio_button_layout.addWidget(radio_button, i, 0)
if value.get('type') == SINGLE_DYNAMIC:
percentage_spin_box = PercentageSpinBox(self)
self.radio_button_layout.addWidget(percentage_spin_box, i, 1)
percentage_spin_box.setValue(value.get('value', 0))
step = percentage_spin_box.singleStep()
if step > 1:
precision = 0
else:
precision = len(str(step).split('.')[1])
if precision > 3:
precision = 3
percentage_spin_box.setDecimals(precision)
self.spin_boxes[key] = percentage_spin_box
# Enable spin box depends on the selected option
if self._parameter.selected == key:
percentage_spin_box.setEnabled(True)
else:
percentage_spin_box.setEnabled(False)
elif value.get('type') == STATIC:
static_value = value.get('value', 0)
if static_value is not None:
self.radio_button_layout.addWidget(
QLabel(str(static_value * 100) + ' %'), i, 1)
elif value.get('type') == MULTIPLE_DYNAMIC:
if self._parameter.selected == key:
self.list_widget.setEnabled(True)
else:
self.list_widget.setEnabled(False)
self.input_button_group.addButton(radio_button, i)
if self._parameter.selected == key:
radio_button.setChecked(True)
# Help text
self.help_label = QLabel(self._parameter.help_text)
self.help_label.setSizePolicy(QSizePolicy.Maximum,
QSizePolicy.Expanding)
self.help_label.setWordWrap(True)
self.help_label.setAlignment(Qt.AlignTop)
self.inner_input_layout.addLayout(self.radio_button_layout)
self.inner_input_layout.addWidget(self.list_widget)
# Put elements into layouts
self.input_layout.addWidget(self.label)
self.input_layout.addLayout(self.inner_input_layout)
self.help_layout = QVBoxLayout()
self.help_layout.addWidget(self.help_label)
self.main_layout.addLayout(self.input_layout)
self.main_layout.addLayout(self.help_layout)
self.setLayout(self.main_layout)
self.setSizePolicy(QSizePolicy.Maximum, QSizePolicy.Expanding)
# Update list widget
self.update_list_widget()
# Connect signal
# noinspection PyUnresolvedReferences
self.input_button_group.buttonClicked.connect(
self.radio_buttons_clicked)
def get_parameter(self):
"""Obtain list parameter object from the current widget state.
:returns: A DefaultValueParameter from the current state of widget
:rtype: DefaultValueParameter
"""
# Set value for each key
for key, value in list(self._parameter.options.items()):
if value.get('type') == STATIC:
continue
elif value.get('type') == SINGLE_DYNAMIC:
new_value = self.spin_boxes.get(key).value()
self._parameter.set_value_for_key(key, new_value)
elif value.get('type') == MULTIPLE_DYNAMIC:
# Need to iterate through all items
items = []
for index in range(self.list_widget.count()):
items.append(self.list_widget.item(index))
new_value = [i.text() for i in items]
self._parameter.set_value_for_key(key, new_value)
# Get selected radio button
radio_button_checked_id = self.input_button_group.checkedId()
# No radio button checked, then default value = None
if radio_button_checked_id == -1:
self._parameter.selected = None
else:
self._parameter.selected = list(
self._parameter.options.keys())[radio_button_checked_id]
return self._parameter
def update_list_widget(self):
"""Update list widget when radio button is clicked."""
# Get selected radio button
radio_button_checked_id = self.input_button_group.checkedId()
# No radio button checked, then default value = None
if radio_button_checked_id > -1:
selected_dict = list(
self._parameter.options.values())[radio_button_checked_id]
if selected_dict.get('type') == MULTIPLE_DYNAMIC:
for field in selected_dict.get('value'):
# Update list widget
field_item = QListWidgetItem(self.list_widget)
field_item.setFlags(Qt.ItemIsEnabled
| Qt.ItemIsSelectable
| Qt.ItemIsDragEnabled)
field_item.setData(Qt.UserRole, field)
field_item.setText(field)
self.list_widget.addItem(field_item)
def radio_buttons_clicked(self):
"""Handler when selected radio button changed."""
# Disable all spin boxes
for spin_box in list(self.spin_boxes.values()):
spin_box.setEnabled(False)
# Disable list widget
self.list_widget.setEnabled(False)
# Get selected radio button
radio_button_checked_id = self.input_button_group.checkedId()
if radio_button_checked_id > -1:
selected_value = list(
self._parameter.options.values())[radio_button_checked_id]
if selected_value.get('type') == MULTIPLE_DYNAMIC:
# Enable list widget
self.list_widget.setEnabled(True)
elif selected_value.get('type') == SINGLE_DYNAMIC:
selected_key = list(
self._parameter.options.keys())[radio_button_checked_id]
self.spin_boxes[selected_key].setEnabled(True)
def select_radio_button(self, key):
"""Helper to select a radio button with key.
:param key: The key of the radio button.
:type key: str
"""
key_index = list(self._parameter.options.keys()).index(key)
radio_button = self.input_button_group.button(key_index)
radio_button.click()
class DeprecateElectorateDialog(QDialog):
"""
A dialog used for selecting electorates to deprecate (or un-deprecate)
:param district_registry: associated registry of available
districts to show
"""
def __init__(self,
electorate_registry: LinzElectoralDistrictRegistry,
parent=None):
super().__init__(parent)
self.electorate_registry = electorate_registry
self.setWindowTitle(self.tr('Deprecate Electorate'))
layout = QVBoxLayout()
self.search = QgsFilterLineEdit()
self.search.setShowSearchIcon(True)
self.search.setPlaceholderText(
self.tr('Search for {}').format(
electorate_registry.type_string_sentence()))
self.search.textChanged.connect(self.filter_changed)
layout.addWidget(self.search)
request = QgsFeatureRequest()
request.setFlags(QgsFeatureRequest.NoGeometry)
request.setSubsetOfAttributes([
electorate_registry.source_field_index,
electorate_registry.title_field_index,
electorate_registry.deprecated_field_index
])
self.list = QListWidget()
for f in electorate_registry.source_layer.getFeatures(request):
title = f[electorate_registry.title_field_index]
code = f[electorate_registry.source_field_index]
deprecated = f[electorate_registry.deprecated_field_index]
if deprecated:
title = '*' + title
item = QListWidgetItem(title)
item.setData(Qt.UserRole, code)
self.list.addItem(item)
layout.addWidget(self.list, 10)
button_box = QDialogButtonBox(QDialogButtonBox.Ok
| QDialogButtonBox.Cancel)
layout.addWidget(button_box)
button_box.rejected.connect(self.reject)
button_box.accepted.connect(self.accept)
self.setLayout(layout)
self.list.itemDoubleClicked.connect(self.accept)
def selected_district(self):
"""
Returns the electorate selected in the dialog
"""
if self.list.selectedItems():
return self.list.selectedItems()[0].data(Qt.UserRole)
return None
def filter_changed(self, filter_text):
"""
Handles search filter changes
"""
for i in range(self.list.count()):
item = self.list.item(i)
item.setHidden(filter_text.upper() not in item.text().upper())
class ScenarioSelectionDialog(QDialog):
"""
A dialog used for selecting from available scenarios
"""
def __init__(self, scenario_registry: ScenarioRegistry, parent=None):
"""
Constructor for ScenarioSelectionDialog
:param scenario_registry: linked scenario registry
:param parent: parent widget
"""
super().__init__(parent)
self.scenario_registry = scenario_registry
self.setWindowTitle(self.tr('Select Current Scenario'))
layout = QVBoxLayout()
self.search = QgsFilterLineEdit()
self.search.setShowSearchIcon(True)
self.search.setPlaceholderText(self.tr('Search for scenario'))
self.search.textChanged.connect(self.filter_changed)
layout.addWidget(self.search)
self.list = QListWidget()
for title, scenario_id in scenario_registry.scenario_titles().items():
item = QListWidgetItem(title)
item.setData(Qt.UserRole, scenario_id)
self.list.addItem(item)
layout.addWidget(self.list, 10)
button_box = QDialogButtonBox(
QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
layout.addWidget(button_box)
button_box.rejected.connect(self.reject)
button_box.accepted.connect(self.accept)
self.setLayout(layout)
self.list.itemDoubleClicked.connect(
self.accept)
# select last scenario by default
if self.list.count() > 0:
self.list.item(self.list.count() - 1).setSelected(True)
def set_selected_scenario(self, scenario):
"""
Sets the scenario selected in the dialog
:param scenario: scenario to select
"""
for i in range(self.list.count()):
if self.list.item(i).data(Qt.UserRole) == scenario:
self.list.item(i).setSelected(True)
return
def selected_scenario(self):
"""
Returns the scenario selected in the dialog
"""
if self.list.selectedItems():
return self.list.selectedItems()[0].data(Qt.UserRole)
return None
def filter_changed(self, filter_text):
"""
Handles search filter changes
"""
for i in range(self.list.count()):
item = self.list.item(i)
item.setHidden(filter_text.upper() not in item.text().upper())
class GraphDialog(QDialog):
edit_patterns = 0
edit_curves = 1
titles = {edit_patterns: 'Pattern editor', edit_curves: 'Curve editor'}
labels = {edit_patterns: 'Patterns', edit_curves: 'Curves'}
def __init__(self, dockwidget, parent, params, edit_type):
QDialog.__init__(self, parent)
main_lay = QVBoxLayout(self)
self.dockwidget = dockwidget
self.params = params
self.edit_type = edit_type
self.x_label = ''
self.y_label = ''
self.setMinimumWidth(600)
self.setMinimumHeight(400)
self.setWindowTitle(self.titles[edit_type]) # TODO: softcode
self.setWindowModality(QtCore.Qt.ApplicationModal)
self.current = None
self.current_saved = False
# File
self.lbl_file = QLabel('File:')
self.fra_file = QFrame()
self.fra_file.setContentsMargins(0, 0, 0, 0)
fra_file_lay = QHBoxLayout(self.fra_file)
if edit_type == self.edit_patterns:
self.txt_file = QLineEdit(self.params.patterns_file)
elif edit_type == self.edit_curves:
self.txt_file = QLineEdit(self.params.curves_file)
self.txt_file.setReadOnly(True)
self.txt_file.setAlignment(QtCore.Qt.AlignLeft
| QtCore.Qt.AlignVCenter)
self.txt_file.setSizePolicy(QSizePolicy.MinimumExpanding,
QSizePolicy.Minimum)
fra_file_lay.addWidget(self.txt_file)
self.btn_file = QPushButton('Change') # TODO: softcode
self.btn_file.clicked.connect(self.import_file)
fra_file_lay.addWidget(self.btn_file)
fra_file_lay.setContentsMargins(0, 0, 0, 0)
self.lbl_list = QLabel(self.labels[edit_type])
self.lst_list = QListWidget()
self.lst_list.currentItemChanged.connect(self.list_item_changed)
# Form
self.fra_form = QFrame()
fra_form1_lay = QFormLayout(self.fra_form)
fra_form1_lay.setContentsMargins(0, 0, 0, 0)
fra_form1_lay.addRow(self.lbl_list, self.lst_list)
# Buttons
self.fra_buttons = QFrame()
fra_buttons_lay = QHBoxLayout(self.fra_buttons)
fra_buttons_lay.setContentsMargins(0, 0, 0, 0)
if self.edit_type == self.edit_patterns:
ele_name = 'pattern'
elif self.edit_type == self.edit_curves:
ele_name = 'curve'
self.btn_new = QPushButton('New ' + ele_name) # TODO: softcode
self.btn_new.clicked.connect(self.new_element)
fra_buttons_lay.addWidget(self.btn_new)
self.btn_import = QPushButton('Import ' + ele_name +
's') # TODO: softcode
self.btn_import.clicked.connect(self.import_file)
fra_buttons_lay.addWidget(self.btn_import)
self.btn_save = QPushButton('Save current ' +
ele_name) # TODO: softcode
self.btn_save.clicked.connect(self.save)
fra_buttons_lay.addWidget(self.btn_save)
self.btn_del = QPushButton('Delete current ' +
ele_name) # TODO: softcode
self.btn_del.clicked.connect(self.del_item)
fra_buttons_lay.addWidget(self.btn_del)
# ID
self.lbl_id = QLabel('ID:')
self.txt_id = QLineEdit()
self.txt_id.setSizePolicy(QSizePolicy.Maximum,
QSizePolicy.MinimumExpanding)
self.lbl_desc = QLabel('Desc.:')
self.txt_desc = QLineEdit()
self.fra_id = QFrame()
fra_id_lay = QHBoxLayout(self.fra_id)
fra_id_lay.addWidget(self.lbl_id)
fra_id_lay.addWidget(self.txt_id)
fra_id_lay.addWidget(self.lbl_desc)
fra_id_lay.addWidget(self.txt_desc)
# Table form
self.table = QTableWidget(self)
self.rows_nr = 24
self.cols_nr = 2
self.table.setRowCount(self.rows_nr)
self.table.setColumnCount(self.cols_nr)
self.table.verticalHeader().setVisible(False)
# Initialize empty table
self.clear_table()
self.table.itemChanged.connect(self.data_changed)
self.fra_table = QFrame()
fra_table_lay = QVBoxLayout(self.fra_table)
fra_table_lay.setContentsMargins(0, 0, 0, 0)
if edit_type == self.edit_curves:
self.fra_pump_type = QFrame()
fra_pump_type_lay = QFormLayout(self.fra_pump_type)
self.lbl_pump_type = QLabel('Curve type:') # TODO: softcode
self.cbo_pump_type = QComboBox()
for key, name in Curve.type_names.items():
self.cbo_pump_type.addItem(name, key)
fra_pump_type_lay.addRow(self.lbl_pump_type, self.cbo_pump_type)
fra_table_lay.addWidget(self.fra_pump_type)
self.cbo_pump_type.activated.connect(self.cbo_pump_type_activated)
fra_table_lay.addWidget(self.table)
self.btn_add_row = QPushButton('Add row')
self.btn_add_row.clicked.connect(self.add_row)
fra_table_lay.addWidget(self.btn_add_row)
# Graph canvas
self.fra_graph = QFrame()
self.static_canvas = StaticMplCanvas(self.fra_graph,
width=5,
height=4,
dpi=100)
fra_graph_lay = QVBoxLayout(self.fra_graph)
fra_graph_lay.addWidget(self.static_canvas)
# Top frame
self.fra_top = QFrame()
fra_top_lay = QVBoxLayout(self.fra_top)
fra_top_lay.addWidget(self.fra_form)
fra_top_lay.addWidget(self.fra_id)
fra_top_lay.addWidget(self.fra_buttons)
# Bottom frame
self.fra_bottom = QFrame()
fra_bottom_lay = QHBoxLayout(self.fra_bottom)
fra_bottom_lay.addWidget(self.fra_table)
fra_bottom_lay.addWidget(self.fra_graph)
# Main
main_lay.addWidget(self.fra_top)
main_lay.addWidget(self.fra_bottom)
# Get existing patterns/curves
self.need_to_update_graph = False
if self.edit_type == self.edit_patterns:
for pattern_id, pattern in self.params.patterns.items():
self.lst_list.addItem(pattern.id)
elif self.edit_type == self.edit_curves:
for curve_id, curve in self.params.curves.items():
self.lst_list.addItem(curve.id)
if self.lst_list.count() > 0:
self.lst_list.setCurrentRow(0)
self.txt_id.setEnabled(True)
self.txt_desc.setEnabled(True)
self.btn_save.setEnabled(True)
self.btn_del.setEnabled(True)
self.table.setEnabled(True)
self.table.setEditTriggers(QAbstractItemView.AllEditTriggers)
else:
self.txt_id.setEnabled(False)
self.txt_desc.setEnabled(False)
self.btn_save.setEnabled(False)
self.btn_del.setEnabled(False)
self.table.setEnabled(False)
self.table.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.new_dialog = None
self.need_to_update_graph = True
def cbo_pump_type_activated(self):
self.update_table_headers()
self.update_graph()
def add_row(self):
row_pos = self.table.rowCount()
self.table.insertRow(row_pos)
col = 0
item = QTableWidgetItem(str(row_pos))
if self.edit_type == self.edit_patterns:
self.table.setItem(row_pos, col, item)
item.setFlags(QtCore.Qt.ItemIsSelectable)
def setVisible(self, bool):
QDialog.setVisible(self, bool)
self.update_table_headers()
self.update_graph()
def list_item_changed(self):
p_index = self.lst_list.currentRow()
flags = Qt.ItemFlags()
flags != Qt.ItemIsEnabled
# Clear table
self.clear_table()
self.need_to_update_graph = False
if p_index >= 0:
self.table.setRowCount(0)
if self.edit_type == self.edit_patterns:
self.current = self.params.patterns[
self.lst_list.currentItem().text()]
for v in range(len(self.current.values)):
row_pos = self.table.rowCount()
self.table.insertRow(row_pos)
item = QTableWidgetItem(str(v))
item.setFlags(flags)
self.table.setItem(v, 0, item)
self.table.setItem(
v, 1, QTableWidgetItem(str(self.current.values[v])))
elif self.edit_type == self.edit_curves:
self.current = self.params.curves[
self.lst_list.currentItem().text()]
for v in range(len(self.current.xs)):
row_pos = self.table.rowCount()
self.table.insertRow(row_pos)
self.table.setItem(
v, 0, QTableWidgetItem(str(self.current.xs[v])))
self.table.setItem(
v, 1, QTableWidgetItem(str(self.current.ys[v])))
curve_type = self.current.type
self.cbo_pump_type.setCurrentIndex(curve_type)
# Update GUI
self.txt_id.setText(self.current.id)
self.txt_desc.setText(self.current.desc)
self.update_table_headers()
# Update graph
self.need_to_update_graph = True
self.update_graph()
else:
# No curves
self.txt_id.setText('')
self.txt_desc.setText('')
# Update table and chart
self.need_to_update_graph = False
for v in range(self.table.columnCount()):
self.table.setItem(v, 1, QTableWidgetItem(''))
self.need_to_update_graph = True
self.update_graph()
def import_file(self):
config_file = ConfigFile(Parameters.config_file_path)
directory = None
if self.edit_type == GraphDialog.edit_curves:
directory = self.params.last_curves_dir
elif self.edit_type == GraphDialog.edit_patterns:
directory = self.params.last_patterns_dir
if directory is None:
directory = self.params.last_project_dir
file_path, __ = QFileDialog.getOpenFileName(self, 'Select file',
directory,
'Files (*.txt *.inp)')
if file_path is None or file_path == '':
return
else:
if self.edit_type == GraphDialog.edit_patterns:
# Save patterns file path in configuration file
config_file.set_patterns_file_path(file_path)
Parameters.patterns_file = file_path
elif self.edit_type == GraphDialog.edit_curves:
# Save curve file path in configuration file
config_file.set_curves_file_path(file_path)
Parameters.curves_file = file_path
self.read(file_path)
def read(self, file_path):
self.lst_list.clear()
if self.edit_type == self.edit_patterns:
InpFile.read_patterns(self.params, file_path)
for pattern_id, pattern in self.params.patterns.items():
# desc = ' (' + pattern.desc + ')' if pattern.desc is not None else ''
self.lst_list.addItem(pattern.id)
self.params.patterns[pattern.id] = pattern
elif self.edit_type == self.edit_curves:
InpFile.read_curves(self.params, file_path)
for curve_id, curve in self.params.curves.items():
# desc = ' (' + curve.desc + ')' if curve.desc is not None else ''
self.lst_list.addItem(curve.id)
self.params.curves[curve.id] = curve
if self.lst_list.count() > 0:
self.lst_list.setCurrentRow(0)
def new_element(self):
old_ids = []
if self.edit_type == self.edit_patterns:
for pattern in self.params.patterns.values():
old_ids.append(pattern.id)
elif self.edit_type == self.edit_curves:
for curve in self.params.curves.values():
old_ids.append(curve.id)
self.new_dialog = NewIdDialog(self, old_ids)
self.new_dialog.exec_()
new_id = self.new_dialog.get_newid()
description = self.new_dialog.get_description()
if new_id is None or description is None:
return
if self.edit_type == self.edit_patterns:
new_pattern = Pattern(new_id, description)
self.params.patterns[new_pattern.id] = new_pattern
self.lst_list.addItem(new_pattern.id)
elif self.edit_type == self.edit_curves:
curve_type = self.cbo_pump_type.itemData(
self.cbo_pump_type.currentIndex())
new_curve = Curve(new_id, curve_type, desc=description)
self.params.curves[new_curve.id] = new_curve
self.lst_list.addItem(new_curve.id)
self.lst_list.setCurrentRow(self.lst_list.count() - 1)
self.txt_id.setText(new_id)
self.txt_desc.setText(description)
# Clear table
self.clear_table()
self.static_canvas.axes.clear()
self.txt_id.setEnabled(True)
self.txt_desc.setEnabled(True)
self.btn_save.setEnabled(True)
self.btn_del.setEnabled(True)
self.table.setEnabled(True)
self.table.setEditTriggers(QAbstractItemView.AllEditTriggers)
def save(self):
self.need_to_update_graph = False
# Check for ID
if not self.txt_id.text():
QMessageBox.warning(
self,
Parameters.plug_in_name,
u'Please specify the ID.', # TODO: softcode
QMessageBox.Ok)
return
if self.edit_type == GraphDialog.edit_patterns:
values = []
for row in range(self.table.rowCount()):
item = self.table.item(row, 1)
if item is not None and item.text() != '':
values.append(self.from_item_to_val(item))
else:
values.append('0')
pattern = Pattern(self.txt_id.text(), self.txt_desc.text(), values)
old_patterns = self.params.patterns
old_patterns[pattern.id] = pattern
self.params.patterns = old_patterns
self.lst_list.currentItem().setText(pattern.id)
elif self.edit_type == GraphDialog.edit_curves:
# Check for ID unique
xs = []
ys = []
for row in range(self.table.rowCount()):
item_x = self.table.item(row, 0)
item_y = self.table.item(row, 1)
if item_x.text().strip() != '' and item_y.text().strip() != '':
xs.append(self.from_item_to_val(item_x))
ys.append(self.from_item_to_val(item_y))
curve_type = self.cbo_pump_type.itemData(
self.cbo_pump_type.currentIndex())
curve = Curve(self.txt_id.text(), curve_type, self.txt_desc.text())
for v in range(len(xs)):
curve.append_xy(xs[v], ys[v])
old_curves = self.params.curves
old_curves[curve.id] = curve
self.params.curves = old_curves
self.lst_list.currentItem().setText(curve.id)
# Update GUI
self.dockwidget.update_curves_combo()
# self.read()
self.need_to_update_graph = True
def clear_table(self):
self.need_to_update_graph = False
for r in range(self.table.rowCount()):
self.table.setItem(r, 0, QTableWidgetItem(None))
self.table.setItem(r, 1, QTableWidgetItem(None))
for row in range(self.rows_nr):
for col in range(self.cols_nr):
if self.edit_type == self.edit_patterns:
if col == 0:
item = QTableWidgetItem(str(row))
self.table.setItem(row, col, item)
item.setFlags(QtCore.Qt.ItemIsSelectable)
# elif col == 1 and row == 0:
# item = QTableWidgetItem(str(1))
# self.table.setItem(row, col, item)
# item.setFlags(QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled)
# elif self.edit_type == self.edit_curves:
# if row == 0:
# item = QTableWidgetItem(str(0))
# self.table.setItem(row, 0, item)
# item = QTableWidgetItem(str(1))
# self.table.setItem(row, 1, item)
# item.setFlags(QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled)
self.need_to_update_graph = True
def del_item(self):
selected_row = self.lst_list.currentRow()
name = self.lst_list.currentItem().text()
if selected_row < 0:
return
self.lst_list.takeItem(selected_row)
if self.lst_list.count() == 0:
self.txt_id.setEnabled(False)
self.txt_desc.setEnabled(False)
self.btn_save.setEnabled(False)
self.btn_del.setEnabled(False)
self.table.setEnabled(False)
self.table.setEditTriggers(QAbstractItemView.NoEditTriggers)
if self.edit_type == GraphDialog.edit_curves:
del self.params.curves[name]
# Update GUI
self.dockwidget.update_curves_combo()
elif self.edit_type == GraphDialog.edit_patterns:
del self.params.patterns[name]
# Update GUI
self.dockwidget.update_patterns_combo()
def data_changed(self):
if self.need_to_update_graph:
self.update_graph()
def update_table_headers(self):
if self.edit_type == self.edit_patterns:
self.x_label = 'Time period'
self.y_label = 'Multiplier'
elif self.edit_type == self.edit_curves:
cbo_data = self.cbo_pump_type.itemData(
self.cbo_pump_type.currentIndex())
if cbo_data == Curve.type_efficiency:
self.x_label = 'Flow ' + '[' + self.params.options.flow_units + ']'
self.y_label = 'Efficiency ' + '[' + self.params.options.units_deltaz[
self.params.options.units] + ']'
if cbo_data == Curve.type_headloss:
self.x_label = 'Flow ' + '[' + self.params.options.flow_units + ']'
self.y_label = 'Headloss ' + '[' + self.params.options.units_deltaz[
self.params.options.units] + ']'
if cbo_data == Curve.type_pump:
self.x_label = 'Flow ' + '[' + self.params.options.flow_units + ']'
self.y_label = 'Head ' + '[' + self.params.options.units_deltaz[
self.params.options.units] + ']'
if cbo_data == Curve.type_volume:
self.x_label = 'Height ' + '[' + self.params.options.flow_units + ']'
self.y_label = 'Volume ' + '[' + self.params.options.units_deltaz[
self.params.options.units] + ']'
self.table.setHorizontalHeaderLabels([self.x_label,
self.y_label]) # TODO: softcode
def update_graph(self):
if not self.need_to_update_graph:
return
xs = []
ys = []
for row in range(self.table.rowCount()):
item = self.table.item(row, 0)
x = self.from_item_to_val(item)
item = self.table.item(row, 1)
y = self.from_item_to_val(item)
if x is not None:
xs.append(float(x))
if y is not None:
ys.append(float(y))
if len(xs) == 0 or len(ys) == 0:
self.static_canvas.clear()
return
xys_t = list(zip(xs, ys))
xys_t.sort()
xys = list(zip(*xys_t))
xs = xys[0]
ys = xys[1]
if self.edit_type == self.edit_patterns:
y_axis_label = 'Mult. avg.: ' + '{0:.2f}'.format(
(numpy.average(ys)))
self.static_canvas.draw_bars_graph(
ys,
time_period=self.params.times.pattern_timestep,
y_axes_label=y_axis_label)
elif self.edit_type == self.edit_curves:
# Account for different types of curves
cbo_data = self.cbo_pump_type.itemData(
self.cbo_pump_type.currentIndex())
series_length = min(len(xs), len(ys))
# Need to account for different types of curves
if cbo_data == Curve.type_efficiency or cbo_data == Curve.type_headloss or cbo_data == Curve.type_volume:
self.static_canvas.draw_line_graph(xs[:series_length],
ys[:series_length],
self.x_label, self.y_label)
elif cbo_data == Curve.type_pump:
if series_length == 1 or series_length == 3:
if series_length == 1:
# 3 curve points
curve_xs = [0, xs[0], xs[0] * 2]
curve_ys = [ys[0] * 1.33, ys[0], 0]
# y = a * x^2 + b * x + c
elif series_length == 3:
# 3 curve points
curve_xs = [xs[0], xs[1], xs[2]]
curve_ys = [ys[0], ys[1], ys[2]]
(a, b, c) = numpy.polyfit(curve_xs, curve_ys, 2)
# Create a few interpolated values
interp_xs = []
interp_ys = []
n_vals = 30
for v in range(n_vals + 1):
x = (curve_xs[2] - curve_xs[0]) / n_vals * v
interp_xs.append(x)
y = a * x**2 + b * x + c
interp_ys.append(y)
self.static_canvas.draw_line_graph(interp_xs, interp_ys,
self.x_label,
self.y_label)
else:
self.static_canvas.draw_line_graph(xs[:series_length],
ys[:series_length],
self.x_label,
self.y_label)
def from_item_to_val(self, item):
if item is None:
value = None
else:
value = item.text()
try:
value = float(value)
value = max(value, 0)
except:
value = None
return value
class TagsDialog(QDialog):
def __init__(self, dockwidget, parent, params):
QDialog.__init__(self, parent)
main_lay = QVBoxLayout(self)
self.dockwidget = dockwidget
self.params = params
self.setWindowTitle('Tags editor')
# Top frame
self.fra_top = QFrame()
fra_top_lay = QVBoxLayout(self.fra_top)
self.lst_main = QListWidget(self)
self.btn_add = QPushButton('Add tag')
self.btn_add.clicked.connect(self.add_tag)
self.btn_remove = QPushButton('Remove tag')
self.btn_remove.clicked.connect(self.remove_tag)
fra_top_lay.addWidget(self.lst_main)
fra_top_lay.addWidget(self.btn_add)
fra_top_lay.addWidget(self.btn_remove)
# Bottom frame
self.fra_bottom = QFrame()
fra_bottom_lay = QHBoxLayout(self.fra_bottom)
btb_main = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
btb_main.accepted.connect(self.ok)
btb_main.rejected.connect(self.reject)
fra_bottom_lay.addWidget(btb_main)
# Main
main_lay.addWidget(self.fra_top)
main_lay.addWidget(self.fra_bottom)
self.initialize()
def initialize(self):
for tag_name in self.params.tag_names:
self.lst_main.insertItem(self.lst_main.count(), QListWidgetItem(tag_name, self.lst_main))
def ok(self):
tag_names = []
for r in range(self.lst_main.count()):
tag_names.append(self.lst_main.item(r).text())
self.params.tag_names = tag_names
self.setVisible(False)
def reject(self):
self.setVisible(False)
def add_tag(self):
tag_name_dialog = TagNameDialog(self.dockwidget, self)
tag_name_dialog.exec_()
tag_name = tag_name_dialog.get_tag_name()
if tag_name is not None:
current_row = self.lst_main.currentRow()
if current_row is None:
current_row = self.lst_main.count()
self.lst_main.insertItem(current_row, QListWidgetItem(tag_name, self.lst_main))
def remove_tag(self):
sel_items = self.lst_main.selectedItems()
for sel_item in sel_items:
self.lst_main.takeItem(self.lst_main.row(sel_item))
class GroupSelectParameterWidget(GenericParameterWidget):
"""Widget class for Group Select Parameter."""
def __init__(self, parameter, parent=None):
"""Constructor.
:param parameter: A GroupSelectParameter object.
:type parameter: GroupSelectParameter
"""
QWidget.__init__(self, parent)
self._parameter = parameter
# Store spin box
self.spin_boxes = {}
# Create elements
# Label (name)
self.label = QLabel(self._parameter.name)
# Layouts
self.main_layout = QVBoxLayout()
self.input_layout = QVBoxLayout()
# _inner_input_layout must be filled with widget in the child class
self.inner_input_layout = QVBoxLayout()
self.radio_button_layout = QGridLayout()
# Create radio button group
self.input_button_group = QButtonGroup()
# List widget
self.list_widget = QListWidget()
self.list_widget.setSelectionMode(QAbstractItemView.ExtendedSelection)
self.list_widget.setDragDropMode(QAbstractItemView.DragDrop)
self.list_widget.setDefaultDropAction(Qt.MoveAction)
self.list_widget.setEnabled(False)
self.list_widget.setSizePolicy(
QSizePolicy.Maximum, QSizePolicy.Expanding)
for i, key in enumerate(self._parameter.options):
value = self._parameter.options[key]
radio_button = QRadioButton(value.get('label'))
self.radio_button_layout.addWidget(radio_button, i, 0)
if value.get('type') == SINGLE_DYNAMIC:
percentage_spin_box = PercentageSpinBox(self)
self.radio_button_layout.addWidget(percentage_spin_box, i, 1)
percentage_spin_box.setValue(value.get('value', 0))
step = percentage_spin_box.singleStep()
if step > 1:
precision = 0
else:
precision = len(str(step).split('.')[1])
if precision > 3:
precision = 3
percentage_spin_box.setDecimals(precision)
self.spin_boxes[key] = percentage_spin_box
# Enable spin box depends on the selected option
if self._parameter.selected == key:
percentage_spin_box.setEnabled(True)
else:
percentage_spin_box.setEnabled(False)
elif value.get('type') == STATIC:
static_value = value.get('value', 0)
if static_value is not None:
self.radio_button_layout.addWidget(
QLabel(str(static_value * 100) + ' %'), i, 1)
elif value.get('type') == MULTIPLE_DYNAMIC:
if self._parameter.selected == key:
self.list_widget.setEnabled(True)
else:
self.list_widget.setEnabled(False)
self.input_button_group.addButton(radio_button, i)
if self._parameter.selected == key:
radio_button.setChecked(True)
# Help text
self.help_label = QLabel(self._parameter.help_text)
self.help_label.setSizePolicy(
QSizePolicy.Maximum, QSizePolicy.Expanding)
self.help_label.setWordWrap(True)
self.help_label.setAlignment(Qt.AlignTop)
self.inner_input_layout.addLayout(self.radio_button_layout)
self.inner_input_layout.addWidget(self.list_widget)
# Put elements into layouts
self.input_layout.addWidget(self.label)
self.input_layout.addLayout(self.inner_input_layout)
self.help_layout = QVBoxLayout()
self.help_layout.addWidget(self.help_label)
self.main_layout.addLayout(self.input_layout)
self.main_layout.addLayout(self.help_layout)
self.setLayout(self.main_layout)
self.setSizePolicy(QSizePolicy.Maximum, QSizePolicy.Expanding)
# Update list widget
self.update_list_widget()
# Connect signal
# noinspection PyUnresolvedReferences
self.input_button_group.buttonClicked.connect(
self.radio_buttons_clicked)
def get_parameter(self):
"""Obtain list parameter object from the current widget state.
:returns: A DefaultValueParameter from the current state of widget
:rtype: DefaultValueParameter
"""
# Set value for each key
for key, value in list(self._parameter.options.items()):
if value.get('type') == STATIC:
continue
elif value.get('type') == SINGLE_DYNAMIC:
new_value = self.spin_boxes.get(key).value()
self._parameter.set_value_for_key(key, new_value)
elif value.get('type') == MULTIPLE_DYNAMIC:
# Need to iterate through all items
items = []
for index in range(self.list_widget.count()):
items.append(self.list_widget.item(index))
new_value = [i.text() for i in items]
self._parameter.set_value_for_key(key, new_value)
# Get selected radio button
radio_button_checked_id = self.input_button_group.checkedId()
# No radio button checked, then default value = None
if radio_button_checked_id == -1:
self._parameter.selected = None
else:
self._parameter.selected = list(self._parameter.options.keys())[
radio_button_checked_id]
return self._parameter
def update_list_widget(self):
"""Update list widget when radio button is clicked."""
# Get selected radio button
radio_button_checked_id = self.input_button_group.checkedId()
# No radio button checked, then default value = None
if radio_button_checked_id > -1:
selected_dict = list(self._parameter.options.values())[
radio_button_checked_id]
if selected_dict.get('type') == MULTIPLE_DYNAMIC:
for field in selected_dict.get('value'):
# Update list widget
field_item = QListWidgetItem(self.list_widget)
field_item.setFlags(
Qt.ItemIsEnabled
| Qt.ItemIsSelectable
| Qt.ItemIsDragEnabled)
field_item.setData(Qt.UserRole, field)
field_item.setText(field)
self.list_widget.addItem(field_item)
def radio_buttons_clicked(self):
"""Handler when selected radio button changed."""
# Disable all spin boxes
for spin_box in list(self.spin_boxes.values()):
spin_box.setEnabled(False)
# Disable list widget
self.list_widget.setEnabled(False)
# Get selected radio button
radio_button_checked_id = self.input_button_group.checkedId()
if radio_button_checked_id > -1:
selected_value = list(self._parameter.options.values())[
radio_button_checked_id]
if selected_value.get('type') == MULTIPLE_DYNAMIC:
# Enable list widget
self.list_widget.setEnabled(True)
elif selected_value.get('type') == SINGLE_DYNAMIC:
selected_key = list(self._parameter.options.keys())[
radio_button_checked_id]
self.spin_boxes[selected_key].setEnabled(True)
def select_radio_button(self, key):
"""Helper to select a radio button with key.
:param key: The key of the radio button.
:type key: str
"""
key_index = list(self._parameter.options.keys()).index(key)
radio_button = self.input_button_group.button(key_index)
radio_button.click()
class AnnotationManager:
def __init__(self, iface):
locale = QSettings().value('locale/userLocale')[0:2]
locale_path = os.path.join(os.path.dirname(__file__), 'i18n',
'annotationManager_{}.qm'.format(locale))
self.translator = None
if os.path.exists(locale_path):
self.translator = QTranslator()
self.translator.load(locale_path)
if qVersion() > '4.3.3':
QCoreApplication.installTranslator(self.translator)
self.iface = iface
self.iface.projectRead.connect(self.projectOpen)
self.dock = QDockWidget(self.tr('Annotations'))
self.manager = QWidget()
toolbar = QToolBar()
self.annotationList = QListWidget()
self.annotationList.setSelectionMode(
QAbstractItemView.ExtendedSelection)
self.annotationList.itemSelectionChanged.connect(self.selectAnnotation)
self.annotationList.itemChanged.connect(self.checkItem)
action_refresh = QAction(
QIcon(':/plugins/annotationManager/resources/mActionDraw.png'),
self.tr('Refresh the annotations list'), self.manager)
action_refresh.triggered.connect(self.refreshAnnotations)
action_remove = QAction(
QIcon(
':/plugins/annotationManager/resources/mActionRemoveAnnotation.png'
), self.tr('Remove the selected annotation'), self.manager)
action_remove.triggered.connect(self.removeAnnotation)
viewMenu = QMenu()
action_showAll = QAction(
QIcon(':/plugins/annotationManager/resources/mActionShowAll.png'),
self.tr('Show all annotations'), self.manager)
action_showAll.triggered.connect(self.showAll)
action_hideAll = QAction(
QIcon(':/plugins/annotationManager/resources/mActionHideAll.png'),
self.tr('Hide all annotations'), self.manager)
action_hideAll.triggered.connect(self.hideAll)
action_showAllSelected = QAction(
QIcon(':/plugins/annotationManager/resources/mActionShowAll.png'),
self.tr('Show all selected annotations'), self.manager)
action_showAllSelected.triggered.connect(self.showAllSelected)
action_hideAllSelected = QAction(
QIcon(':/plugins/annotationManager/resources/mActionHideAll.png'),
self.tr('Hide all selected annotations'), self.manager)
action_hideAllSelected.triggered.connect(self.hideAllSelected)
viewMenu.addAction(action_showAll)
viewMenu.addAction(action_hideAll)
viewMenu.addAction(action_showAllSelected)
viewMenu.addAction(action_hideAllSelected)
viewButton = QToolButton()
viewButton.setIcon(
QIcon(':/plugins/annotationManager/resources/mActionShowAll.png'))
viewButton.setPopupMode(2)
viewButton.setMenu(viewMenu)
toolbar.addAction(action_refresh)
toolbar.addAction(action_remove)
toolbar.addWidget(viewButton)
toolbar.setIconSize(QSize(16, 16))
p1_vertical = QVBoxLayout()
p1_vertical.setContentsMargins(0, 0, 0, 0)
p1_vertical.addWidget(toolbar)
p1_vertical.addWidget(self.annotationList)
self.manager.setLayout(p1_vertical)
self.dock.setWidget(self.manager)
self.dock.setAllowedAreas(Qt.LeftDockWidgetArea
| Qt.RightDockWidgetArea)
self.iface.addDockWidget(Qt.LeftDockWidgetArea, self.dock)
self.rb = QgsRubberBand(self.iface.mapCanvas(),
QgsWkbTypes.PolygonGeometry)
self.project = QgsProject.instance()
self.annotationManager = self.project.annotationManager()
self.annotationManager.annotationAdded.connect(self.refreshAnnotations)
self.annotationManager.annotationRemoved.connect(
self.refreshAnnotations)
def checkItem(self, item):
index = self.annotationList.row(item)
if item.checkState() == Qt.Checked:
self.annotationManager.annotations()[index].setVisible(True)
else:
self.annotationManager.annotations()[index].setVisible(False)
if item.isSelected():
item.setSelected(False)
self.rb.reset(QgsWkbTypes.PolygonGeometry)
def selectAnnotation(self):
self.rb.reset(QgsWkbTypes.PolygonGeometry)
self.rb.setColor(QColor(0, 0, 255, 128))
for item in self.annotationList.selectedItems():
index = self.annotationList.row(item)
mapTool = QgsMapTool(self.iface.mapCanvas())
point = mapTool.toCanvasCoordinates(
self.annotationManager.annotations()[index].mapPosition())
pt1 = mapTool.toMapCoordinates(
QPoint(point.x() - 10,
point.y() - 10))
pt2 = mapTool.toMapCoordinates(
QPoint(point.x() + 10,
point.y() + 10))
rect = QgsRectangle(pt1, pt2)
poly = QgsGeometry().fromRect(rect)
self.rb.addGeometry(poly, None)
def showAll(self):
count = self.annotationList.count()
for i in range(count):
self.annotationList.item(i).setCheckState(Qt.Checked)
def hideAll(self):
count = self.annotationList.count()
for i in range(count):
self.annotationList.item(i).setCheckState(Qt.Unchecked)
def showAllSelected(self):
for item in self.annotationList.selectedItems():
item.setCheckState(Qt.Checked)
def hideAllSelected(self):
for item in self.annotationList.selectedItems():
item.setCheckState(Qt.Unchecked)
def unload(self):
del self.dock
def tr(self, message):
return QCoreApplication.translate('AnnotationManager', message)
def refreshAnnotationTitle(self, annotation=None):
if annotation is None:
annotation = self.project.annotationManager().sender()
item = self.annotationList.item(
self.annotationManager.annotations().index(annotation))
title = 'Annotation'
if isinstance(annotation, QgsTextAnnotation):
title = annotation.document().toPlainText().split('\n')[0]
if len(title) > 40:
title = title[:40] + '(...)'
item.setText(title)
def refreshAnnotations(self):
self.annotationList.clearSelection()
self.annotationList.clear()
for annotation in self.annotationManager.annotations():
item = QListWidgetItem()
annotation.appearanceChanged.connect(self.refreshAnnotationTitle)
if annotation.isVisible():
item.setCheckState(Qt.Checked)
else:
item.setCheckState(Qt.Unchecked)
item.setFlags(item.flags())
self.annotationList.addItem(item)
self.refreshAnnotationTitle(annotation)
def removeAnnotation(self):
if len(self.annotationList.selectedItems()) > 0:
self.annotationManager.annotationRemoved.disconnect()
trash = []
for item in self.annotationList.selectedItems():
index = self.annotationList.row(item)
trash.append(self.annotationManager.annotations()[index])
while trash:
self.annotationManager.removeAnnotation(trash.pop())
self.refreshAnnotations()
self.annotationManager.annotationRemoved.connect(
self.refreshAnnotations)
def projectOpen(self):
self.refreshAnnotations()
def initGui(self):
self.refreshAnnotations()
class MultiSelectComboBox(QComboBox):
SEARCH_BAR_IDX = 0
SELECT_ALL_IDX = 1
RESERVED_IDXS_COUNT = 2
selection_changed = pyqtSignal()
item_was_clicked = pyqtSignal(str, bool)
def __init__(self, parent, mono=False):
super().__init__(parent)
self.mono = mono
if self.mono:
return
self.mlist = QListWidget(self)
self.line_edit = ComplexLineEdit(self)
self.clear()
self.line_edit.setReadOnly(True)
self.line_edit.installEventFilter(self)
self.setModel(self.mlist.model())
self.setView(self.mlist)
self.view().setVerticalScrollBarPolicy(Qt.ScrollBarAsNeeded)
self.setLineEdit(self.line_edit)
# NOTE: this is necessary to handle the case in which an item in the
# list is clicked to its right part, outside the text
self.activated.connect(self.itemClicked)
def on_select_all_toggled(self, state):
for i in range(self.RESERVED_IDXS_COUNT, self.mlist.count()):
checkbox = self.mlist.itemWidget(self.mlist.item(i))
if self.search_bar.text().lower() in checkbox.text().lower():
checkbox.setChecked(state)
def itemClicked(self, idx):
if self.mono:
self.item_was_clicked.emit(self.currentText(), True)
return super().itemClicked(idx)
if idx not in [self.SEARCH_BAR_IDX, self.SELECT_ALL_IDX]:
checkbox = self.mlist.itemWidget(self.mlist.item(idx))
checkbox.setChecked(not checkbox.isChecked())
self.item_was_clicked.emit(checkbox.text(), checkbox.isChecked())
def hidePopup(self):
if self.mono:
return super().hidePopup()
width = self.width()
height = self.mlist.height()
x = (QCursor.pos().x()
- self.mapToGlobal(self.geometry().topLeft()).x()
+ self.geometry().x())
y = (QCursor.pos().y()
- self.mapToGlobal(self.geometry().topLeft()).y()
+ self.geometry().y())
if (x >= 0 and x <= width and y >= self.height()
and y <= height + self.height()):
# Item was clicked, do not hide popup
pass
else:
super().hidePopup()
def stateChanged(self, state):
if self.mono:
return super().stateChanged(state)
# NOTE: not using state
selected_data = ""
separator = "; "
for i in range(self.RESERVED_IDXS_COUNT, self.mlist.count()):
checkbox = self.mlist.itemWidget(self.mlist.item(i))
if checkbox.isChecked():
selected_data += checkbox.text() + separator
if selected_data.endswith(separator):
selected_data = selected_data[:-len(separator)]
if selected_data:
self.line_edit.setText(selected_data)
else:
self.line_edit.clear()
self.line_edit.setToolTip(selected_data)
self.selection_changed.emit()
def on_checkbox_stateChanged(self, text, state):
self.item_was_clicked.emit(text, state)
def add_selected_items(self, items):
if self.mono:
return super().addItems(items)
self.addItems(items, selected=True)
def add_unselected_items(self, items):
if self.mono:
return super().addItems(items)
self.addItems(items, selected=False)
def set_selected_items(self, items):
if self.mono:
return
self.set_items_selection(items, True)
def set_unselected_items(self, items):
if self.mono:
return
self.set_items_selection(items, False)
def set_idxs_selection(self, idxs, checked=True):
if self.mono:
# NOTE: this method is not expected to be used for mono selectors.
# Anyway, we are making it possible to use it, and the selector
# will point to the first element of idxs
return self.setCurrentIndex(idxs[0])
for i in range(self.RESERVED_IDXS_COUNT, self.mlist.count()):
checkbox = self.mlist.itemWidget(self.mlist.item(i))
if i - self.RESERVED_IDXS_COUNT in idxs:
checkbox.setChecked(checked)
else:
checkbox.setChecked(not checked)
def set_items_selection(self, items, checked):
if self.mono:
return
for i in range(self.RESERVED_IDXS_COUNT, self.mlist.count()):
checkbox = self.mlist.itemWidget(self.mlist.item(i))
if checkbox.text() in items:
checkbox.setChecked(checked)
else:
checkbox.setChecked(not checked)
def get_selected_items(self):
items = []
if self.mono:
if super().currentText():
return [super().currentText()]
else:
return []
for i in range(self.RESERVED_IDXS_COUNT, self.mlist.count()):
checkbox = self.mlist.itemWidget(self.mlist.item(i))
if checkbox.isChecked():
items.append(checkbox.text())
return items
def get_unselected_items(self):
items = []
if self.mono:
selected_text = self.currentText()
for i in range(self.count()):
item_text = self.itemText(i)
if item_text and item_text != selected_text:
items.append(item_text)
return items
for i in range(self.RESERVED_IDXS_COUNT, self.mlist.count()):
checkbox = self.mlist.itemWidget(self.mlist.item(i))
if not checkbox.isChecked():
items.append(checkbox.text())
return items
def addItem(self, text, user_data=None, selected=False):
if self.mono:
return super().addItem(text, user_data)
# NOTE: not using user_data
list_widget_item = QListWidgetItem(self.mlist)
checkbox = QCheckBox(self)
checkbox.setText(text)
self.mlist.addItem(list_widget_item)
self.mlist.setItemWidget(list_widget_item, checkbox)
checkbox.stateChanged.connect(self.stateChanged)
checkbox.stateChanged.connect(
lambda state: self.on_checkbox_stateChanged(
checkbox.text(), state))
checkbox.setChecked(selected)
def currentText(self):
if self.mono:
return super().currentText()
return self.line_edit.current_text()
def addItems(self, texts, selected=False):
if self.mono:
return super().addItems(texts)
for text in texts:
self.addItem(text, selected=selected)
def count(self):
if self.mono:
return super().count()
# do not count search bar and toggle select all
count = self.mlist.count() - self.RESERVED_IDXS_COUNT
if count < 0:
count = 0
return count
def selected_count(self):
if self.mono:
if self.currentIndex() == -1:
return 0
else:
return 1
return len(self.get_selected_items())
def onSearch(self, search_str):
self.setMaxVisibleItems(min(10, self.mlist.count()))
for i in range(self.RESERVED_IDXS_COUNT, self.mlist.count()):
checkbox = self.mlist.itemWidget(self.mlist.item(i))
if search_str.lower() in checkbox.text().lower():
self.mlist.item(i).setHidden(False)
else:
self.mlist.item(i).setHidden(True)
# NOTE: hack to fix problem when you first filter and have few items,
# then filter again and have more items
self.hidePopup()
self.showPopup()
# NOTE: hide/show would lose focus from the search bar
self.search_bar.setFocus()
def set_search_bar_placeholder_text(self, text):
self.search_bar.setPlaceholderText(text)
def clear(self):
if self.mono:
return super().clear()
self.mlist.clear()
self.search_bar = QLineEdit(self)
self.search_item = QListWidgetItem(self.mlist)
self.search_bar.setPlaceholderText("Search...")
self.search_bar.setClearButtonEnabled(True)
self.mlist.addItem(self.search_item)
self.mlist.setItemWidget(self.search_item, self.search_bar)
self.toggle_select_item = QListWidgetItem(self.mlist)
self.toggle_ckb = QCheckBox(self)
self.toggle_ckb.setText('Select/unselect all')
self.mlist.addItem(self.toggle_select_item)
self.mlist.setItemWidget(self.toggle_select_item, self.toggle_ckb)
self.toggle_ckb.stateChanged.connect(self.on_select_all_toggled)
self.search_bar.textChanged[str].connect(self.onSearch)
def wheelEvent(self, wheel_event):
if self.mono:
return super().wheelEvent(wheel_event)
# do not handle the wheel event
pass
def eventFilter(self, obj, event):
if self.mono:
return super().eventFilter(obj, event)
# this is handled by ComplexLineEdit
return False
def keyPressEvent(self, event):
if self.mono:
return super().keyPressEvent(event)
# do not handle key event
pass
# def setCurrentText(self, text):
# pass
def setCurrentText(self, texts):
if self.mono:
# NOTE: using the first text
return super().setCurrentText(texts[0])
for i in range(self.RESERVED_IDXS_COUNT, self.mlist.count()):
checkbox = self.mlist.itemWidget(self.mlist.item(i))
checkbox_str = checkbox.text()
if checkbox_str in texts:
checkbox.setChecked(True)
def resetSelection(self):
if self.mono:
return super().setCurrentIndex(-1)
for i in range(self.RESERVED_IDXS_COUNT, self.mlist.count()):
checkbox = self.mlist.itemWidget(self.mlist.item(i))
checkbox.setChecked(False)
class DistrictSelectionDialog(QDialog):
"""
A dialog used for selecting from available districts
:param district_registry: associated registry of available
districts to show
"""
def __init__(self, district_registry, parent=None):
super().__init__(parent)
self.district_registry = district_registry
self.setWindowTitle(self.tr('Select New {}').format(
district_registry.type_string_title()))
layout = QVBoxLayout()
self.recent_label = QLabel(self.tr('Recently used {}').format(
district_registry.type_string_sentence_plural()))
layout.addWidget(self.recent_label)
self.recent_list = QListWidget()
self.recent_list.setMaximumHeight(100)
for d in district_registry.recent_districts_list():
item = QListWidgetItem(self.district_registry.get_district_title(d))
item.setData(Qt.UserRole, d)
self.recent_list.addItem(item)
layout.addWidget(self.recent_list, 0)
self.available_label = QLabel(self.tr('Available {}').format(
district_registry.type_string_sentence_plural()
))
layout.addWidget(self.available_label)
self.search = QgsFilterLineEdit()
self.search.setShowSearchIcon(True)
self.search.setPlaceholderText(self.tr('Search for {}').format(
district_registry.type_string_sentence()))
self.search.textChanged.connect(self.filter_changed)
layout.addWidget(self.search)
self.list = QListWidget()
for title, code in district_registry.district_titles().items():
item = QListWidgetItem(title)
item.setData(Qt.UserRole, code)
self.list.addItem(item)
layout.addWidget(self.list, 10)
button_box = QDialogButtonBox(
QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
layout.addWidget(button_box)
button_box.rejected.connect(self.reject)
button_box.accepted.connect(self.accept)
if self.district_registry.flags() & DistrictRegistry.FLAG_ALLOWS_SPATIAL_SELECT:
self.select_from_map_button = button_box.addButton(
self.tr("Select from Map"), QDialogButtonBox.ActionRole)
self.select_from_map_button.clicked.connect(self.pick_from_map)
else:
self.select_from_map_button = None
self.chose_pick_from_map = False
self.setLayout(layout)
self.recent_list.itemSelectionChanged.connect(
self.recent_list_item_selected)
self.list.itemSelectionChanged.connect(
self.list_item_selected)
self.recent_list.itemDoubleClicked.connect(
self.accept)
self.list.itemDoubleClicked.connect(
self.accept)
# select most recently used district by default
if self.recent_list.count() > 0:
self.recent_list.item(0).setSelected(True)
def recent_list_item_selected(self):
"""
Handles a selection made in the recent district list
"""
if self.recent_list.selectedItems():
self.list.clearSelection()
def list_item_selected(self):
"""
Handles a selection made in the complete district list
"""
if self.list.selectedItems():
self.recent_list.clearSelection()
def set_selected_district(self, district):
"""
Sets the district selected in the dialog
:param district: district to select
"""
for i in range(self.list.count()):
if self.list.item(i).data(Qt.UserRole) == district:
self.list.item(i).setSelected(True)
return
def selected_district(self):
"""
Returns the district selected in the dialog
"""
if self.recent_list.selectedItems():
return self.recent_list.selectedItems()[0].data(Qt.UserRole)
elif self.list.selectedItems():
return self.list.selectedItems()[0].data(Qt.UserRole)
return None
def accept(self): # pylint: disable=missing-docstring
self.district_registry.push_recent_district(self.selected_district())
super().accept()
def filter_changed(self, filter_text):
"""
Handles search filter changes
"""
for i in range(self.list.count()):
item = self.list.item(i)
item.setHidden(filter_text.upper() not in item.text().upper())
def pick_from_map(self):
"""
Triggered when a user selects the "Select from Map" option
"""
self.chose_pick_from_map = True
self.reject()
class CommitSelectDialog(QDialog):
def __init__(self, repo, until=None, path=None, parent=None):
super(CommitSelectDialog, self).__init__(parent or iface.mainWindow())
self.repo = repo
self.ref = None
self.path = path
self.until = until
self.initGui()
def initGui(self):
layout = QVBoxLayout()
buttonBox = QDialogButtonBox(QDialogButtonBox.Ok
| QDialogButtonBox.Close)
self.filterBox = QLineEdit()
self.filterBox.setPlaceholderText(
"[enter text or date in dd/mm/yyyy format to filter history]")
self.filterBox.textChanged.connect(self.filterCommits)
self.list = QListWidget()
self.list.setAlternatingRowColors(True)
self.list.setSelectionMode(QAbstractItemView.SingleSelection)
self.list.setSelectionBehavior(QAbstractItemView.SelectRows)
log = self.repo.log(until=self.until, path=self.path, limit=100)
for commit in log:
item = CommitListItem(commit)
self.list.addItem(item)
layout.addWidget(self.filterBox)
layout.addWidget(self.list)
layout.addWidget(buttonBox)
self.setLayout(layout)
buttonBox.accepted.connect(self.okPressed)
buttonBox.rejected.connect(self.cancelPressed)
self.resize(500, 400)
self.setWindowTitle("Select commit")
def filterCommits(self):
text = self.filterBox.text().strip()
try:
t = datetime.datetime.strptime(text, "%d/%m/%Y")
found = False
for i in range(self.list.count()):
item = self.list.item(i)
if found:
item.setHidden(True)
else:
delta = item.commit.committerdate - t
found = delta.days < 0
item.setHidden(not found)
except ValueError as e:
for i in range(self.list.count()):
item = self.list.item(i)
msg = item.commit.message
item.setHidden(text != "" and text not in msg)
def okPressed(self):
selected = self.list.selectedItems()
if len(selected) == 0:
QMessageBox.warning(self, 'No commit selected',
"Select 1 commits from the commit list.",
QMessageBox.Ok)
else:
self.ref = selected[0].commit
self.close()
def cancelPressed(self):
self.ref = None
self.close()
