def generateHighwayDedicationForm(self):
QgsMessageLog.logMessage(
"In generateHighwayDedicationForm::generateForm ... ",
tag="TOMs panel")
layout = QFormLayout()
# Add turn restriction type
self.cb_dedicationValue = QComboBox(self)
enumList = self.getEnumList('DedicationValue')
self.cb_dedicationValue.addItems(enumList)
layout.addRow(self.tr("&Dedication:"), self.cb_dedicationValue)
self.highwayDedicationAttributeStack.setLayout(layout)
# set up network reference capture
geomLayout = QFormLayout()
self.btn_StartReference = QPushButton("Start")
self.btn_EndReference = QPushButton("End")
self.btn_StartReference.clicked.connect(self.getLinkReferenceFirst)
self.btn_EndReference.clicked.connect(self.getLinkReference)
geomLayout.addRow(self.tr("&Highway Dedication Start:"),
self.btn_StartReference)
geomLayout.addRow(self.tr("&Highway Dedication End:"),
self.btn_EndReference)
self.highwayDedicationGeometryStack.setLayout(geomLayout)
# create relevant features
"""
def createButtonsWithTabs(self, reclassificationDict):
"""
Specific method to create buttons with tabs
reclassificationDict: dictionary used to create the buttons
"""
gridLayout = QGridLayout()
tabWidget = QTabWidget()
tabWidget.setTabPosition(QTabWidget.West)
gridLayout.addWidget(tabWidget)
self.scrollArea.setWidget(tabWidget)
propertyDict = dict()
for category in list(reclassificationDict.keys()):
if category in ['version', 'uiParameterJsonDict']:
continue
sortedButtonNames = []
formLayout = QFormLayout()
scrollArea = self.createWidgetWithTabs(formLayout)
tabWidget.addTab(scrollArea, category)
for edgvClass in list(reclassificationDict[category].keys()):
for button in list(
reclassificationDict[category][edgvClass].keys()):
item = reclassificationDict[category][edgvClass][button]
propertyDict[button] = dict()
if isinstance(item, dict):
if 'buttonProp' in list(item.keys()):
propertyDict[button] = item['buttonProp']
sortedButtonNames.append(button)
sortedButtonNames.sort()
for button in sortedButtonNames:
pushButton = self.createButton(
button, propertyDict=propertyDict[button])
formLayout.addRow(pushButton)
class AuxLayerSelector(QWidget):
def __init__(self, parent=None):
super(AuxLayerSelector, self).__init__(parent)
self.layout = QFormLayout()
def setInitialState(self, initDict):
"""
Sets widget interface with initDict entries. Keys are labels and values are list of items for each combobox corresponding to each key.
"""
for key, value in list(initDict.items()):
label = QLabel(key)
widget = DsgCustomComboBox()
widget.addItems(value)
self.layout.addRow(label, widget)
self.setLayout(self.layout)
def resetLayout(self):
"""
Resets current widget layout.
"""
self.layout = QFormLayout()
self.setLayout(self.layout)
def getParameters(self):
"""
Gets current values fom each widget as a dictionary.
"""
returnDict = dict()
for i in range(self.layout.rowCount()):
key = self.layout.itemAt(i, QFormLayout.LabelRole).text()
value = self.layout.itemAt(i, QFormLayout.FieldRole).currentText()
returnDict[key] = value
return returnDict
def make_layout():
"""
Create the inner layout for the widget. For new style forms this is a vbox layout so everything
is stacked on top of each other in a simple list.
:return:
"""
if newstyle:
return QVBoxLayout()
else:
layout = QFormLayout()
layout.setFieldGrowthPolicy(QFormLayout.AllNonFixedFieldsGrow)
return layout
def showAdvancedVectorDialog(self):
dlg = QDialog()
dlg.setObjectName('dbManagerAdvancedVectorDialog')
settings = QgsSettings()
dlg.restoreGeometry(settings.value("/DB_Manager/advancedAddDialog/geometry", QByteArray(), type=QByteArray))
layout = QFormLayout()
dlg.setLayout(layout)
dlg.setWindowTitle(self.tr('Add Layer {}').format(self.name))
geometryTypeComboBox = QComboBox()
geometryTypeComboBox.addItem(self.tr('Point'), 'POINT')
geometryTypeComboBox.addItem(self.tr('Line'), 'LINESTRING')
geometryTypeComboBox.addItem(self.tr('Polygon'), 'POLYGON')
layout.addRow(self.tr('Geometry Type'), geometryTypeComboBox)
zCheckBox = QCheckBox(self.tr('With Z'))
mCheckBox = QCheckBox(self.tr('With M'))
layout.addRow(zCheckBox)
layout.addRow(mCheckBox)
crsSelector = QgsProjectionSelectionWidget()
crsSelector.setCrs(self.crs())
layout.addRow(self.tr('CRS'), crsSelector)
def selectedGeometryType():
geomType = geometryTypeComboBox.currentData()
if zCheckBox.isChecked():
geomType += 'Z'
if mCheckBox.isChecked():
geomType += 'M'
return geomType
def selectedCrs():
return crsSelector.crs()
addButton = QPushButton(self.tr('Load Layer'))
addButton.clicked.connect(lambda: self.addLayer(selectedGeometryType(), selectedCrs()))
btns = QDialogButtonBox(QDialogButtonBox.Cancel)
btns.addButton(addButton, QDialogButtonBox.ActionRole)
layout.addRow(btns)
addButton.clicked.connect(dlg.accept)
btns.accepted.connect(dlg.accept)
btns.rejected.connect(dlg.reject)
dlg.exec_()
settings = QgsSettings()
settings.setValue("/DB_Manager/advancedAddDialog/geometry", dlg.saveGeometry())
def __init__(self, fields, layerBox, parent=None, settings=None):
super(QDialog, self).__init__(parent)
self.setLayout(QFormLayout(self))
self.fields = {f: QgsFieldComboBox(parent=self) for f in fields}
self.settings = settings
for f in self.fields:
#qformlayout.addRow(const QString &labelText, QWidget *field)
self.layout().addRow(f, self.fields[f])
layerBox.layerChanged.connect(self.fields[f].setLayer)
self.fields[f].setLayer(layerBox.currentLayer())
if settings:
self.fields[f].fieldChanged.connect(self.saveSettings)
self.buttonBox = QDialogButtonBox(QDialogButtonBox.Ok
| QDialogButtonBox.Cancel,
parent=self)
self.layout().addRow(self.buttonBox)
self.layerBox = layerBox
if settings:
self.loadSettings()
def connect_features(self, source, target):
"""
Connects the source feature with the target feature.
@param source: A QgsPointLocator.Match object. Its foreign key will be updated.
A dialog will be opened which asks the user for which foreign key(s) he wants to update.
@param target: A QgsPointLocator.Match object. This feature will be used as link target.
Its obj_id attribute will be used as primary key.
"""
dlg = QDialog(self.iface.mainWindow())
dlg.setWindowTitle(self.tr('Select properties to connect'))
dlg.setLayout(QFormLayout())
properties = list()
for prop in self.network_element_sources[source.layer()]['fields']:
if 'filter' in prop.keys():
if not prop['filter'](source, target):
continue
cbx = QCheckBox(prop['name'])
cbx.setObjectName(prop['id'])
if 'is_checked' in prop.keys():
cbx.setChecked(prop['is_checked'](source, target))
properties.append(cbx)
dlg.layout().addWidget(cbx)
btn_box = QDialogButtonBox(
QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
dlg.layout().addWidget(btn_box)
btn_box.accepted.connect(dlg.accept)
btn_box.rejected.connect(dlg.reject)
source_feature = self.get_feature_for_match(source)
target_feature = self.get_feature_for_match(target)
if dlg.exec_():
for cbx in properties:
if cbx.isChecked():
source_feature[cbx.objectName()] = target_feature['obj_id']
if not source.layer().isEditable():
self.iface.messageBar().pushMessage('QGEP', self.tr('Layer "{layername}" is not in edit mode').format(
layername=source.layer().name()), Qgis.Warning, 5)
elif source.layer().updateFeature(source_feature):
self.iface.messageBar().pushMessage('QGEP',
self.tr('Connected {} to {}').format(
source_feature['identifier'],
target_feature['identifier']),
Qgis.Info, 5)
else:
self.iface.messageBar().pushMessage('QGEP',
self.tr(
'Error connecting features'),
Qgis.Warning, 5)
self.reset()
def __init__(self, title, data, parent=None):
QWidget.__init__(self, parent)
self.setWindowTitle("Geology log viewer")
formLayout = QFormLayout()
# id
titleW = QLineEdit(title, self)
titleW.setReadOnly(True)
formLayout.addRow("Description", titleW)
# the plot
layout = QVBoxLayout()
self.plot = PlotView(self)
layout.addLayout(formLayout)
layout.addWidget(self.plot)
self.setLayout(layout)
self.plot.setData(data)
self.resize(800, 600)
def __init__(self, parent, old_ids):
QDialog.__init__(self, parent)
self.old_ids = old_ids
main_lay = QVBoxLayout(self)
self.fra_id = QFrame(self)
fra_id_lay = QFormLayout(self.fra_id)
self.lbl_id = QLabel('New ID:')
self.txt_id = QLineEdit('')
fra_id_lay.addRow(self.lbl_id, self.txt_id)
self.lbl_desc = QLabel('Description:')
self.txt_desc = QLineEdit('')
fra_id_lay.addRow(self.lbl_desc, self.txt_desc)
self.fra_buttons = QFrame()
fra_buttons_lay = QHBoxLayout(self.fra_buttons)
self.btn_ok = QPushButton('OK')
self.btn_ok.clicked.connect(self.btn_ok_clicked)
self.btn_cancel = QPushButton('Cancel')
self.btn_cancel.clicked.connect(self.btn_cancel_clicked)
fra_buttons_lay.addWidget(self.btn_ok)
fra_buttons_lay.addWidget(self.btn_cancel)
main_lay.addWidget(self.fra_id)
main_lay.addWidget(self.fra_buttons)
self.new_id = None
self.description = None
def __init__(self, parent, params, old_diam=None):
QDialog.__init__(self, parent)
self.params = params
self.new_diameter = None
self.setWindowTitle(params.plug_in_name)
self.setModal(True)
main_lay = QVBoxLayout(self)
# Frame form
self.fra_form = QFrame(self)
fra_form_lay = QFormLayout(self.fra_form)
# Old diameter
self.lbl_diam_old = QLabel('Current diameter:') # TODO: softcode
self.txt_diam_old = QLineEdit()
self.txt_diam_old.setEnabled(False)
if old_diam is None:
old_diam = '-'
self.txt_diam_old.setText(str(old_diam))
# self.txt_diam_old.setReadOnly(True)
fra_form_lay.addRow(self.lbl_diam_old, self.txt_diam_old)
# New diameter
self.lbl_diameter = QLabel('New diameter:') # TODO: softcode
self.txt_diameter = QLineEdit()
self.txt_diameter.setValidator(RegExValidators.get_pos_decimals())
if self.params.new_diameter:
self.new_diameter = self.params.new_diameter
self.txt_diameter.setText(str(self.new_diameter))
fra_form_lay.addRow(self.lbl_diameter, self.txt_diameter)
# Buttons
self.buttons_form = QFrame(self)
buttons_form_lay = QHBoxLayout(self.buttons_form)
self.btn_ok = QPushButton('OK')
self.btn_cancel = QPushButton('Cancel')
self.btn_cancel.clicked.connect(self.btn_cancel_clicked)
self.btn_ok.clicked.connect(self.btn_ok_clicked)
buttons_form_lay.addWidget(self.btn_ok)
buttons_form_lay.addWidget(self.btn_cancel)
main_lay.addWidget(self.fra_form)
main_lay.addWidget(self.buttons_form)
def __init__(self, parent, params):
QDialog.__init__(self, parent)
self.parent = parent
self.params = params
self.setMinimumWidth(min_width)
# self.setMinimumHeight(min_height)
# Build dialog
self.setWindowTitle('Options - Report') # TODO: softcode
self.setWindowModality(QtCore.Qt.ApplicationModal)
self.fra_form = QFrame(self)
fra_form_lay = QFormLayout(self.fra_form)
fra_form_lay.setContentsMargins(10, 10, 10, 10)
self.lbl_status = QLabel('Hydraulic status:') # TODO: softocode
self.cbo_status = QComboBox()
fra_form_lay.addRow(self.lbl_status, self.cbo_status)
self.lbl_summary = QLabel('Summary') # TODO: softocode
self.cbo_summary = QComboBox()
fra_form_lay.addRow(self.lbl_summary, self.cbo_summary)
self.lbl_energy = QLabel('Energy') # TODO: softocode
self.cbo_energy = QComboBox()
fra_form_lay.addRow(self.lbl_energy, self.cbo_energy)
self.lbl_nodes = QLabel('Nodes') # TODO: softocode
self.cbo_nodes = QComboBox()
fra_form_lay.addRow(self.lbl_nodes, self.cbo_nodes)
self.lbl_links = QLabel('Links') # TODO: softocode
self.cbo_links = QComboBox()
fra_form_lay.addRow(self.lbl_links, self.cbo_links)
# Buttons
self.fra_buttons = QFrame(self)
fra_buttons_lay = QHBoxLayout(self.fra_buttons)
self.btn_Ok = QPushButton('OK')
self.btn_Cancel = QPushButton('Cancel')
fra_buttons_lay.addWidget(self.btn_Ok)
fra_buttons_lay.addWidget(self.btn_Cancel)
# Add to main
fra_main_lay = QVBoxLayout(self)
fra_main_lay.setContentsMargins(0, 0, 0, 0)
fra_main_lay.addWidget(self.fra_form)
fra_main_lay.addWidget(self.fra_buttons)
self.setup()
def __init__(self, parent, params):
QDialog.__init__(self, parent)
self.parent = parent
self.params = params
self.setMinimumWidth(min_width)
# self.setMinimumHeight(min_height)
# Build dialog
self.setWindowTitle('Options - Energy') # TODO: softcode
self.setWindowModality(QtCore.Qt.ApplicationModal)
self.fra_form = QFrame(self)
fra_form_lay = QFormLayout(self.fra_form)
fra_form_lay.setContentsMargins(10, 10, 10, 10)
self.lbl_pump_efficiency = QLabel('Pump efficiency [%]:') # TODO: softocode
self.txt_pump_efficiency = QLineEdit()
fra_form_lay.addRow(self.lbl_pump_efficiency, self.txt_pump_efficiency)
self.lbl_energy_price = QLabel('Energy price/kwh:') # TODO: softocode
self.txt_energy_price = QLineEdit()
fra_form_lay.addRow(self.lbl_energy_price, self.txt_energy_price)
self.lbl_price_pattern = QLabel('Price pattern:') # TODO: softocode
self.txt_price_pattern = QLineEdit() # TODO: replace with dropdown
fra_form_lay.addRow(self.lbl_price_pattern, self.txt_price_pattern)
self.lbl_demand_charge = QLabel('Demand charge:') # TODO: softocode
self.txt_demand_charge = QLineEdit()
fra_form_lay.addRow(self.lbl_demand_charge, self.txt_demand_charge)
# Buttons
self.fra_buttons = QFrame(self)
fra_buttons_lay = QHBoxLayout(self.fra_buttons)
self.btn_Ok = QPushButton('OK')
self.btn_Cancel = QPushButton('Cancel')
fra_buttons_lay.addWidget(self.btn_Ok)
fra_buttons_lay.addWidget(self.btn_Cancel)
# Add to main
fra_main_lay = QVBoxLayout(self)
fra_main_lay.setContentsMargins(0, 0, 0, 0)
fra_main_lay.addWidget(self.fra_form)
fra_main_lay.addWidget(self.fra_buttons)
self.setup()
def __init__(self, parent, params):
QDialog.__init__(self, parent)
self.parent = parent
self.params = params
self.setMinimumWidth(min_width)
# Build dialog
self.setWindowTitle('Options - Times') # TODO: softcode
self.setWindowModality(QtCore.Qt.ApplicationModal)
self.fra_form = QFrame(self)
fra_form_lay = QFormLayout(self.fra_form)
fra_form_lay.setContentsMargins(10, 10, 10, 10)
self.lbl_units = QLabel('Units:') # TODO: softocode
self.cbo_units = QComboBox()
fra_form_lay.addRow(self.lbl_units, self.cbo_units)
self.lbl_duration = QLabel('Duration:') # TODO: softocode
self.txt_duration = QLineEdit()
fra_form_lay.addRow(self.lbl_duration, self.txt_duration)
self.lbl_hydraulic_timestep = QLabel('Hydraulic timestep:') # TODO: softocode
self.txt_hydraulic_timestep = QLineEdit()
fra_form_lay.addRow(self.lbl_hydraulic_timestep, self.txt_hydraulic_timestep)
self.lbl_quality_timestep = QLabel('Quality timestep:') # TODO: softocode
self.txt_quality_timestep = QLineEdit()
fra_form_lay.addRow(self.lbl_quality_timestep, self.txt_quality_timestep)
self.lbl_rule_timestep = QLabel('Rule timestep:') # TODO: softocode
self.txt_rule_timestep = QLineEdit()
fra_form_lay.addRow(self.lbl_rule_timestep, self.txt_rule_timestep)
self.lbl_pattern_timestep = QLabel('Pattern timestep:') # TODO: softocode
self.txt_pattern_timestep = QLineEdit()
fra_form_lay.addRow(self.lbl_pattern_timestep, self.txt_pattern_timestep)
self.lbl_pattern_start = QLabel('Pattern start:') # TODO: softocode
self.txt_pattern_start = QLineEdit()
fra_form_lay.addRow(self.lbl_pattern_start, self.txt_pattern_start)
self.lbl_report_timestep = QLabel('Report timestep:') # TODO: softocode
self.txt_report_timestep = QLineEdit()
fra_form_lay.addRow(self.lbl_report_timestep, self.txt_report_timestep)
self.lbl_report_start = QLabel('Report start:') # TODO: softocode
self.txt_report_start = QLineEdit()
fra_form_lay.addRow(self.lbl_report_start, self.txt_report_start)
self.lbl_clock_time_start = QLabel('Clock start time:') # TODO: softocode
self.txt_clock_time_start = QLineEdit()
fra_form_lay.addRow(self.lbl_clock_time_start, self.txt_clock_time_start)
self.lbl_statistic = QLabel('Statistic:') # TODO: softocode
self.cbo_statistic = QComboBox()
fra_form_lay.addRow(self.lbl_statistic, self.cbo_statistic)
# Buttons
self.fra_buttons = QFrame(self)
fra_buttons_lay = QHBoxLayout(self.fra_buttons)
self.btn_Ok = QPushButton('OK')
self.btn_Cancel = QPushButton('Cancel')
fra_buttons_lay.addWidget(self.btn_Ok)
fra_buttons_lay.addWidget(self.btn_Cancel)
# Add to main
fra_main_lay = QVBoxLayout(self)
fra_main_lay.setContentsMargins(0, 0, 0, 0)
fra_main_lay.addWidget(self.fra_form)
fra_main_lay.addWidget(self.fra_buttons)
self.setup()
def __init__(self, parent, params):
QDialog.__init__(self, parent)
self.parent = parent
self.params = params
self.setMinimumWidth(min_width)
# Build dialog
self.setWindowTitle('Options - Reactions') # TODO: softcode
self.setWindowModality(QtCore.Qt.ApplicationModal)
self.fra_form = QFrame(self)
fra_form_lay = QFormLayout(self.fra_form)
fra_form_lay.setContentsMargins(10, 10, 10, 10)
self.lbl_bulk_reaction_order = QLabel('Bulk reaction order:') # TODO: softocode
self.txt_bulk_reaction_order = QLineEdit('1')
fra_form_lay.addRow(self.lbl_bulk_reaction_order, self.txt_bulk_reaction_order)
self.lbl_tank_reaction_order = QLabel('Tank reaction order:') # TODO: softocode
self.txt_tank_reaction_order = QLineEdit('1')
fra_form_lay.addRow(self.lbl_tank_reaction_order, self.txt_tank_reaction_order)
self.lbl_wall_reaction_order = QLabel('Wall reaction order:') # TODO: softocode
self.txt_wall_reaction_order = QLineEdit('1')
fra_form_lay.addRow(self.lbl_wall_reaction_order, self.txt_wall_reaction_order)
self.lbl_global_bulk_coeff = QLabel('Global bulk coeff.:') # TODO: softocode
self.txt_global_bulk_coeff = QLineEdit('1')
fra_form_lay.addRow(self.lbl_global_bulk_coeff, self.txt_global_bulk_coeff)
self.lbl_global_wall_coeff = QLabel('Global wall coeff.:') # TODO: softocode
self.txt_global_wall_coeff = QLineEdit('0')
fra_form_lay.addRow(self.lbl_global_wall_coeff, self.txt_global_wall_coeff)
self.lbl_limiting_conc = QLabel('Limiting concentration:') # TODO: softocode
self.txt_limiting_conc = QLineEdit('0')
fra_form_lay.addRow(self.lbl_limiting_conc, self.txt_limiting_conc)
self.lbl_wall_coeff_corr = QLabel('Wall coeff. correlation:') # TODO: softocode
self.txt_wall_coeff_corr = QLineEdit('0')
fra_form_lay.addRow(self.lbl_wall_coeff_corr, self.txt_wall_coeff_corr)
# Buttons
self.fra_buttons = QFrame(self)
fra_buttons_lay = QHBoxLayout(self.fra_buttons)
self.btn_Ok = QPushButton('OK')
self.btn_Cancel = QPushButton('Cancel')
fra_buttons_lay.addWidget(self.btn_Ok)
fra_buttons_lay.addWidget(self.btn_Cancel)
# Add to main
fra_main_lay = QVBoxLayout(self)
fra_main_lay.setContentsMargins(0, 0, 0, 0)
fra_main_lay.addWidget(self.fra_form)
fra_main_lay.addWidget(self.fra_buttons)
self.setup()
def __init__(self, parent, params):
QDialog.__init__(self, parent)
self.parent = parent
self.params = params
self.setMinimumWidth(min_width)
# self.setMinimumHeight(min_height)
# Build dialog
self.setWindowTitle('Options - Quality') # TODO: softcode
self.setWindowModality(QtCore.Qt.ApplicationModal)
self.fra_form = QFrame(self)
fra_form_lay = QFormLayout(self.fra_form)
fra_form_lay.setContentsMargins(10, 10, 10, 10)
self.lbl_parameter = QLabel('Parameter:') # TODO: softocode
self.cbo_parameter = QComboBox()
fra_form_lay.addRow(self.lbl_parameter, self.cbo_parameter)
self.lbl_mass_units = QLabel('Mass units:') # TODO: softocode
self.cbo_mass_units = QComboBox()
fra_form_lay.addRow(self.lbl_mass_units, self.cbo_mass_units)
self.lbl_diffusivity = QLabel('Relative diffusivity:') # TODO: softocode
self.txt_diffusivity = QLineEdit()
fra_form_lay.addRow(self.lbl_diffusivity, self.txt_diffusivity)
self.lbl_trace_node = QLabel('Trace node:') # TODO: softocode
self.txt_trace_node = QLineEdit()
fra_form_lay.addRow(self.lbl_trace_node, self.txt_trace_node)
self.lbl_quality_tol = QLabel('Quality tolerance:') # TODO: softocode
self.txt_quality_tol = QLineEdit()
fra_form_lay.addRow(self.lbl_quality_tol, self.txt_quality_tol)
# Buttons
self.fra_buttons = QFrame(self)
fra_buttons_lay = QHBoxLayout(self.fra_buttons)
self.btn_Ok = QPushButton('OK')
self.btn_Cancel = QPushButton('Cancel')
fra_buttons_lay.addWidget(self.btn_Ok)
fra_buttons_lay.addWidget(self.btn_Cancel)
# Add to main
fra_main_lay = QVBoxLayout(self)
fra_main_lay.setContentsMargins(0, 0, 0, 0)
fra_main_lay.addWidget(self.fra_form)
fra_main_lay.addWidget(self.fra_buttons)
self.setup()
def __init__(self, parent, params, new_proj=False):
QDialog.__init__(self, parent)
self.parent = parent
self.params = params
self.new_proj = new_proj
self.setMinimumWidth(min_width)
# self.setMinimumHeight(min_height)
# Build dialog
self.setWindowTitle('Options - Hydraulics') # TODO: softcode
self.setWindowModality(QtCore.Qt.ApplicationModal)
self.fra_form = QFrame(self)
fra_form_lay = QFormLayout(self.fra_form)
fra_form_lay.setContentsMargins(10, 10, 10, 10)
self.lbl_units = QLabel('Units system:') # TODO: softocode
self.cbo_units = QComboBox()
fra_form_lay.addRow(self.lbl_units, self.cbo_units)
self.lbl_flow_units = QLabel('Flow units:') # TODO: softocode
self.cbo_flow_units = QComboBox()
fra_form_lay.addRow(self.lbl_flow_units, self.cbo_flow_units)
self.lbl_headloss = QLabel('Head loss:') # TODO: softocode
self.cbo_headloss = QComboBox()
fra_form_lay.addRow(self.lbl_headloss, self.cbo_headloss)
self.chk_hydraulics = QCheckBox('Hydraulics:') # TODO: softcode
self.cbo_hydraulics = QComboBox()
fra_form_lay.addRow(self.chk_hydraulics, self.cbo_hydraulics)
self.txt_hydraulics_file = QLineEdit()
fra_form_lay.addRow(None, self.txt_hydraulics_file)
self.btn_hydraulics_file = QPushButton('File...') # TODO: softcode
fra_form_lay.addRow(None, self.btn_hydraulics_file)
self.lbl_viscosity = QLabel('Viscosity:') # TODO: softocode
self.txt_viscosity = QLineEdit()
fra_form_lay.addRow(self.lbl_viscosity, self.txt_viscosity)
# self.lbl_diffusivity = QLabel('Diffusivity:') # TODO: softocode
# self.txt_diffusivity = QLineEdit()
# fra_form_lay.addRow(self.lbl_diffusivity, self.txt_diffusivity)
self.lbl_spec_gravity = QLabel('Specific gravity:') # TODO: softocode
self.txt_spec_gravity = QLineEdit()
fra_form_lay.addRow(self.lbl_spec_gravity, self.txt_spec_gravity)
self.lbl_max_trials = QLabel('Max trials:') # TODO: softocode
self.txt_max_trials = QLineEdit()
fra_form_lay.addRow(self.lbl_max_trials, self.txt_max_trials)
self.lbl_accuracy = QLabel('Accuracy:') # TODO: softocode
self.txt_accuracy = QLineEdit()
fra_form_lay.addRow(self.lbl_accuracy, self.txt_accuracy)
self.lbl_unbalanced = QLabel('Unbalanced:') # TODO: softcode
self.fra_unbalanced = QFrame(self)
fra_unbalanced_lay = QHBoxLayout(self.fra_unbalanced)
fra_unbalanced_lay.setContentsMargins(0, 0, 0, 0)
self.cbo_unbalanced = QComboBox()
self.txt_unbalanced = QLineEdit()
fra_unbalanced_lay.addWidget(self.cbo_unbalanced)
fra_unbalanced_lay.addWidget(self.txt_unbalanced)
fra_form_lay.addRow(self.lbl_unbalanced, self.fra_unbalanced)
self.lbl_pattern = QLabel('Pattern:') # TODO: softocode
self.cbo_pattern = QComboBox()
fra_form_lay.addRow(self.lbl_pattern, self.cbo_pattern)
self.lbl_demand_mult = QLabel('Demand multiplier:') # TODO: softocode
self.txt_demand_mult = QLineEdit()
fra_form_lay.addRow(self.lbl_demand_mult, self.txt_demand_mult)
self.lbl_emitter_exp = QLabel('Emitter exponent:') # TODO: softocode
self.txt_emitter_exp = QLineEdit()
fra_form_lay.addRow(self.lbl_emitter_exp, self.txt_emitter_exp)
self.lbl_tolerance = QLabel('Tolerance:') # TODO: softocode
self.txt_tolerance = QLineEdit()
fra_form_lay.addRow(self.lbl_tolerance, self.txt_tolerance)
# Buttons
self.fra_buttons = QFrame(self)
fra_buttons_lay = QHBoxLayout(self.fra_buttons)
self.btn_Cancel = QPushButton('Cancel')
self.btn_Ok = QPushButton('OK')
fra_buttons_lay.addWidget(self.btn_Ok)
fra_buttons_lay.addWidget(self.btn_Cancel)
# Add to main
fra_main_lay = QVBoxLayout(self)
fra_main_lay.setContentsMargins(0, 0, 0, 0)
fra_main_lay.addWidget(self.fra_form)
fra_main_lay.addWidget(self.fra_buttons)
self.setup()
def __init__(self, parent=None):
super(AuxLayerSelector, self).__init__(parent)
self.layout = QFormLayout()
def __init__(self, iface, parent, params):
QDialog.__init__(self, parent)
self.iface = iface
self.parent = parent
self.params = params
self.output_reader = None
self.tool = None
self.element_ids_nodes = None
self.element_ids_links = None
self.nodes_lay = None
self.links_lay = None
self.setWindowTitle(Parameters.plug_in_name)
# Selection changed listeners
self.params.junctions_vlay.selectionChanged.connect(self.feature_sel_changed)
self.params.reservoirs_vlay.selectionChanged.connect(self.feature_sel_changed)
self.params.tanks_vlay.selectionChanged.connect(self.feature_sel_changed)
self.params.pipes_vlay.selectionChanged.connect(self.feature_sel_changed)
self.params.pumps_vlay.selectionChanged.connect(self.feature_sel_changed)
self.params.valves_vlay.selectionChanged.connect(self.feature_sel_changed)
# self.setMinimumWidth(min_width)
# self.setMinimumHeight(min_height)
fra_main_lay = QVBoxLayout(self)
self.fra_out_file = QFrame(self)
fra_out_file_lay = QHBoxLayout(self.fra_out_file)
self.lbl_out_file = QLabel('Simulation output file:')
self.txt_out_file = QLineEdit('')
self.txt_out_file.setReadOnly(True)
self.btn_out_file = QToolButton()
self.btn_out_file.setText('...')
self.btn_out_file.clicked.connect(self.btn_out_file_clicked)
fra_out_file_lay.addWidget(self.lbl_out_file)
fra_out_file_lay.addWidget(self.txt_out_file)
fra_out_file_lay.addWidget(self.btn_out_file)
self.tab_widget = QTabWidget(self)
# Graphs tab ---------------------------------------------------------------------------------------------------
self.tab_graphs = QWidget()
tab_graphs_lay = QHBoxLayout(self.tab_graphs)
# Left frame
self.fra_graphs_left = QFrame()
self.fra_graphs_left.setMaximumWidth(100)
fra_graphs_left_lay = QVBoxLayout(self.fra_graphs_left)
self.btn_sel_element = QPushButton('Pick')
self.btn_sel_element.clicked.connect(self.btn_sel_element_clicked)
fra_graphs_left_lay.addWidget(self.btn_sel_element)
# Nodes
self.grb_nodes = QGroupBox(u'Nodes')
lay_grb_nodes = QVBoxLayout(self.grb_nodes)
self.chk_node_demand = QCheckBox('Demand')
lay_grb_nodes.addWidget(self.chk_node_demand)
self.chk_node_head = QCheckBox('Head')
lay_grb_nodes.addWidget(self.chk_node_head)
self.chk_node_pressure = QCheckBox('Pressure')
lay_grb_nodes.addWidget(self.chk_node_pressure)
self.chk_node_quality = QCheckBox('Quality')
lay_grb_nodes.addWidget(self.chk_node_quality)
fra_graphs_left_lay.addWidget(self.grb_nodes)
# Links
self.grb_links = QGroupBox(u'Links')
lay_grb_links = QVBoxLayout(self.grb_links)
self.chk_link_flow = QCheckBox('Flow')
lay_grb_links.addWidget(self.chk_link_flow)
self.chk_link_velocity = QCheckBox('Velocity')
lay_grb_links.addWidget(self.chk_link_velocity)
self.chk_link_headloss = QCheckBox('Headloss')
lay_grb_links.addWidget(self.chk_link_headloss)
self.chk_link_quality = QCheckBox('Quality')
lay_grb_links.addWidget(self.chk_link_quality)
fra_graphs_left_lay.addWidget(self.grb_links)
self.btn_draw_graph = QPushButton('Draw')
self.btn_draw_graph.clicked.connect(self.draw_graphs)
fra_graphs_left_lay.addWidget(self.btn_draw_graph)
self.spacer = QSpacerItem(20, 40, QSizePolicy.Minimum, QSizePolicy.Expanding)
fra_graphs_left_lay.addItem(self.spacer)
tab_graphs_lay.addWidget(self.fra_graphs_left)
# Right frame
self.fra_graphs_right = QFrame()
fra_graphs_right_lay = QVBoxLayout(self.fra_graphs_right)
fra_graphs_right_lay.setContentsMargins(0, 0, 0, 0)
self.static_canvas = StaticMplCanvas(self.fra_graphs_right, width=5, height=4, dpi=100)
fra_graphs_right_lay.addWidget(self.static_canvas)
tab_graphs_lay.addWidget(self.fra_graphs_right)
# lay.addWidget(self.button)
self.tab_widget.addTab(self.tab_graphs, 'Graphs')
# Maps tab -----------------------------------------------------------------------------------------------------
self.tab_maps = QWidget()
tab_maps_lay = QHBoxLayout(self.tab_maps)
# Left frame
self.fra_maps_left = QFrame()
self.fra_maps_left.setMaximumWidth(200)
fra_maps_left_lay = QVBoxLayout(self.fra_maps_left)
self.grb_maps = QGroupBox(u'Variable')
grb_maps_lay = QVBoxLayout(self.grb_maps)
self.rad_maps_node_demand = QRadioButton(u'Node demand')
grb_maps_lay.addWidget(self.rad_maps_node_demand)
self.rad_maps_node_head = QRadioButton(u'Node head')
grb_maps_lay.addWidget(self.rad_maps_node_head)
self.rad_maps_node_pressure = QRadioButton(u'Node pressure')
grb_maps_lay.addWidget(self.rad_maps_node_pressure)
self.rad_maps_node_quality = QRadioButton(u'Node quality')
grb_maps_lay.addWidget(self.rad_maps_node_quality)
self.rad_maps_link_flow = QRadioButton(u'Link flow')
grb_maps_lay.addWidget(self.rad_maps_link_flow)
self.rad_maps_link_velocity = QRadioButton(u'Link velocity')
grb_maps_lay.addWidget(self.rad_maps_link_velocity)
self.rad_maps_link_headloss = QRadioButton(u'Link headloss')
grb_maps_lay.addWidget(self.rad_maps_link_headloss)
self.rad_maps_link_quality = QRadioButton(u'Link quality')
grb_maps_lay.addWidget(self.rad_maps_link_quality)
fra_maps_left_lay.addWidget(self.grb_maps)
fra_maps_left_lay.addItem(self.spacer)
tab_maps_lay.addWidget(self.fra_maps_left)
# Right maps frame
self.fra_maps_right = QFrame()
fra_maps_right_lay = QVBoxLayout(self.fra_maps_right)
self.fra_maps_right_time = QFrame()
fra_maps_right_time_lay = QFormLayout(self.fra_maps_right_time)
self.lbl_map_times = QLabel(u'Period [h]:')
self.cbo_map_times = QComboBox()
fra_maps_right_time_lay.addRow(self.lbl_map_times, self.cbo_map_times)
fra_maps_right_lay.addWidget(self.fra_maps_right_time)
self.btn_draw_map = QPushButton(u'Draw map')
self.btn_draw_map.clicked.connect(self.draw_maps)
fra_maps_right_lay.addWidget(self.btn_draw_map)
fra_maps_right_lay.addItem(self.spacer)
tab_maps_lay.addWidget(self.fra_maps_right)
self.tab_widget.addTab(self.tab_maps, 'Maps')
# # Add to main
fra_main_lay.addWidget(self.fra_out_file)
fra_main_lay.addWidget(self.tab_widget)
self.setup()
self.initialize()
# self.read_outputs()
# Set size
self.setMinimumWidth(self.tab_graphs.width())
self.setMinimumHeight(self.tab_graphs.height())
def resetLayout(self):
"""
Resets current widget layout.
"""
self.layout = QFormLayout()
self.setLayout(self.layout)
def generateAccessRestrictionForm(self):
QgsMessageLog.logMessage(
"In generateAccessRestrictionForm::generateForm ... ",
tag="TOMs panel")
layout = QFormLayout()
#groupBox = QGroupBox("Restriction Attributes", self.currDialog)
#formLayout = QFormLayout()
# Add access restriction type
self.cb_accessRestrictionType = QComboBox(self)
enumList = self.getEnumList('AccessRestrictionValue')
self.cb_accessRestrictionType.addItems(enumList)
layout.addRow(self.tr("&Access Restriction Type:"),
self.cb_accessRestrictionType)
# Add vehicle exemption
self.cb_accessRestrictionVehicleExemptions = QComboBox(self)
enumList = self.getTableList('"moving_traffic"."vehicleQualifiers"')
self.cb_accessRestrictionVehicleExemptions.addItems(enumList)
layout.addRow(self.tr("&Vehicle exemptions:"),
self.cb_accessRestrictionVehicleExemptions)
# Add vehicle inclusions
self.cb_accessRestrictionVehicleInclusions = QComboBox(self)
enumList = self.getTableList('"moving_traffic"."vehicleQualifiers"')
self.cb_accessRestrictionVehicleInclusions.addItems(enumList)
layout.addRow(self.tr("&Vehicle inclusions:"),
self.cb_accessRestrictionVehicleInclusions)
# add time intervals
self.cb_accessRestrictionTimePeriods = QComboBox(self)
enumList = self.getTableList('"moving_traffic"."TimePeriods"')
self.cb_accessRestrictionTimePeriods.addItems(enumList)
layout.addRow(self.tr("&Time Period:"),
self.cb_accessRestrictionTimePeriods)
# add traffic sign
"""self.cb_trafficSign = QComboBox(self)
enumList = self.getTableList('Signs')
self.cb_timePeriods.addItems(enumList)
layout.addRow(self.tr("&Traffic Sign:"), self.cb_timePeriods)"""
self.accessRestrictionAttributeStack.setLayout(layout)
# set up network reference capture
geomLayout = QFormLayout()
self.btn_PointReference = QPushButton("Location")
self.btn_PointReference.clicked.connect(self.getPointReference)
geomLayout.addRow(self.tr("&Access Restriction Location:"),
self.btn_PointReference)
# add link direction
self.cb_accessRestrictionLinkDirectionValue = QComboBox(self)
enumList = self.getEnumList('LinkDirectionValue')
self.cb_accessRestrictionLinkDirectionValue.addItems(enumList)
geomLayout.addRow(self.tr("&Applicable link direction:"),
self.cb_accessRestrictionLinkDirectionValue)
self.accessRestrictionGeometryStack.setLayout(geomLayout)
# create relevant features
"""
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 generateTurnRestrictionForm(self):
QgsMessageLog.logMessage(
"In generateTurnRestrictionForm::generateForm ... ",
tag="TOMs panel")
layout = QFormLayout()
# Add turn restriction type
self.cb_turnRestrictionType = QComboBox(self)
enumList = self.getEnumList('TurnRestrictionValue')
self.cb_turnRestrictionType.addItems(enumList)
layout.addRow(self.tr("&Turn Restriction Type:"),
self.cb_turnRestrictionType)
# Add vehicle exemption
self.cb_turnRestrictionVehicleExemptions = QComboBox(self)
enumList = self.getTableList('"moving_traffic"."vehicleQualifiers"')
self.cb_turnRestrictionVehicleExemptions.addItems(enumList)
layout.addRow(self.tr("&Vehicle exemptions:"),
self.cb_turnRestrictionVehicleExemptions)
# Add vehicle inclusions
self.cb_turnRestrictionVehicleInclusions = QComboBox(self)
enumList = self.getTableList('"moving_traffic"."vehicleQualifiers"')
self.cb_turnRestrictionVehicleInclusions.addItems(enumList)
layout.addRow(self.tr("&Vehicle inclusions:"),
self.cb_turnRestrictionVehicleInclusions)
# add time intervals
self.cb_turnRestrictionTimePeriods = QComboBox(self)
enumList = self.getTableList('"moving_traffic"."TimePeriods"')
self.cb_turnRestrictionTimePeriods.addItems(enumList)
layout.addRow(self.tr("&Time Period:"),
self.cb_turnRestrictionTimePeriods)
self.turnRestrictionAttributeStack.setLayout(layout)
# set up network reference capture
geomLayout = QFormLayout()
self.btn_StartReference = QPushButton("Start")
self.btn_EndReference = QPushButton("End")
self.btn_StartReference.clicked.connect(self.getLinkReferenceFirst)
self.btn_EndReference.clicked.connect(self.getLinkReference)
geomLayout.addRow(self.tr("&Turn Restriction Start:"),
self.btn_StartReference)
geomLayout.addRow(self.tr("&Turn Restriction End:"),
self.btn_EndReference)
self.turnRestrictionGeometryStack.setLayout(geomLayout)
# create relevant features
"""
class QvFormNovaMapificacio(QvFormBaseMapificacio):
def __init__(self, llegenda, amplada=500, mapificacio=None, simple=True):
super().__init__(llegenda, amplada)
self.fCSV = mapificacio
self.simple = simple
self.taulaMostra = None
self.setWindowTitle('Afegir capa amb mapa simbòlic')
self.layout = QVBoxLayout()
self.layout.setSpacing(14)
self.setLayout(self.layout)
if self.fCSV is None:
self.arxiu = QgsFileWidget()
self.arxiu.setStorageMode(QgsFileWidget.GetFile)
self.arxiu.setDialogTitle('Selecciona fitxer de dades…')
self.arxiu.setDefaultRoot(RUTA_LOCAL)
self.arxiu.setFilter('Arxius CSV (*.csv)')
self.arxiu.setSelectedFilter('Arxius CSV (*.csv)')
self.arxiu.lineEdit().setReadOnly(True)
self.arxiu.fileChanged.connect(self.arxiuSeleccionat)
self.zona = QComboBox(self)
self.zona.setEditable(False)
self.zona.addItem('Selecciona zona…')
self.zona.currentIndexChanged.connect(self.canviaZona)
self.mapa = QComboBox(self)
self.mapa.setEditable(False)
self.mapa.setIconSize(QSize(126, 126))
self.mapa.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Expanding)
self.mapa.setSizeAdjustPolicy(QComboBox.AdjustToContents)
self.mapa.addItem(QIcon(os.path.join(imatgesDir, 'Àrees.PNG')), 'Àrees')
self.mapa.addItem(QIcon(os.path.join(imatgesDir, 'Cercles.PNG')), 'Cercles')
self.capa = QLineEdit(self)
self.capa.setMaxLength(40)
self.tipus = QComboBox(self)
self.tipus.setEditable(False)
self.tipus.addItem('Selecciona tipus…')
self.tipus.addItems(mv.MAP_AGREGACIO.keys())
self.tipus.currentIndexChanged.connect(self.canviaTipus)
self.distribucio = QComboBox(self)
self.distribucio.setEditable(False)
self.distribucio.addItem(next(iter(mv.MAP_DISTRIBUCIO.keys())))
self.calcul = QvComboBoxCamps(self)
self.filtre = QvComboBoxCamps(self, multiple=True)
self.color = QComboBox(self)
self.color.setEditable(False)
self.comboColors(self.color)
self.metode = QComboBox(self)
self.metode.setEditable(False)
self.metode.addItems(mv.MAP_METODES.keys())
self.intervals = QSpinBox(self)
self.intervals.setMinimum(2)
self.intervals.setMaximum(mv.MAP_MAX_CATEGORIES)
self.intervals.setSingleStep(1)
self.intervals.setValue(4)
self.intervals.setSuffix(" (depèn del mètode)")
# self.intervals.valueChanged.connect(self.deselectValue)
self.bTaula = QPushButton('Veure arxiu')
self.bTaula.setEnabled(False)
self.bTaula.clicked.connect(self.veureArxiu)
self.buttons = QDialogButtonBox()
self.buttons.addButton(QDialogButtonBox.Ok)
self.buttons.accepted.connect(self.accept)
self.buttons.addButton(QDialogButtonBox.Cancel)
self.buttons.rejected.connect(self.cancel)
self.buttons.addButton(self.bTaula, QDialogButtonBox.ResetRole)
self.gDades = QGroupBox('Agregació de dades')
self.lDades = QFormLayout()
self.lDades.setSpacing(14)
self.gDades.setLayout(self.lDades)
if self.fCSV is None:
self.lDades.addRow('Arxiu de dades:', self.arxiu)
self.lDades.addRow('Zona:', self.zona)
self.lDades.addRow("Tipus d'agregació:", self.tipus)
self.lDades.addRow('Camp de càlcul:', self.calcul)
if self.simple:
self.filtre.setVisible(False)
self.distribucio.setVisible(False)
else:
self.lDades.addRow('Filtre:', self.filtre)
self.lDades.addRow('Distribució:', self.distribucio)
self.gMapa = QGroupBox('Definició del mapa simbòlic')
self.lMapa = QFormLayout()
self.lMapa.setSpacing(14)
self.gMapa.setLayout(self.lMapa)
self.lMapa.addRow('Nom de capa:', self.capa)
self.lMapa.addRow('Tipus de mapa:', self.mapa)
self.gSimb = QGroupBox('Simbologia del mapa')
self.lSimb = QFormLayout()
self.lSimb.setSpacing(14)
self.gSimb.setLayout(self.lSimb)
self.lSimb.addRow('Color base:', self.color)
self.lSimb.addRow('Mètode classificació:', self.metode)
self.lSimb.addRow("Nombre d'intervals:", self.intervals)
self.layout.addWidget(self.gDades)
self.layout.addWidget(self.gMapa)
if self.simple:
self.gSimb.setVisible(False)
else:
self.layout.addWidget(self.gSimb)
self.layout.addWidget(self.buttons)
self.adjustSize()
self.nouArxiu()
def exec(self):
# La mapificación solo funciona si está instalado el módulo pandas
if PANDAS_ENABLED:
return super().exec()
else:
self.msgError(PANDAS_ERROR)
return QDialog.Rejected
@pyqtSlot()
def veureArxiu(self):
if self.taulaMostra is not None:
self.taulaMostra.show()
self.taulaMostra.activateWindow()
def campsDB(self, nom):
res = []
if nom != '':
fich = RUTA_DADES + mv.MAP_ZONES_DB
if os.path.isfile(fich):
conn = sqlite3.connect('file:' + fich + '?mode=ro', uri=True)
conn.row_factory = sqlite3.Row
c = conn.cursor()
c.execute('select * from ' + nom) # nom.split('.')[0])
row = c.fetchone()
# res = [i[0].upper() for i in c.description]
res = [i.upper() for i in row.keys()]
conn.close()
return res
def soloPrimerItem(self, combo):
combo.setCurrentIndex(0)
ultimo = combo.count() - 1
for n in range(ultimo, 0, -1):
combo.removeItem(n)
@pyqtSlot()
def canviaZona(self):
self.distribucio.setCurrentIndex(0)
self.soloPrimerItem(self.distribucio)
if self.zona.currentIndex() > 0:
z = self.zona.currentText()
campsZona = self.campsDB(mv.MAP_ZONES[z][1])
# Carga combo con distribuciones si el campo correspondiente está en la BBDD
for dist, campo in mv.MAP_DISTRIBUCIO.items():
if campo != '' and campo in campsZona:
self.distribucio.addItem(dist)
@pyqtSlot()
def canviaTipus(self):
if self.tipus.currentText() == 'Recompte':
self.calcul.setCurrentIndex(-1)
self.calcul.setEnabled(False)
else:
self.calcul.setEnabled(True)
def borrarArxiu(self):
if self.taulaMostra is not None:
self.taulaMostra.hide()
self.taulaMostra = None
self.bTaula.setEnabled(False)
self.tipus.setCurrentIndex(0)
self.soloPrimerItem(self.zona)
self.calcul.clear()
self.filtre.clear()
def nouArxiu(self):
if self.fCSV is None:
return
# Carga combo con zonas si el campo correspondiente está en el fichero CSV
num = 0
for zona, val in mv.MAP_ZONES.items():
if val[1] != '' and self.fCSV.prefixe + QvSqlite.getAlias(val[0]) in self.fCSV.camps:
self.zona.addItem(zona)
num = num + 1
# Comprobar si la extensión del mapa está limitada
if num > 0:
extensio = self.fCSV.testExtensioArxiu(mv.MAP_EXTENSIO)
if extensio: # Mapa limitado
self.comboDelete(self.zona, mv.MAP_TRUE_EXTENSIO)
else: # Mapa completo
self.comboDelete(self.zona, mv.MAP_FALSE_EXTENSIO)
# Ajustar combo de zonas
if num == 0:
self.msgInfo("El fitxer " + self.fCSV.fZones + " no té cap camp de zona")
if hasattr(self, 'arxiu'):
self.arxiu.lineEdit().clear()
self.arxiu.setFocus()
return
if num == 1:
self.zona.setCurrentIndex(1)
self.capa.setFocus()
else:
self.zona.setFocus()
self.taulaMostra = QvEditorCsv(self.fCSV.fZones, [], 'utf-8', self.fCSV.separador, self)
self.taulaMostra.setWindowTitle("Vista prèvia d'arxiu geocodificat")
self.taulaMostra.setReadOnly(True)
self.bTaula.setEnabled(True)
self.calcul.setItems(self.fCSV.camps, primer='')
self.filtre.setItems(self.fCSV.camps)
@pyqtSlot(str)
def arxiuSeleccionat(self, nom):
if nom == '':
return
self.borrarArxiu()
self.fCSV = QvMapificacio(nom)
self.nouArxiu()
def validaSortida(self, nom):
fSalida = self.fCSV.nomArxiuSortida(self.fCSV.netejaString(nom, True))
return self.msgSobreescriure(fSalida)
def valida(self):
ok = False
if hasattr(self, 'arxiu') and self.arxiu.filePath() == '':
self.msgInfo("S'ha de seleccionar un arxiu de dades")
self.arxiu.setFocus()
elif self.zona.currentIndex() <= 0:
self.msgInfo("S'ha de seleccionar una zona")
self.zona.setFocus()
elif self.capa.text().strip() == '':
self.msgInfo("S'ha de introduir un nom de capa")
self.capa.setFocus()
elif self.tipus.currentIndex() <= 0:
self.msgInfo("S'ha de seleccionar un tipus d'agregació")
self.tipus.setFocus()
elif self.calcul.currentText().strip() == '' and self.tipus.currentText() != 'Recompte':
self.msgInfo("S'ha de introduir un cálcul per fer l'agregació")
self.calcul.setFocus()
elif self.fCSV is None:
return self.msgInfo("No hi ha cap fitxer seleccionat")
elif not self.validaSortida(self.capa.text().strip()):
self.capa.setFocus()
else:
ok = True
return ok
def setRenderParams(self):
self.renderParams = QvMapRendererParams(self.mapa.currentText())
if self.simple:
self.renderParams.colorBase = mv.MAP_COLORS[self.renderParams.colorBase]
else:
self.renderParams.colorBase = mv.MAP_COLORS[self.color.currentText()]
if self.renderParams.colorContorn is None or self.renderParams.colorContorn == 'Base':
self.renderParams.colorContorn = self.renderParams.colorBase
else:
self.renderParams.colorContorn = mv.MAP_CONTORNS[self.renderParams.colorContorn]
if self.tipus.currentText().startswith('Recompte') and \
self.distribucio.currentText() == "Total":
self.renderParams.numDecimals = 0
else:
self.renderParams.numDecimals = 2
if self.renderParams.tipusMapa == 'Àrees':
self.renderParams.modeCategories = mv.MAP_METODES[self.metode.currentText()]
self.renderParams.numCategories = self.intervals.value()
if self.renderParams.tipusMapa == 'Cercles':
zona = self.zona.currentText()
if zona == 'Districte':
self.renderParams.increase = 8
elif zona == 'Barri':
self.renderParams.increase = 4
elif zona == 'Àrea estadística bàsica':
self.renderParams.increase = 3
elif zona == 'Secció censal':
self.renderParams.increase = 2
else:
self.renderParams.increase = 1
def procesa(self):
if self.taulaMostra is not None:
self.taulaMostra.hide()
self.setRenderParams()
ok = self.fCSV.agregacio(self.llegenda, self.capa.text().strip(),
self.zona.currentText(), self.tipus.currentText(),
self.renderParams,
campAgregat=self.calcul.currentText().strip(),
simple=self.simple,
filtre=self.filtre.currentText().strip(),
tipusDistribucio=self.distribucio.currentText(),
form=self)
if ok:
return ''
else:
return self.fCSV.msgError
def generateRestrictionForVehiclesForm(self):
QgsMessageLog.logMessage(
"In generateRestrictionForVehiclesForm::generateForm ... ",
tag="TOMs panel")
layout = QFormLayout()
# Add restriction for vehicles type
self.cb_restrictionForVehiclesType = QComboBox(self)
enumList = self.getEnumList('RestrictionTypeValue')
self.cb_restrictionForVehiclesType.addItems(enumList)
layout.addRow(self.tr("&Access Restriction Type:"),
self.cb_restrictionForVehiclesType)
# add measure
self.le_restrictionForVehiclesMeasure = QLineEdit()
self.le_restrictionForVehiclesMeasure.setValidator(
QDoubleValidator(0.99, 999.99, 2))
layout.addRow(self.tr("&Measure (in metric units):"),
self.le_restrictionForVehiclesMeasure)
# add measure
self.le_restrictionForVehiclesMeasure2 = QLineEdit()
self.le_restrictionForVehiclesMeasure2.setValidator(
QDoubleValidator(0.99, 999.99, 2))
layout.addRow(
self.tr("&Measure (in imperial units) [only if present]:"),
self.le_restrictionForVehiclesMeasure2)
# Add vehicle exemption
self.cb_restrictionForVehiclesVehicleExemptions = QComboBox(self)
enumList = self.getTableList('"moving_traffic"."vehicleQualifiers"')
self.cb_restrictionForVehiclesVehicleExemptions.addItems(enumList)
layout.addRow(self.tr("&Vehicle exemptions:"),
self.cb_restrictionForVehiclesVehicleExemptions)
# Add vehicle inclusions
self.cb_restrictionForVehiclesVehicleInclusions = QComboBox(self)
enumList = self.getTableList('"moving_traffic"."vehicleQualifiers"')
self.cb_restrictionForVehiclesVehicleInclusions.addItems(enumList)
layout.addRow(self.tr("&Vehicle inclusions:"),
self.cb_restrictionForVehiclesVehicleInclusions)
# add structure type
self.cb_restrictionForVehiclesStructureType = QComboBox(self)
enumList = self.getEnumList('StructureTypeValue')
self.cb_restrictionForVehiclesStructureType.addItems(enumList)
layout.addRow(self.tr("&Structure Type:"),
self.cb_restrictionForVehiclesStructureType)
# add traffic sign
"""self.cb_trafficSign = QComboBox(self)
enumList = self.getTableList('Signs')
self.cb_timePeriods.addItems(enumList)
layout.addRow(self.tr("&Traffic Sign:"), self.cb_timePeriods)"""
self.restrictionForVehiclesAttributeStack.setLayout(layout)
geomLayout = QFormLayout()
self.btn_PointReference = QPushButton("Location")
self.btn_PointReference.clicked.connect(self.getPointReference)
geomLayout.addRow(self.tr("&Restriction For Vehicle Location:"),
self.btn_PointReference)
# add link direction
self.cb_restrictionForVehiclesLinkDirectionValue = QComboBox(self)
enumList = self.getEnumList('LinkDirectionValue')
self.cb_restrictionForVehiclesLinkDirectionValue.addItems(enumList)
geomLayout.addRow(self.tr("&Applicable link direction:"),
self.cb_restrictionForVehiclesLinkDirectionValue)
self.restrictionForVehiclesGeometryStack.setLayout(geomLayout)
# create relevant features
"""
def __init__(self, llegenda, amplada=500, mapificacio=None, simple=True):
super().__init__(llegenda, amplada)
self.fCSV = mapificacio
self.simple = simple
self.taulaMostra = None
self.setWindowTitle('Afegir capa amb mapa simbòlic')
self.layout = QVBoxLayout()
self.layout.setSpacing(14)
self.setLayout(self.layout)
if self.fCSV is None:
self.arxiu = QgsFileWidget()
self.arxiu.setStorageMode(QgsFileWidget.GetFile)
self.arxiu.setDialogTitle('Selecciona fitxer de dades…')
self.arxiu.setDefaultRoot(RUTA_LOCAL)
self.arxiu.setFilter('Arxius CSV (*.csv)')
self.arxiu.setSelectedFilter('Arxius CSV (*.csv)')
self.arxiu.lineEdit().setReadOnly(True)
self.arxiu.fileChanged.connect(self.arxiuSeleccionat)
self.zona = QComboBox(self)
self.zona.setEditable(False)
self.zona.addItem('Selecciona zona…')
self.zona.currentIndexChanged.connect(self.canviaZona)
self.mapa = QComboBox(self)
self.mapa.setEditable(False)
self.mapa.setIconSize(QSize(126, 126))
self.mapa.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Expanding)
self.mapa.setSizeAdjustPolicy(QComboBox.AdjustToContents)
self.mapa.addItem(QIcon(os.path.join(imatgesDir, 'Àrees.PNG')), 'Àrees')
self.mapa.addItem(QIcon(os.path.join(imatgesDir, 'Cercles.PNG')), 'Cercles')
self.capa = QLineEdit(self)
self.capa.setMaxLength(40)
self.tipus = QComboBox(self)
self.tipus.setEditable(False)
self.tipus.addItem('Selecciona tipus…')
self.tipus.addItems(mv.MAP_AGREGACIO.keys())
self.tipus.currentIndexChanged.connect(self.canviaTipus)
self.distribucio = QComboBox(self)
self.distribucio.setEditable(False)
self.distribucio.addItem(next(iter(mv.MAP_DISTRIBUCIO.keys())))
self.calcul = QvComboBoxCamps(self)
self.filtre = QvComboBoxCamps(self, multiple=True)
self.color = QComboBox(self)
self.color.setEditable(False)
self.comboColors(self.color)
self.metode = QComboBox(self)
self.metode.setEditable(False)
self.metode.addItems(mv.MAP_METODES.keys())
self.intervals = QSpinBox(self)
self.intervals.setMinimum(2)
self.intervals.setMaximum(mv.MAP_MAX_CATEGORIES)
self.intervals.setSingleStep(1)
self.intervals.setValue(4)
self.intervals.setSuffix(" (depèn del mètode)")
# self.intervals.valueChanged.connect(self.deselectValue)
self.bTaula = QPushButton('Veure arxiu')
self.bTaula.setEnabled(False)
self.bTaula.clicked.connect(self.veureArxiu)
self.buttons = QDialogButtonBox()
self.buttons.addButton(QDialogButtonBox.Ok)
self.buttons.accepted.connect(self.accept)
self.buttons.addButton(QDialogButtonBox.Cancel)
self.buttons.rejected.connect(self.cancel)
self.buttons.addButton(self.bTaula, QDialogButtonBox.ResetRole)
self.gDades = QGroupBox('Agregació de dades')
self.lDades = QFormLayout()
self.lDades.setSpacing(14)
self.gDades.setLayout(self.lDades)
if self.fCSV is None:
self.lDades.addRow('Arxiu de dades:', self.arxiu)
self.lDades.addRow('Zona:', self.zona)
self.lDades.addRow("Tipus d'agregació:", self.tipus)
self.lDades.addRow('Camp de càlcul:', self.calcul)
if self.simple:
self.filtre.setVisible(False)
self.distribucio.setVisible(False)
else:
self.lDades.addRow('Filtre:', self.filtre)
self.lDades.addRow('Distribució:', self.distribucio)
self.gMapa = QGroupBox('Definició del mapa simbòlic')
self.lMapa = QFormLayout()
self.lMapa.setSpacing(14)
self.gMapa.setLayout(self.lMapa)
self.lMapa.addRow('Nom de capa:', self.capa)
self.lMapa.addRow('Tipus de mapa:', self.mapa)
self.gSimb = QGroupBox('Simbologia del mapa')
self.lSimb = QFormLayout()
self.lSimb.setSpacing(14)
self.gSimb.setLayout(self.lSimb)
self.lSimb.addRow('Color base:', self.color)
self.lSimb.addRow('Mètode classificació:', self.metode)
self.lSimb.addRow("Nombre d'intervals:", self.intervals)
self.layout.addWidget(self.gDades)
self.layout.addWidget(self.gMapa)
if self.simple:
self.gSimb.setVisible(False)
else:
self.layout.addWidget(self.gSimb)
self.layout.addWidget(self.buttons)
self.adjustSize()
self.nouArxiu()
def init_gui(self):
"""
"""
dlg_layout = QVBoxLayout()
params_layout = QVBoxLayout()
params_layout.setAlignment(Qt.AlignTop)
# Config files groupbox
self.config_files_groupbox = QgsCollapsibleGroupBox(
u"Fichier de configuration de l'arbre des ressources")
config_file_groupbox_layout = QFormLayout(self.config_files_groupbox)
# URL of the file
self.config_file_url_label = QLabel(u"URL du fichier", self)
self.config_file_url_edit = QLineEdit(self)
self.config_file_url_edit.editingFinished.connect(
self.config_file_url_changed)
config_file_groupbox_layout.addRow(self.config_file_url_label,
self.config_file_url_edit)
# Download the file at startup
self.download_cb = QCheckBox(
u"Télécharger le fichier à chaque lancement de QGIS", self)
self.download_cb.stateChanged.connect(self.download_cb_changed)
config_file_groupbox_layout.addRow(self.download_cb)
params_layout.addWidget(self.config_files_groupbox)
# Download the file now
self.download_now_label = QLabel(u"Télécharger le fichier maintenant",
self)
self.download_now_btnbox = QDialogButtonBox()
self.download_now_btnbox.setOrientation(Qt.Horizontal)
self.download_now_btnbox.setStandardButtons(QDialogButtonBox.Yes)
self.download_now_btnbox.button(QDialogButtonBox.Yes).clicked.connect(
self.download_file_now)
config_file_groupbox_layout.addRow(self.download_now_label,
self.download_now_btnbox)
# Content of the resource tree groupbox
self.resource_tree_groupbox = QgsCollapsibleGroupBox(
u"Contenu de l'arbre des ressources")
resource_tree_groupbox_layout = QFormLayout(
self.resource_tree_groupbox)
# Hide resources with a warn flag
self.hide_resources_with_warn_status_cb = QCheckBox(
u"Masquer les ressources en cours d'intégration", self)
self.hide_resources_with_warn_status_cb.stateChanged.connect(
self.hide_resources_with_warn_cb_changed)
resource_tree_groupbox_layout.addRow(
self.hide_resources_with_warn_status_cb)
# Hide empty groups in the resources tree
self.hide_empty_groups_cb = QCheckBox(
u"Masquer les groupes de ressources vides", self)
self.hide_empty_groups_cb.stateChanged.connect(
self.hide_empty_groups_cb_changed)
resource_tree_groupbox_layout.addRow(self.hide_empty_groups_cb)
params_layout.addWidget(self.resource_tree_groupbox)
dlg_layout.addLayout(params_layout)
# Set values
self.set_values_from_qsettings()
# Bottom dialog buttons
self.button_box = QDialogButtonBox()
self.button_box.setOrientation(Qt.Horizontal)
self.button_box.setStandardButtons(QDialogButtonBox.RestoreDefaults
| QDialogButtonBox.Apply
| QDialogButtonBox.Close)
self.button_box.button(
QDialogButtonBox.RestoreDefaults).clicked.connect(
self.restore_defaults_button_clicked)
self.button_box.button(QDialogButtonBox.Close).clicked.connect(
self.close_button_clicked)
self.button_box.button(QDialogButtonBox.Apply).clicked.connect(
self.apply_button_clicked)
# Dialog box title, layout, size and display
title = u"Paramétrage de l'extension GéoSAS…"
self.setWindowTitle(title)
dlg_layout.addWidget(self.button_box)
self.setLayout(dlg_layout)
self.setMinimumWidth(500)
self.resize(self.sizeHint())
self.setSizeGripEnabled(False)
self.setFixedSize(self.size())
self.show()
self.setSizeGripEnabled(False)
class QvFormSimbMapificacio(QvFormBaseMapificacio):
def __init__(self, llegenda, capa=None, amplada=500):
super().__init__(llegenda, amplada)
if capa is None:
self.capa = llegenda.currentLayer()
else:
self.capa = capa
self.info = None
if not self.iniParams():
return
self.setWindowTitle('Modificar mapa simbòlic ' + self.renderParams.tipusMapa.lower())
self.layout = QVBoxLayout()
self.layout.setSpacing(14)
self.setLayout(self.layout)
self.color = QComboBox(self)
self.color.setEditable(False)
self.comboColors(self.color)
self.contorn = QComboBox(self)
self.contorn.setEditable(False)
self.comboColors(self.contorn, mv.MAP_CONTORNS)
self.color.currentIndexChanged.connect(self.canviaContorns)
self.metode = QComboBox(self)
self.metode.setEditable(False)
if self.renderParams.numCategories > 1:
self.metode.addItems(mv.MAP_METODES_MODIF.keys())
else:
self.metode.addItems(mv.MAP_METODES.keys())
self.metode.setCurrentIndex(-1)
self.metode.currentIndexChanged.connect(self.canviaMetode)
self.nomIntervals = QLabel("Nombre d'intervals:", self)
self.intervals = QSpinBox(self)
self.intervals.setMinimum(min(2, self.renderParams.numCategories))
self.intervals.setMaximum(max(mv.MAP_MAX_CATEGORIES, self.renderParams.numCategories))
self.intervals.setSingleStep(1)
self.intervals.setValue(4)
if self.renderParams.tipusMapa == 'Àrees':
self.intervals.setSuffix(" (depèn del mètode)")
# self.intervals.valueChanged.connect(self.deselectValue)
self.nomTamany = QLabel("Tamany cercle:", self)
self.tamany = QSpinBox(self)
self.tamany.setMinimum(1)
self.tamany.setMaximum(12)
self.tamany.setSingleStep(1)
self.tamany.setValue(4)
self.bInfo = QPushButton('Info')
self.bInfo.clicked.connect(self.veureInfo)
self.buttons = QDialogButtonBox()
self.buttons.addButton(QDialogButtonBox.Ok)
self.buttons.accepted.connect(self.accept)
self.buttons.addButton(QDialogButtonBox.Cancel)
self.buttons.rejected.connect(self.cancel)
self.buttons.addButton(self.bInfo, QDialogButtonBox.ResetRole)
self.gSimb = QGroupBox('Simbologia del mapa')
self.lSimb = QFormLayout()
self.lSimb.setSpacing(14)
self.gSimb.setLayout(self.lSimb)
self.lSimb.addRow('Color base:', self.color)
self.lSimb.addRow('Color contorn:', self.contorn)
if self.renderParams.tipusMapa == 'Àrees':
self.lSimb.addRow('Mètode classificació:', self.metode)
self.lSimb.addRow(self.nomIntervals, self.intervals)
self.nomTamany.setVisible(False)
self.tamany.setVisible(False)
else:
self.metode.setVisible(False)
self.nomIntervals.setVisible(False)
self.intervals.setVisible(False)
self.lSimb.addRow(self.nomTamany, self.tamany)
self.wInterval = []
for w in self.iniIntervals():
self.wInterval.append(w)
self.gInter = self.grupIntervals()
self.layout.addWidget(self.gSimb)
if self.renderParams.tipusMapa == 'Àrees':
self.layout.addWidget(self.gInter)
self.layout.addWidget(self.buttons)
self.valorsInicials()
def iniParams(self):
self.info = QgsExpressionContextUtils.layerScope(self.capa).variable(mv.MAP_ID)
if self.info is None:
return False
self.renderParams = QvMapRendererParams.fromLayer(self.capa)
if self.renderParams.msgError == '':
self.custom = (self.renderParams.modeCategories == 'Personalitzat')
return True
else:
self.msgInfo("No s'han pogut recuperar els paràmetres del mapa simbòlic\n\n" +
"Error: " + self.renderParams.msgError)
return False
@pyqtSlot()
def veureInfo(self):
if self.info is not None:
box = QMessageBox(self)
box.setWindowTitle('Info del mapa simbòlic')
txt = '<table width="600">'
params = self.info.split('\n')
for param in params:
linea = param.strip()
if linea.endswith(':'):
linea += ' ---'
txt += '<tr><td><nobr>· {}</nobr></td></tr>'.format(linea)
txt += '</table>'
box.setTextFormat(Qt.RichText)
box.setText("Paràmetres d'agregació de dades:")
box.setInformativeText(txt)
box.setIcon(QMessageBox.Information)
box.setStandardButtons(QMessageBox.Ok)
box.setDefaultButton(QMessageBox.Ok)
box.exec()
def valorsInicials(self):
self.color.setCurrentIndex(self.color.findText(self.renderParams.colorBase))
self.contorn.setCurrentIndex(self.contorn.findText(self.renderParams.colorContorn))
self.intervals.setValue(self.renderParams.numCategories)
self.tamany.setValue(self.renderParams.increase)
self.metode.setCurrentIndex(self.metode.findText(self.renderParams.modeCategories))
def valorsFinals(self):
self.renderParams.colorBase = self.color.currentText()
self.renderParams.colorContorn = self.contorn.currentText()
self.renderParams.modeCategories = self.metode.currentText()
self.renderParams.numCategories = self.intervals.value()
self.renderParams.increase = self.tamany.value()
if self.custom:
self.renderParams.rangsCategories = []
for fila in self.wInterval:
self.renderParams.rangsCategories.append((fila[0].text(), fila[2].text()))
self.renderParams.numCategories = len(self.renderParams.rangsCategories)
def txtRang(self, num):
if type(num) == str:
return num
return QvApp().locale.toString(num, 'f', self.renderParams.numDecimals)
def iniFilaInterval(self, iniValor, finValor):
maxSizeB = 27
# validator = QDoubleValidator(self)
# validator.setLocale(QvApp().locale)
# validator.setNotation(QDoubleValidator.StandardNotation)
# validator.setDecimals(5)
validator = QvVerifNumero(self)
ini = QLineEdit(self)
ini.setText(self.txtRang(iniValor))
ini.setValidator(validator)
sep = QLabel('-', self)
fin = QLineEdit(self)
fin.setText(self.txtRang(finValor))
fin.setValidator(validator)
fin.editingFinished.connect(self.nouTall)
add = QPushButton('+', self)
add.setMaximumSize(maxSizeB, maxSizeB)
add.setToolTip('Afegeix nou interval')
add.clicked.connect(self.afegirFila)
add.setFocusPolicy(Qt.NoFocus)
rem = QPushButton('-', self)
rem.setMaximumSize(maxSizeB, maxSizeB)
rem.setToolTip('Esborra interval')
rem.clicked.connect(self.eliminarFila)
rem.setFocusPolicy(Qt.NoFocus)
return [ini, sep, fin, add, rem]
def iniIntervals(self):
for cat in self.renderParams.rangsCategories:
yield self.iniFilaInterval(cat.lowerValue(), cat.upperValue())
def grupIntervals(self):
group = QGroupBox('Definició dels intervals')
# group.setMinimumWidth(400)
layout = QGridLayout()
layout.setSpacing(10)
# layout.setColumnMinimumWidth(4, 40)
numFilas = len(self.wInterval)
for fila, widgets in enumerate(self.wInterval):
for col, w in enumerate(widgets):
# Primera fila: solo +
if fila == 0 and col > 3:
w.setVisible(False)
# # Ultima fila: no hay + ni -
elif fila > 0 and fila == (numFilas - 1) and col > 2:
w.setVisible(False)
else:
w.setVisible(True)
# Valor inicial deshabilitado (menos 1a fila)
if col == 0 and fila != 0:
w.setDisabled(True)
w.setProperty('Fila', fila)
layout.addWidget(w, fila, col)
group.setLayout(layout)
return group
def actGrupIntervals(self):
self.intervals.setValue(len(self.wInterval))
self.setUpdatesEnabled(False)
self.buttons.setVisible(False)
self.gInter.setVisible(False)
self.layout.removeWidget(self.buttons)
self.layout.removeWidget(self.gInter)
self.gInter.deleteLater()
self.gInter = self.grupIntervals()
self.layout.addWidget(self.gInter)
self.layout.addWidget(self.buttons)
self.gInter.setVisible(True)
self.buttons.setVisible(True)
self.adjustSize()
self.setUpdatesEnabled(True)
@pyqtSlot()
def afegirFila(self):
masFilas = (len(self.wInterval) < mv.MAP_MAX_CATEGORIES)
if masFilas:
f = self.sender().property('Fila') + 1
ini = self.wInterval[f][0]
val = ini.text()
ini.setText('')
w = self.iniFilaInterval(val, '')
self.wInterval.insert(f, w)
self.actGrupIntervals()
self.wInterval[f][2].setFocus()
else:
self.msgInfo("S'ha arribat al màxim d'intervals possibles")
@pyqtSlot()
def eliminarFila(self):
f = self.sender().property('Fila')
ini = self.wInterval[f][0]
val = ini.text()
del self.wInterval[f]
ini = self.wInterval[f][0]
ini.setText(val)
self.actGrupIntervals()
@pyqtSlot()
def nouTall(self):
w = self.sender()
if w.isModified():
f = w.property('Fila') + 1
if f < len(self.wInterval):
ini = self.wInterval[f][0]
ini.setText(w.text())
w.setModified(False)
@pyqtSlot()
def canviaMetode(self):
self.custom = (self.metode.currentText() == 'Personalitzat')
if self.custom:
self.intervals.setValue(len(self.wInterval))
self.intervals.setEnabled(not self.custom)
self.gInter.setVisible(self.custom)
self.adjustSize()
# print('GSIMB -> Ancho:', self.gSimb.size().width(), '- Alto:', self.gSimb.size().height())
# print('FORM -> Ancho:', self.size().width(), '- Alto:', self.size().height())
@pyqtSlot()
def canviaContorns(self):
self.comboColors(self.contorn, mv.MAP_CONTORNS,
mv.MAP_COLORS[self.color.currentText()], True)
def leSelectFocus(self, wLineEdit):
lon = len(wLineEdit.text())
if lon > 0:
wLineEdit.setSelection(0, lon)
wLineEdit.setFocus()
def validaNum(self, wLineEdit):
val = wLineEdit.validator()
if val is None:
return True
res = val.validate(wLineEdit.text(), 0)
if res[0] == QValidator.Acceptable:
return True
else:
self.msgInfo("Cal introduir un nombre enter o amb decimals.\n"
"Es farà servir la coma (,) per separar els decimals.\n"
"I pels milers, opcionalment, el punt (.)")
self.leSelectFocus(wLineEdit)
return False
def validaInterval(self, wLineEdit1, wLineEdit2):
num1, _ = QvApp().locale.toFloat(wLineEdit1.text())
num2, _ = QvApp().locale.toFloat(wLineEdit2.text())
if num2 >= num1:
return True
else:
self.msgInfo("El segon nombre de l'interval ha de ser major que el primer")
self.leSelectFocus(wLineEdit2)
return False
def validaFila(self, fila):
wLineEdit1 = fila[0]
wLineEdit2 = fila[2]
if not self.validaNum(wLineEdit1):
return False
if not self.validaNum(wLineEdit2):
return False
if not self.validaInterval(wLineEdit1, wLineEdit2):
return False
return True
def valida(self):
if self.custom:
for fila in self.wInterval:
if not self.validaFila(fila):
return False
return True
def procesa(self):
self.valorsFinals()
try:
mapRenderer = self.renderParams.mapRenderer(self.llegenda)
if self.custom:
self.renderParams.colorBase = mv.MAP_COLORS[self.renderParams.colorBase]
self.renderParams.colorContorn = mv.MAP_CONTORNS[self.renderParams.colorContorn]
self.renderer = mapRenderer.customRender(self.capa)
else:
self.renderParams.colorBase = mv.MAP_COLORS[self.renderParams.colorBase]
if self.renderParams.colorContorn == 'Base':
self.renderParams.colorContorn = self.renderParams.colorBase
else:
self.renderParams.colorContorn = mv.MAP_CONTORNS[self.renderParams.colorContorn]
self.renderParams.modeCategories = \
mv.MAP_METODES_MODIF[self.renderParams.modeCategories]
self.renderer = mapRenderer.calcRender(self.capa)
if self.renderer is None:
return "No s'ha pogut elaborar el mapa simbòlic"
err = self.llegenda.saveStyleToGeoPackage(self.capa, mv.MAP_ID)
if err != '':
return "Hi ha hagut problemes al desar la simbologia\n({})".format(err)
# self.llegenda.modificacioProjecte('mapModified')
return ''
except Exception as e:
return "No s'ha pogut modificar el mapa simbòlic\n({})".format(str(e))
def __init__(self, llegenda, capa=None, amplada=500):
super().__init__(llegenda, amplada)
if capa is None:
self.capa = llegenda.currentLayer()
else:
self.capa = capa
self.info = None
if not self.iniParams():
return
self.setWindowTitle('Modificar mapa simbòlic ' + self.renderParams.tipusMapa.lower())
self.layout = QVBoxLayout()
self.layout.setSpacing(14)
self.setLayout(self.layout)
self.color = QComboBox(self)
self.color.setEditable(False)
self.comboColors(self.color)
self.contorn = QComboBox(self)
self.contorn.setEditable(False)
self.comboColors(self.contorn, mv.MAP_CONTORNS)
self.color.currentIndexChanged.connect(self.canviaContorns)
self.metode = QComboBox(self)
self.metode.setEditable(False)
if self.renderParams.numCategories > 1:
self.metode.addItems(mv.MAP_METODES_MODIF.keys())
else:
self.metode.addItems(mv.MAP_METODES.keys())
self.metode.setCurrentIndex(-1)
self.metode.currentIndexChanged.connect(self.canviaMetode)
self.nomIntervals = QLabel("Nombre d'intervals:", self)
self.intervals = QSpinBox(self)
self.intervals.setMinimum(min(2, self.renderParams.numCategories))
self.intervals.setMaximum(max(mv.MAP_MAX_CATEGORIES, self.renderParams.numCategories))
self.intervals.setSingleStep(1)
self.intervals.setValue(4)
if self.renderParams.tipusMapa == 'Àrees':
self.intervals.setSuffix(" (depèn del mètode)")
# self.intervals.valueChanged.connect(self.deselectValue)
self.nomTamany = QLabel("Tamany cercle:", self)
self.tamany = QSpinBox(self)
self.tamany.setMinimum(1)
self.tamany.setMaximum(12)
self.tamany.setSingleStep(1)
self.tamany.setValue(4)
self.bInfo = QPushButton('Info')
self.bInfo.clicked.connect(self.veureInfo)
self.buttons = QDialogButtonBox()
self.buttons.addButton(QDialogButtonBox.Ok)
self.buttons.accepted.connect(self.accept)
self.buttons.addButton(QDialogButtonBox.Cancel)
self.buttons.rejected.connect(self.cancel)
self.buttons.addButton(self.bInfo, QDialogButtonBox.ResetRole)
self.gSimb = QGroupBox('Simbologia del mapa')
self.lSimb = QFormLayout()
self.lSimb.setSpacing(14)
self.gSimb.setLayout(self.lSimb)
self.lSimb.addRow('Color base:', self.color)
self.lSimb.addRow('Color contorn:', self.contorn)
if self.renderParams.tipusMapa == 'Àrees':
self.lSimb.addRow('Mètode classificació:', self.metode)
self.lSimb.addRow(self.nomIntervals, self.intervals)
self.nomTamany.setVisible(False)
self.tamany.setVisible(False)
else:
self.metode.setVisible(False)
self.nomIntervals.setVisible(False)
self.intervals.setVisible(False)
self.lSimb.addRow(self.nomTamany, self.tamany)
self.wInterval = []
for w in self.iniIntervals():
self.wInterval.append(w)
self.gInter = self.grupIntervals()
self.layout.addWidget(self.gSimb)
if self.renderParams.tipusMapa == 'Àrees':
self.layout.addWidget(self.gInter)
self.layout.addWidget(self.buttons)
self.valorsInicials()
def __init__(self, title, yTitle, data, parent=None):
QWidget.__init__(self, parent)
self.setWindowTitle("TimeSeries viewer")
# sort data by x
data.sort(key=lambda x: x[0])
formLayout = QFormLayout()
# id
titleW = QLineEdit(title, self)
titleW.setReadOnly(True)
formLayout.addRow("ID", titleW)
# start and end time
sdt = QDateTime.fromString(data[0][2], "yyyy-MM-ddTHH:mm:ss.zZ")
edt = QDateTime.fromString(data[-1][2], "yyyy-MM-ddTHH:mm:ss.zZ")
startTimeW = QDateTimeEdit(sdt)
startTimeW.setReadOnly(True)
endTimeW = QDateTimeEdit(edt)
endTimeW.setReadOnly(True)
formLayout.addRow("Start time", startTimeW)
formLayout.addRow("End time", endTimeW)
# unit of measure
unitW = QLineEdit(yTitle)
unitW.setReadOnly(True)
formLayout.addRow("Unit", unitW)
# min / max value
minValue = min([x[1] for x in data])
maxValue = max([x[1] for x in data])
minValueW = QLineEdit(str(minValue))
minValueW.setReadOnly(True)
maxValueW = QLineEdit(str(maxValue))
maxValueW.setReadOnly(True)
formLayout.addRow("Min value", minValueW)
formLayout.addRow("Max value", maxValueW)
# the plot
layout = QVBoxLayout()
self.plot = PlotView(yTitle, self)
layout.addLayout(formLayout)
layout.addWidget(self.plot)
self.setLayout(layout)
self.plot.setData(data)
self.resize(800, 600)
