def add_row(self):
"""Add a new row to verhang table"""
self.tableWidgetVerhang.insertRow(self.tableWidgetVerhang.rowCount())
current_row = self.tableWidgetVerhang.rowCount() - 1
# from column
from_spinbox = QtWidgets.QDoubleSpinBox()
from_spinbox.setMaximum(10000)
from_spinbox.setSingleStep(50)
from_spinbox.valueChanged.connect(self.from_spinbox_value_changed)
self.tableWidgetVerhang.setCellWidget(current_row, 0, from_spinbox)
# to column
to_spinbox = QtWidgets.QDoubleSpinBox()
to_spinbox.setMaximum(100000)
to_spinbox.setSingleStep(50)
to_spinbox.valueChanged.connect(self.to_spinbox_value_changed)
self.tableWidgetVerhang.setCellWidget(current_row, 1, to_spinbox)
# verhang column
verhang_spinbox = QtWidgets.QDoubleSpinBox()
verhang_spinbox.setMaximum(1)
verhang_spinbox.setDecimals(4)
verhang_spinbox.setSingleStep(0.001)
verhang_spinbox.valueChanged.connect(
self.verhang_spinbox_value_changed)
self.tableWidgetVerhang.setCellWidget(current_row, 2, verhang_spinbox)
self.update_verhang_table()
self.validate_run()
def setupUi(self, BulkVectorExportDialog):
BulkVectorExportDialog.setObjectName(
_fromUtf8("BulkVectorExportDialog"))
BulkVectorExportDialog.resize(392, 141)
self.buttonBox = QtWidgets.QDialogButtonBox(BulkVectorExportDialog)
self.buttonBox.setGeometry(QtCore.QRect(220, 100, 161, 32))
self.buttonBox.setWhatsThis(_fromUtf8(""))
self.buttonBox.setOrientation(QtCore.Qt.Horizontal)
self.buttonBox.setStandardButtons(QtWidgets.QDialogButtonBox.Cancel
| QtWidgets.QDialogButtonBox.Ok)
self.buttonBox.setCenterButtons(True)
self.buttonBox.setObjectName(_fromUtf8("buttonBox"))
self.dirEdit = QtWidgets.QLineEdit(BulkVectorExportDialog)
self.dirEdit.setGeometry(QtCore.QRect(120, 40, 231, 20))
self.dirEdit.setObjectName(_fromUtf8("dirEdit"))
self.label = QtWidgets.QLabel(BulkVectorExportDialog)
self.label.setGeometry(QtCore.QRect(10, 40, 71, 16))
self.label.setObjectName(_fromUtf8("label"))
self.dirButton = QtWidgets.QPushButton(BulkVectorExportDialog)
self.dirButton.setGeometry(QtCore.QRect(360, 40, 31, 21))
self.dirButton.setObjectName(_fromUtf8("dirButton"))
self.retranslateUi(BulkVectorExportDialog)
self.buttonBox.accepted.connect(BulkVectorExportDialog.accept)
self.buttonBox.rejected.connect(BulkVectorExportDialog.reject)
QtCore.QMetaObject.connectSlotsByName(BulkVectorExportDialog)
def setupUi(self, graphicsWindow, nom):
graphicsWindow.setObjectName("graphicsWindow")
graphicsWindow.resize(800, 600)
self.centralwidget = QtWidgets.QWidget(graphicsWindow)
self.centralwidget.setObjectName("centralwidget")
self.graphicsView = QtWidgets.QGraphicsView(self.centralwidget)
self.graphicsView.setGeometry(QtCore.QRect(0, 0, 791, 551))
self.graphicsView.setVerticalScrollBarPolicy(
QtCore.Qt.ScrollBarAlwaysOff)
self.graphicsView.setHorizontalScrollBarPolicy(
QtCore.Qt.ScrollBarAlwaysOff)
self.graphicsView.setBackgroundBrush(
QtGui.QBrush(QtGui.QColor(182, 182, 182)))
self.graphicsView.setObjectName("graphicsView")
self.widget = QtWidgets.QWidget(self.centralwidget)
self.widget.setGeometry(QtCore.QRect(170, 110, 1000, 1200))
self.widget.setObjectName("widget")
graphicsWindow.setCentralWidget(self.centralwidget)
self.menubar = QtWidgets.QMenuBar(graphicsWindow)
self.menubar.setGeometry(QtCore.QRect(0, 0, 800, 21))
self.menubar.setObjectName("menubar")
graphicsWindow.setMenuBar(self.menubar)
self.statusbar = QtWidgets.QStatusBar(graphicsWindow)
self.statusbar.setObjectName("statusbar")
graphicsWindow.setStatusBar(self.statusbar)
self.retranslateUi(graphicsWindow, nom)
QtCore.QMetaObject.connectSlotsByName(graphicsWindow)
def append_to_list(self, layer_type):
layer_fields, table, final_table, required_fields = self.__find_layer_changed(
layer_type)
for i in table.selectedRanges():
new_fields = [
table.item(row, 0).text()
for row in range(i.topRow(),
i.bottomRow() + 1)
]
for row in range(i.bottomRow(), i.topRow() - 1, -1):
table.removeRow(row)
counter = final_table.rowCount()
for field in new_fields:
final_table.setRowCount(counter + 1)
item1 = QtWidgets.QTableWidgetItem(field)
item1.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable)
final_table.setItem(counter, 0, item1)
chb1 = QtWidgets.QCheckBox()
chb1.setChecked(False)
chb1.setEnabled(False)
chb1.stateChanged.connect(self.keep_checked)
final_table.setCellWidget(counter, 1, self.centers_item(chb1))
cbb = QtWidgets.QComboBox()
cbb.addItem(field)
final_table.setCellWidget(counter, 2, self.centers_item(cbb))
counter += 1
def handle_dataset_list(
self,
dataset_list: typing.List[models.BriefDataset],
pagination_info: models.GeonodePaginationInfo,
):
"""Handle incoming dataset list
This method is called when the api client emits the `layer_list_received`
signal. It expects to receive a list of brief dataset descriptions, as found
on the remote GeoNode server.
"""
self.handle_pagination(pagination_info)
if len(dataset_list) > 0:
scroll_container = QtWidgets.QWidget()
layout = QtWidgets.QVBoxLayout()
layout.setContentsMargins(1, 1, 1, 1)
layout.setSpacing(1)
for brief_dataset in dataset_list:
search_result_widget = SearchResultWidget(
brief_dataset,
self.api_client,
data_source_widget=self,
)
layout.addWidget(search_result_widget)
layout.setAlignment(search_result_widget, QtCore.Qt.AlignTop)
scroll_container.setLayout(layout)
self.scroll_area.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOn)
self.scroll_area.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
self.scroll_area.setWidgetResizable(True)
self.scroll_area.setWidget(scroll_container)
self.message_bar.clearWidgets()
self.search_finished.emit("")
def initGui(self):
"""init actions plugin"""
self.toolbar = self.iface.addToolBar(PC.PLUGIN["name"])
self.action = PQtW.QAction(PQtG.QIcon(PC.PLUGIN["icon"]),
PC.PLUGIN["name"], self.iface.mainWindow())
self.action.triggered.connect(self.run)
self.toolbar.addAction(self.action)
self.iface.addPluginToMenu(PC.PLUGIN["menulocation"], self.action)
#add label to toolbar
label = PQtW.QLabel()
self.toolbar.addWidget(label)
label.setText(PC.PLUGIN["toolbartext"])
#init dropdown to switch floors
self.projCombo = PQtW.QComboBox(self.iface.mainWindow())
minBouwlaag = PC.PAND["minbouwlaag"]
maxBouwlaag = PC.PAND["maxbouwlaag"]
for i in range(maxBouwlaag - minBouwlaag + 1):
if maxBouwlaag - i != 0:
if maxBouwlaag - i == 1:
init_index = i
self.projCombo.addItem(str(maxBouwlaag - i))
self.projComboAction = self.toolbar.addWidget(self.projCombo)
self.projCombo.setFixedWidth(100)
self.projCombo.setMaxVisibleItems(30)
#set intial index to floor 1
self.projCombo.setCurrentIndex(init_index)
#connect to set layer subset if the index is changed
self.projCombo.currentIndexChanged.connect(
self.set_layer_subset_toolbar)
#init projectVariable to communicate from plugin to original drawing possibilities
QC.QgsExpressionContextUtils.setProjectVariable(
QC.QgsProject.instance(), 'actieve_bouwlaag', 1)
def set_widgets(self):
"""Set widgets on the Impact Functions Table 2 tab."""
self.tblFunctions2.clear()
hazard, exposure, _, _ = self.parent.\
selected_impact_function_constraints()
hazard_layer_geometries = get_allowed_geometries(
layer_purpose_hazard['key'])
exposure_layer_geometries = get_allowed_geometries(
layer_purpose_exposure['key'])
self.lblSelectFunction2.setText(select_function_constraints2_question %
(hazard['name'], exposure['name']))
self.tblFunctions2.setColumnCount(len(hazard_layer_geometries))
self.tblFunctions2.setRowCount(len(exposure_layer_geometries))
self.tblFunctions2.setHorizontalHeaderLabels(
[i['name'].capitalize() for i in hazard_layer_geometries])
for i in range(len(exposure_layer_geometries)):
item = QtWidgets.QTableWidgetItem()
item.setText(exposure_layer_geometries[i]['name'].capitalize())
item.setTextAlignment(QtCore.Qt.AlignCenter)
self.tblFunctions2.setVerticalHeaderItem(i, item)
self.tblFunctions2.horizontalHeader().setSectionResizeMode(
QtWidgets.QHeaderView.Stretch)
self.tblFunctions2.verticalHeader().setSectionResizeMode(
QtWidgets.QHeaderView.Stretch)
active_items = []
for column in range(len(hazard_layer_geometries)):
for row in range(len(exposure_layer_geometries)):
hazard_geometry = hazard_layer_geometries[column]
exposure_geometry = exposure_layer_geometries[row]
item = QtWidgets.QTableWidgetItem()
hazard_geometry_allowed = hazard_geometry['key'] in hazard[
'allowed_geometries']
exposure_geometry_allowed = (exposure_geometry['key']
in exposure['allowed_geometries'])
if hazard_geometry_allowed and exposure_geometry_allowed:
background_color = available_option_color
active_items += [item]
else:
background_color = unavailable_option_color
item.setFlags(item.flags() & ~QtCore.Qt.ItemIsEnabled)
item.setFlags(item.flags() & ~QtCore.Qt.ItemIsSelectable)
item.setBackground(QtGui.QBrush(background_color))
item.setFont(big_font)
item.setTextAlignment(QtCore.Qt.AlignCenter
| QtCore.Qt.AlignHCenter)
item.setData(RoleHazard, hazard)
item.setData(RoleExposure, exposure)
item.setData(RoleHazardConstraint, hazard_geometry)
item.setData(RoleExposureConstraint, exposure_geometry)
self.tblFunctions2.setItem(row, column, item)
# Automatically select one item...
if len(active_items) == 1:
active_items[0].setSelected(True)
# set focus, as the inactive selection style is gray
self.tblFunctions2.setFocus()
def __init__(self):
self.mock = mock.MagicMock()
self.widget = QtWidgets.QWidget()
self.mainwindow = QtWidgets.QMainWindow(self.widget)
self.mock.mainWindow.return_value = self.mainwindow
self.mock.layers.return_value = list(
QgsProject.instance().mapLayers().values())
def test_calc_selected_dont_overwrite(self, mock_selected_obsids,
mock_messagebar):
mock_selected_obsids.return_value = ['rb1', 'rb2']
db_utils.sql_alter_db(
'''INSERT INTO obs_points (obsid, h_toc) VALUES ('rb1', 1)''')
db_utils.sql_alter_db(
'''INSERT into w_levels (obsid, meas, date_time) VALUES ('rb1', 222, '2005-01-01 00:00:00')'''
)
db_utils.sql_alter_db(
'''INSERT INTO obs_points (obsid, h_toc) VALUES ('rb2', 4)''')
db_utils.sql_alter_db(
'''INSERT into w_levels (obsid, meas, date_time) VALUES ('rb2', 444, '2005-01-01 00:00:00')'''
)
db_utils.sql_alter_db(
'''INSERT into w_levels (obsid, meas, level_masl, date_time) VALUES ('rb2', 555, 667, '2005-01-02 00:00:00')'''
)
self.calclvl.FromDateTime = QtWidgets.QDateTimeEdit()
self.calclvl.FromDateTime.setDateTime(
datestring_to_date('2000-01-01 00:00:00'))
self.calclvl.ToDateTime = QtWidgets.QDateTimeEdit()
self.calclvl.ToDateTime.setDateTime(
datestring_to_date('2010-01-01 00:00:00'))
self.calclvl.checkBox_overwrite_prev.setChecked(False)
self.calclvl.calcselected()
#self.checkBox_skipnulls
test_string = utils_for_tests.create_test_string(
db_utils.sql_load_fr_db(
'SELECT obsid, date_time, meas, h_toc, level_masl FROM w_levels ORDER BY obsid, date_time'
))
reference_string = '(True, [(rb1, 2005-01-01 00:00:00, 222.0, 1.0, -221.0), (rb2, 2005-01-01 00:00:00, 444.0, 4.0, -440.0), (rb2, 2005-01-02 00:00:00, 555.0, None, 667.0)])'
print(str(mock_messagebar.mock_calls))
print(test_string)
assert test_string == reference_string
def populateTable(self, table, usersList):
if table == 'users':
table = self.usertabel
else:
table = self.groupstabel
tableRowCount = len(usersList)
table.setRowCount(tableRowCount)
for row in range(tableRowCount):
user = usersList[row]
table.setVerticalHeaderItem(
row, QtGui.QTableWidgetItem(user['displayTitle']))
permissions = user['permissions']
permList = ['Read', 'Update', 'Delete']
if not permissions:
for x in permList:
item = QtGui.QTableWidgetItem(x)
item.setCheckState(Qt.Unchecked)
table.setItem(row, permList.index(x), item)
else:
for x in permList:
item = QtGui.QTableWidgetItem(x)
if x.upper() in permissions['permissions']:
item.setCheckState(Qt.Checked)
else:
item.setCheckState(Qt.Unchecked)
table.setItem(row, permList.index(x), item)
def add_raster_to_table_list(self, raster_layer, upper=False, lower=False):
if self.pixel_size[0] == '0' and raster_layer is not None:
self.pixel_size = get_pixel_size(
self.mcboRasterLayer.currentLayer())
# 'of {} {}'.format(*self.pixel_size[:2]))
# get list of objects to update
tab_obj_list = []
if upper:
tab_obj_list.append(self.tabUpper)
if lower:
tab_obj_list.append(self.tabLower)
for ea_tab in tab_obj_list:
# find out if it is already there.
if ea_tab.findItems(raster_layer.id(), QtCore.Qt.MatchExactly):
continue
rowPosition = ea_tab.rowCount()
ea_tab.insertRow(rowPosition)
# Save the id of the layer to a column used to get a layer object later on.
# adapted from
# https://gis.stackexchange.com/questions/165415/activating-layer-by-its-name-in-pyqgis
ea_tab.setItem(rowPosition, 0,
QtWidgets.QTableWidgetItem(raster_layer.id()))
ea_tab.setItem(rowPosition, 1,
QtWidgets.QTableWidgetItem(raster_layer.name()))
self.setMapLayers()
def setupUi(self, Form):
Form.setObjectName("Form")
Form.resize(400, 67)
self.gridLayout = QtWidgets.QGridLayout(Form)
self.gridLayout.setObjectName("gridLayout")
self.label_start = QtWidgets.QLabel(Form)
self.label_start.setObjectName("label_start")
self.gridLayout.addWidget(self.label_start, 0, 0, 1, 1)
self.label_end = QtWidgets.QLabel(Form)
self.label_end.setObjectName("label_end")
self.gridLayout.addWidget(self.label_end, 0, 1, 1, 1)
self.date_start = gui.QgsDateTimeEdit(Form)
self.date_start.setMinimumDateTime(QtCore.QDateTime(QtCore.QDate(1970, 1, 1), QtCore.QTime(0, 0, 0)))
self.date_start.setMinimumDate(QtCore.QDate(1970, 1, 1))
self.date_start.setCurrentSection(QtWidgets.QDateTimeEdit.YearSection)
self.date_start.setTimeSpec(QtCore.Qt.UTC)
self.date_start.setObjectName("date_start")
self.gridLayout.addWidget(self.date_start, 1, 0, 1, 1)
self.date_end = gui.QgsDateTimeEdit(Form)
self.date_end.setMinimumDateTime(QtCore.QDateTime(QtCore.QDate(1970, 1, 1), QtCore.QTime(0, 0, 0)))
self.date_end.setMinimumDate(QtCore.QDate(1970, 1, 1))
self.date_end.setCurrentSection(QtWidgets.QDateTimeEdit.YearSection)
self.date_end.setObjectName("date_end")
self.gridLayout.addWidget(self.date_end, 1, 1, 1, 1)
self.date_start.clear()
self.date_end.clear()
self.retranslateUi(Form)
QtCore.QMetaObject.connectSlotsByName(Form)
def centers_item(self, item):
cell_widget = QtWidgets.QWidget()
lay_out = QtWidgets.QHBoxLayout(cell_widget)
lay_out.addWidget(item)
lay_out.setAlignment(Qt.AlignCenter)
lay_out.setContentsMargins(0, 0, 0, 0)
cell_widget.setLayout(lay_out)
return cell_widget
def __addRowToGridLayout(self):
if len(self.__vfkLineEdits) >= 5:
self.__maximumLineEditsReached()
return
# update label
self.label.setText('VFK soubory:')
# new layout
horizontalLayout = QtWidgets.QHBoxLayout()
# create new objects
self.__browseButtons['browseButton_{}'.format(
len(self.__vfkLineEdits) +
1)] = QtWidgets.QPushButton(u"Procházet")
self.__vfkLineEdits['vfkLineEdit_{}'.format(
len(self.__vfkLineEdits) + 1)] = QtWidgets.QLineEdit()
horizontalLayout.addWidget(self.__vfkLineEdits['vfkLineEdit_{}'.format(
len(self.__vfkLineEdits))])
horizontalLayout.addWidget(
self.__browseButtons['browseButton_{}'.format(
len(self.__vfkLineEdits))])
# number of lines in gridLayout
rows_count = self.gridLayout_12.rowCount(
) # count of rows in gridLayout
# export objects from gridLayout
item_label = self.gridLayout_12.itemAtPosition(rows_count - 3, 0)
item_par = self.gridLayout_12.itemAtPosition(rows_count - 3, 1)
item_bud = self.gridLayout_12.itemAtPosition(rows_count - 2, 1)
item_settings = self.gridLayout_12.itemAtPosition(rows_count - 1, 0)
item_rewrite_db = self.gridLayout_12.itemAtPosition(rows_count - 1, 1)
# remove objects from gridLayout
self.gridLayout_12.removeItem(
self.gridLayout_12.itemAtPosition(rows_count - 3, 0))
self.gridLayout_12.removeItem(
self.gridLayout_12.itemAtPosition(rows_count - 3, 1))
self.gridLayout_12.removeItem(
self.gridLayout_12.itemAtPosition(rows_count - 2, 1))
self.gridLayout_12.removeItem(
self.gridLayout_12.itemAtPosition(rows_count - 1, 0))
self.gridLayout_12.removeItem(
self.gridLayout_12.itemAtPosition(rows_count - 1, 1))
# re-build gridLayout
self.gridLayout_12.addLayout(horizontalLayout, rows_count - 3, 1)
self.gridLayout_12.addItem(item_label, rows_count - 2, 0)
self.gridLayout_12.addItem(item_par, rows_count - 2, 1)
self.gridLayout_12.addItem(item_bud, rows_count - 1, 1)
self.gridLayout_12.addItem(item_settings, rows_count, 0)
self.gridLayout_12.addItem(item_rewrite_db, rows_count, 1)
self.__browseButtons['browseButton_{}'.format(len(self.__vfkLineEdits))].clicked.\
connect(lambda: self.browseButton_clicked(
int('{}'.format(len(self.__vfkLineEdits)))))
def add_aggregation(self, *args, aggregation: Aggregation = DEFAULT_AGGREGATION):
"""Add a new row to tableWidgetAggregations, always last row"""
self.tableWidgetAggregations.insertRow(self.tableWidgetAggregations.rowCount())
current_row = self.tableWidgetAggregations.rowCount() - 1
# variable column
variable_combobox = QtWidgets.QComboBox()
for i, variable in enumerate(AGGREGATION_VARIABLES):
variable_combobox.addItem(VT_NAMES[variable.var_type] + ': ' + variable.long_name)
variable_combobox.setItemData(i, variable)
idx = variable_combobox.findText(aggregation.variable.long_name, Qt.MatchEndsWith)
variable_combobox.setCurrentIndex(idx)
variable_combobox.currentTextChanged.connect(self.variable_combobox_text_changed)
self.tableWidgetAggregations.setCellWidget(current_row, 0, variable_combobox)
# sign column
direction_combobox = QtWidgets.QComboBox()
counter = 0
for s in AGGREGATION_SIGNS:
direction_combobox.addItem(s.long_name)
direction_combobox.setItemData(counter, s)
counter += 1
direction_combobox.setCurrentText(aggregation.sign.long_name)
self.tableWidgetAggregations.setCellWidget(current_row, 1, direction_combobox)
direction_combobox.currentTextChanged.connect(self.direction_combobox_text_changed)
# method column
method_combobox = QtWidgets.QComboBox()
for i, method in enumerate(AGGREGATION_METHODS):
method_combobox.addItem(method.long_name)
method_combobox.setItemData(i, method)
method_combobox.setCurrentText(aggregation.method.long_name)
self.tableWidgetAggregations.setCellWidget(current_row, 2, method_combobox)
method_combobox.currentTextChanged.connect(self.method_combobox_text_changed)
# threshold column
threshold_widget = QtWidgets.QDoubleSpinBox()
threshold_widget.setRange(sys.float_info.min, sys.float_info.max)
self.tableWidgetAggregations.setCellWidget(current_row, 3, threshold_widget)
method = method_combobox.itemData(method_combobox.currentIndex())
self.set_threshold_widget(row=current_row, method=method)
if aggregation.threshold is not None:
threshold_widget.setValue(aggregation.threshold)
threshold_widget.valueChanged.connect(self.threshold_value_changed)
# units column
units_combobox = QtWidgets.QComboBox()
self.tableWidgetAggregations.setCellWidget(current_row, 4, units_combobox)
self.set_units_widget(row=current_row,
variable=variable_combobox.itemData(variable_combobox.currentIndex()),
method=method
)
# TODO: dit nu nu lastig te setten obv aggregation, omdat die wel een attribuut multiplier heeft,
# maar niet een attribuut units. laat ik nu even voor wat het is
units_combobox.currentTextChanged.connect(self.units_combobox_text_changed)
self.update_demanded_aggregations()
self.set_styling_tab()
self.validate()
def on_workspaceComboBox_currentIndexChanged(self):
self.clearLayout()
workspace = self.getCurrentWorkspace()
for parameter in [x for x in workspace['parametros'] if x != 'LOG_FILE']:
newLabel = QtWidgets.QLabel(parameter)
self.verticalLayout_2.addWidget(newLabel)
newLineEdit = QtWidgets.QLineEdit()
self.interfaceDict[parameter] = newLineEdit
self.verticalLayout_2.addWidget(newLineEdit)
def changed_layer(self, layer_type):
try:
layer_fields, table, final_table, required_fields = self.__find_layer_changed(
layer_type)
table.clearContents()
table.setRowCount(0)
# We create the comboboxes that will hold the definitions for all the fields that are mandatory for
# creating the appropriate triggers on the SQLite file
if layer_fields is not None:
fields = [field.name() for field in layer_fields]
counter = 0
for field in fields:
table.setRowCount(counter + 1)
item1 = QtWidgets.QTableWidgetItem(field)
item1.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable)
table.setItem(counter, 0, item1)
counter += 1
self.counter[layer_type] = counter
final_table.clearContents()
final_table.setRowCount(0)
counter = 0
if layer_type == "links":
init_fields = [
x for x in required_fields
if x not in Network.req_link_flds
]
else:
init_fields = [
x for x in required_fields
if x not in Network.req_node_flds
]
for rf in required_fields:
final_table.setRowCount(counter + 1)
item1 = QtWidgets.QTableWidgetItem(rf)
item1.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable)
final_table.setItem(counter, 0, item1)
chb1 = QtWidgets.QCheckBox()
if rf in init_fields:
chb1.setChecked(True)
chb1.stateChanged.connect(
partial(self.set_field_to_default, layer_type))
else:
chb1.setChecked(True)
chb1.stateChanged.connect(
partial(self.set_field_to_default, layer_type))
chb1.setChecked(False)
chb1.setEnabled(False)
final_table.setCellWidget(counter, 1, self.centers_item(chb1))
counter += 1
except:
pass
def setupUi(self, Dialog):
Dialog.setObjectName("Dialog")
Dialog.resize(261, 171)
self.comboBox = QtWidgets.QComboBox(Dialog)
self.comboBox.setGeometry(QtCore.QRect(10, 10, 241, 22))
self.comboBox.setObjectName("comboBox")
self.choose = QtWidgets.QAction(Dialog)
self.choose.setObjectName("choose")
self.retranslateUi(Dialog)
QtCore.QMetaObject.connectSlotsByName(Dialog)
def progressdialog(self, progress):
pdialog = PQtW.QProgressDialog()
pdialog.setWindowTitle("Progress")
pdialog.setLabelText("Voortgang van importeren:")
pbar = PQtW.QProgressBar(pdialog)
pbar.setTextVisible(True)
pbar.setValue(progress)
pdialog.setBar(pbar)
pdialog.setMinimumWidth(300)
pdialog.show()
return pdialog, pbar
def setupUi(self, Clone):
Clone.setObjectName(_fromUtf8("Clone"))
Clone.resize(375, 210)
self.gridlayout = QtWidgets.QGridLayout(Clone)
self.gridlayout.setObjectName(_fromUtf8("gridlayout"))
self.vboxlayout = QtWidgets.QVBoxLayout()
self.vboxlayout.setObjectName(_fromUtf8("vboxlayout"))
spacerItem = QtWidgets.QSpacerItem(
20, 20, QtWidgets.QSizePolicy.Minimum,
QtWidgets.QSizePolicy.MinimumExpanding)
self.vboxlayout.addItem(spacerItem)
self.label = QtWidgets.QLabel(Clone)
sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Preferred,
QtWidgets.QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(
self.label.sizePolicy().hasHeightForWidth())
self.label.setSizePolicy(sizePolicy)
self.label.setObjectName(_fromUtf8("label"))
self.vboxlayout.addWidget(self.label)
self.lineDsn = QtWidgets.QLineEdit(Clone)
self.lineDsn.setMouseTracking(False)
self.lineDsn.setInputMask(_fromUtf8(""))
self.lineDsn.setMaxLength(10)
self.lineDsn.setFrame(True)
self.lineDsn.setObjectName(_fromUtf8("lineDsn"))
self.vboxlayout.addWidget(self.lineDsn)
self.label_3 = QtWidgets.QLabel(Clone)
self.label_3.setObjectName(_fromUtf8("label_3"))
self.vboxlayout.addWidget(self.label_3)
self.comboDsn = QtWidgets.QComboBox(Clone)
self.comboDsn.setObjectName(_fromUtf8("comboDsn"))
self.vboxlayout.addWidget(self.comboDsn)
self.gridlayout.addLayout(self.vboxlayout, 0, 0, 1, 1)
self.buttonBox = QtWidgets.QDialogButtonBox(Clone)
self.buttonBox.setOrientation(QtCore.Qt.Horizontal)
self.buttonBox.setStandardButtons(QtWidgets.QDialogButtonBox.Cancel
| QtWidgets.QDialogButtonBox.NoButton
| QtWidgets.QDialogButtonBox.Ok)
self.buttonBox.setCenterButtons(True)
self.buttonBox.setObjectName(_fromUtf8("buttonBox"))
self.gridlayout.addWidget(self.buttonBox, 2, 0, 1, 1)
spacerItem1 = QtWidgets.QSpacerItem(
20, 20, QtWidgets.QSizePolicy.Minimum,
QtWidgets.QSizePolicy.MinimumExpanding)
self.gridlayout.addItem(spacerItem1, 1, 0, 1, 1)
self.retranslateUi(Clone)
self.buttonBox.accepted.connect(Clone.accept)
self.buttonBox.rejected.connect(Clone.reject)
QMetaObject.connectSlotsByName(Clone)
Clone.setTabOrder(self.lineDsn, self.comboDsn)
Clone.setTabOrder(self.comboDsn, self.buttonBox)
def initUI(self):
lo = QtWidgets.QFormLayout()
lo.addRow(QtWidgets.QLabel("Drop something here:"))
l1 = QtWidgets.QLabel("")
l2 = QtWidgets.QLabel("")
dropspace = QpalsDropTextbox()
lo.addRow(dropspace)
lo.addRow(l1)
lo.addRow(l2)
self.setLayout(lo)
self.setWindowTitle("Hallo Alina")
def listCRS(self, txt=''):
crs = self.model.listCRS(txt)
self.conf.tableCRS.clearContents()
k = 0
for x in crs:
self.conf.tableCRS.insertRow(self.conf.tableCRS.rowCount())
self.conf.tableCRS.setItem(k, 0,
QtWidgets.QTableWidgetItem(str(x[1])))
self.conf.tableCRS.setItem(k, 1,
QtWidgets.QTableWidgetItem(str(x[0])))
k += 1
def getTitleBar():
"""create titlebar for dockwidget"""
titleBar = PQtW.QWidget()
layout = PQtW.QHBoxLayout()
font = QFont("Arial", 10, QFont.Bold)
label = create_label(PLUGIN["name"], layout, font)
btnFloat = create_pushbutton("Icon", PLUGIN["floaticon"], layout, 20)
btnHelp = create_pushbutton("Icon", PLUGIN["helpicon"], layout, 20)
titleBar.setLayout(layout)
titleBar.setWindowFlag(Qt.WindowMaximizeButtonHint, True)
return btnHelp, btnFloat, titleBar
def setup_class_table(self, classes):
default_codes = sorted(
[c['Initial_Code'] for c in self.default_classes])
input_codes = sorted([c['Initial_Code'] for c in classes])
new_codes = [c for c in input_codes if c not in default_codes]
missing_codes = [c for c in default_codes if c not in input_codes]
if len(new_codes) > 0:
QtWidgets.QMessageBox.warning(
None, self.tr("Warning"),
self.
tr(u"Some of the class codes ({}) in the definition file do not appear in the chosen data file."
.format(', '.join([str(c) for c in new_codes]), None)))
if len(missing_codes) > 0:
QtWidgets.QMessageBox.warning(
None, self.tr("Warning"),
self.
tr(u"Some of the class codes ({}) in the data file do not appear in the chosen definition file."
.format(', '.join([str(c) for c in missing_codes]), None)))
# Setup a new classes list with the new class codes for all classes
# included in default calsses, and and any other class codes that are
# missing added from the default class list
classes = [c for c in classes if c['Initial_Code'] in default_codes]
classes.extend([
c for c in self.default_classes
if c['Initial_Code'] not in input_codes
])
table_model = LCAggTableModel(classes, parent=self)
proxy_model = QtWidgets.QSortFilterProxyModel()
proxy_model.setSourceModel(table_model)
self.remap_view.setModel(proxy_model)
# Add selector in cell
for row in range(0, len(classes)):
lc_classes = QtWidgets.QComboBox()
lc_classes.currentIndexChanged.connect(self.lc_class_combo_changed)
# Add the classes in order of their codes
lc_classes.addItems(
sorted(list(self.final_classes.keys()),
key=lambda k: self.final_classes[k]))
ind = lc_classes.findText(classes[row]['Final_Label'])
if ind != -1:
lc_classes.setCurrentIndex(ind)
self.remap_view.setIndexWidget(
proxy_model.index(row,
self.remap_view.model().columnCount() - 1),
lc_classes)
self.remap_view.setSelectionBehavior(
QtWidgets.QAbstractItemView.SelectRows)
self.remap_view.setColumnWidth(1, 450)
self.remap_view.horizontalHeader().setStretchLastSection(True)
return True
def __init__(self, llegenda, nom='Llegenda', vertical=True):
super().__init__()
self.llegenda = llegenda
self.items = dict()
self.botons = dict()
self.setWindowTitle(nom)
if vertical:
self.setLayout(qgWdg.QVBoxLayout())
else:
self.setLayout(qgWdg.QHBoxLayout())
self.funcioFiltre = None
self.funcioBoto = None
def _initStats(self, statsWidget=False):
"""Initialize statistics tab.
:param statsWidget: True to create plot widget otherwise info
QLabel is displayed
"""
# use grid layout
if not hasattr(self, "_statsLayout"):
self._statsLayout = QtWidgets.QGridLayout(self.groupStats)
if not hasattr(self, "_statsWidget"):
self._statsWidget = SafecastStats(self.groupStats)
self._statsWidget.setHeaderHidden(True)
if not hasattr(self, "_statsLabel"):
self._statsLabel = QtWidgets.QLabel(
self.
tr("Load or select Safecast layer in order to display ader statistics."
), self.groupStats)
self._statsLabel.setWordWrap(True)
self._statsSpacer = QtWidgets.QSpacerItem(
20, 40, QtWidgets.QSizePolicy.Minimum,
QtWidgets.QSizePolicy.Expanding)
self._statsLayout.addWidget(self._statsLabel)
self._statsLayout.addItem(self._statsSpacer)
self._statsWidget.setVisible(False)
self._statsVisible = False
return # initialization done
if statsWidget and not self._statsVisible:
# remove info label & spacer from layout
self._statsLabel.setVisible(False)
self._statsLayout.removeWidget(self._statsLabel)
self._statsLayout.removeItem(self._statsSpacer)
# add stats widget into layout
self._statsWidget.setVisible(True)
self._statsLayout.addWidget(self._statsWidget)
self._statsVisible = True
self.groupStats.adjustSize()
elif not statsWidget and self._statsVisible:
# remove plot widget from layout
self._statsWidget.setVisible(False)
self._plotLayout.removeWidget(self._statsWidget)
self._statsVisible = False
# add info label & spacer into layout
self._statsLabel.setVisible(True)
self._statsLayout.addWidget(self._statsLabel)
self._statsLayout.addItem(self._statsSpacer)
# set group tile
self.groupStats.setTitle(self.tr("Statistics"))
def _initPlot(self, plotWidget=False):
"""Initialize plot tab.
:param plotWidget: True to create plot widget otherwise info
QLabel is displayed
"""
# use grid layout if not defined
if not hasattr(self, "_plotLayout"):
self._plotLayout = QtWidgets.QGridLayout(self.groupPlot)
# create new plot widget
if not hasattr(self, "_plotWidget") and not plotMsg:
self._plotWidget = SafecastPlot(self.groupPlot)
self._plotWidget.setVisible(False)
if not hasattr(self, "_plotLabel"):
self._plotLabel = QtWidgets.QLabel(
self.
tr("Load or select Safecast layer in order to display ader plot."
) if not plotMsg else plotMsg, self.groupPlot)
self._plotLabel.setWordWrap(True)
self._plotSpacer = QtWidgets.QSpacerItem(
20, 40, QtWidgets.QSizePolicy.Minimum,
QtWidgets.QSizePolicy.Expanding)
self._plotLayout.addWidget(self._plotLabel)
self._plotLayout.addItem(self._plotSpacer)
self._plotVisible = False
return # initialization done
if plotWidget and not self._plotVisible:
# remove info label & spacer from layout
self._plotLabel.setVisible(False)
self._plotLayout.removeWidget(self._plotLabel)
self._plotLayout.removeItem(self._plotSpacer)
# add plot widget into layout
self._plotWidget.setVisible(True)
self._plotLayout.addWidget(self._plotWidget)
self._plotVisible = True
self.groupPlot.adjustSize()
elif not plotWidget and self._plotVisible:
# remove plot widget from layout
self._plotWidget.setVisible(False)
self._plotLayout.removeWidget(self._plotLabel)
self._plotVisible = False
# add info label & spacer into layout
self._plotLabel.setVisible(True)
self._plotLayout.addWidget(self._plotLabel)
self._plotLayout.addItem(self._plotSpacer)
# set group tile
self.groupPlot.setTitle(self.tr("Plot"))
def createSec(self):
odmpath = self.odmText.text()
axispath = self.axisText.text()
if not os.path.exists(odmpath):
QtWidgets.QMessageBox("Error", "Odm file not found.")
return
if not os.path.exists(axispath):
QtWidgets.QMessageBox("Error", "Axis file not found.")
return
outpath = QtWidgets.QFileDialog.getSaveFileName(
caption="Select output file", filter="*.qpalsWSM")
if isinstance(outpath, tuple):
outpath = outpath[0]
self.WSMProj.odmpath = odmpath
self.WSMProj.axispath = axispath
self.WSMProj.savepath = outpath[0]
self.WSMProj.overlap = self.overlapSpin.value()
self.WSMProj.depth = self.depthSpin.value()
self.WSMProj.width = self.widthSpin.value()
self.WSMProj.attr = self.attrSel.currentText()
self.prjBox.setEnabled(False)
module = QpalsModuleBase.QpalsModuleBase(execName=os.path.join(
self.project.opalspath, "opalsSection.exe"),
QpalsProject=self.project)
infile = QpalsParameter('inFile', odmpath, None, None, None, None,
None)
axisfile = QpalsParameter('axisFile', axispath, None, None, None, None,
None)
attribute = QpalsParameter('attribute', self.attrSel.currentText(),
None, None, None, None, None)
overlap = QpalsParameter('overlap',
str(self.overlapSpin.value() / 100), None,
None, None, None, None)
thickness = QpalsParameter(
'patchSize',
'%s;%s' % (self.widthSpin.value(), self.depthSpin.value()), None,
None, None, None, None)
outParamFileH = tempfile.NamedTemporaryFile(suffix='.xml', delete=True)
self.outParamFile = outParamFileH.name
outParamFileH.close()
outParamFileParam = QpalsParameter('outParamFile', self.outParamFile,
None, None, None, None, None)
module.params += [
infile, axisfile, thickness, attribute, overlap, outParamFileParam
]
thread, worker = module.run_async(status=self.update_status,
on_finish=self.parse_output,
on_error=self.sec_error)
self.threads.append(thread)
self.workers.append(worker)
def test_calcall(self, mock_messagebar):
db_utils.sql_alter_db('''INSERT INTO obs_points (obsid, h_toc) VALUES ('rb1', 1)''')
db_utils.sql_alter_db('''INSERT into w_levels (obsid, meas, date_time) VALUES ('rb1', 222, '2005-01-01 00:00:00')''')
self.calclvl.FromDateTime = QtWidgets.QDateTimeEdit()
self.calclvl.FromDateTime.setDateTime(datestring_to_date('2000-01-01 00:00:00'))
self.calclvl.ToDateTime = QtWidgets.QDateTimeEdit()
self.calclvl.ToDateTime.setDateTime(datestring_to_date('2010-01-01 00:00:00'))
self.calclvl.calcall()
test_string = utils_for_tests.create_test_string(
db_utils.sql_load_fr_db('SELECT obsid, date_time, meas, h_toc, level_masl FROM w_levels'))
reference_string = '(True, [(rb1, 2005-01-01 00:00:00, 222.0, 1.0, -221.0)])'
assert test_string == reference_string
def addFoundItem(self, layer, feature, attrname, value):
'''We found an item so add it to the found list.'''
self.resultsTable.insertRow(self.found)
self.results.append([layer, feature])
self.resultsTable.setItem(self.found, 0,
QtWidgets.QTableWidgetItem(value))
self.resultsTable.setItem(self.found, 1,
QtWidgets.QTableWidgetItem(layer.name()))
self.resultsTable.setItem(self.found, 2,
QtWidgets.QTableWidgetItem(attrname))
self.resultsTable.setItem(
self.found, 3, QtWidgets.QTableWidgetItem(str(feature.id())))
self.found += 1
