def __init__(self, rows, columns):
QWidget.__init__(self)
self.table = QTableWidget(rows, columns, self)
for column in range(columns):
for row in range(rows):
item = QTableWidgetItem('Text%d' % row)
if row % 2:
item.setFlags(Qt.ItemIsUserCheckable | Qt.ItemIsEnabled)
item.setCheckState(Qt.Unchecked)
self.table.setItem(row, column, item)
self.table.itemClicked.connect(self.handleItemClicked)
layout = QVBoxLayout(self)
layout.addWidget(self.table)
self._list = []
def clear_table(self):
self.need_to_update_graph = False
for r in range(self.table.rowCount()):
self.table.setItem(r, 0, QTableWidgetItem(None))
self.table.setItem(r, 1, QTableWidgetItem(None))
for row in range(self.rows_nr):
for col in range(self.cols_nr):
if self.edit_type == self.edit_patterns:
if col == 0:
item = QTableWidgetItem(str(row))
self.table.setItem(row, col, item)
item.setFlags(QtCore.Qt.ItemIsSelectable)
# elif col == 1 and row == 0:
# item = QTableWidgetItem(str(1))
# self.table.setItem(row, col, item)
# item.setFlags(QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled)
# elif self.edit_type == self.edit_curves:
# if row == 0:
# item = QTableWidgetItem(str(0))
# self.table.setItem(row, 0, item)
# item = QTableWidgetItem(str(1))
# self.table.setItem(row, 1, item)
# item.setFlags(QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled)
self.need_to_update_graph = True
def setTableContent(self):
params = self._alg.parameters
outputs = self._alg.outputs
visibleParams = [p for p in params if not p.hidden]
visibleOutputs = [p for o in outputs if not o.hidden]
self.tableWidget.setRowCount(len(visibleParams) + len(visibleOutputs))
for i, param in visibleParams:
item = QTableWidgetItem(param.description)
item.setFlags(Qt.ItemIsEnabled)
self.tableWidget.setItem(i, 0, item)
item = self.getWidgetFromParameter(param)
self.valueItems[param.name] = item
self.tableWidget.setCellWidget(i, 1, item)
self.tableWidget.setRowHeight(i, 22)
for i, output in visibleOutputs:
item = QTableWidgetItem(output.description + '<'
+ output.__module__.split('.')[-1] + '>')
item.setFlags(Qt.ItemIsEnabled)
self.tableWidget.setItem(i, 0, item)
item = QLineEdit()
if hasattr(item, 'setPlaceholderText'):
item.setPlaceholderText(ModelerParametersDialog.ENTER_NAME)
self.valueItems[output.name] = item
self.tableWidget.setCellWidget(i, 1, item)
self.tableWidget.setRowHeight(i, 22)
def _refresh_defects_list(self):
if self.layer is None:
return
self._clear_defects_list()
excluded_fields = self._get_excluded_columns_list()
fields = []
for f in self.layer.fields():
if not f.name() in excluded_fields:
fields.append(f.name())
labels = [self.layer.attributeAlias(i) for i in range(len(fields))]
self.defects_list.setColumnCount(len(fields))
self.defects_list.setHorizontalHeaderLabels(labels)
row = 0
for feature in self._get_features():
self.defects_list.insertRow(row)
column = 0
for field in fields:
if type(feature[field]) is QDateTime:
item = QTableWidgetItem(feature[field].toString())
elif type(feature[field]) is long \
or type(feature[field]) is int:
item = QCustomTableWidgetItem(str(feature[field]))
else:
item = QTableWidgetItem(str(feature[field]))
item.setData(Qt.UserRole, feature.id())
item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
self.defects_list.setItem(row, column, item)
column += 1
row += 1
self.defects_list.resizeColumnsToContents()
def setTableContent(self):
numOutputs = 0
for output in self.alg.outputs:
if isinstance(output, (OutputVector, OutputRaster)):
if not output.flags() & QgsProcessingParameterDefinition.FlagHidden:
numOutputs += 1
self.tblStyles.setRowCount(numOutputs)
i = 0
for output in self.alg.outputs:
if isinstance(output, (OutputVector, OutputRaster)):
if not output.flags() & QgsProcessingParameterDefinition.FlagHidden:
item = QTableWidgetItem(output.description() + '<' +
output.__class__.__name__ + '>')
item.setFlags(Qt.ItemIsEnabled)
self.tblStyles.setItem(i, 0, item)
item = RenderingStyleFilePanel()
style = \
RenderingStyles.getStyle(self.alg.id(),
output.name())
if style:
item.setText(str(style))
self.valueItems[output.name()] = item
self.tblStyles.setCellWidget(i, 1, item)
self.tblStyles.setRowHeight(i, 22)
i += 1
def __init__(self, title=None, data=None):
super(FactorInputDialog, self).__init__(None)
self.setupUi(self)
if not title:
title = self.tr("Enter values")
self.title = title
self.combinationValue = None # Combine formula
self.rasterMatrixValue = None # Rasters involved
self.data = data # data to populate the selected raster table
# table widget Setup
rNum = len(data)
self.tableWidget.setRowCount(rNum)
# Populate the widget table with the selected rasters
row = 0
for tup in self.data:
col = 0
for item in tup:
cellinfo = QTableWidgetItem(item)
if col == 1 or col == 2:
cellinfo.setFlags(QtCore.Qt.ItemIsEnabled)
#cellinfo.setFlags(QtCore.Qt.ItemIsEditable | QtCore.Qt.ItemIsEnabled) # make cell not editable
self.tableWidget.setItem(row, col, cellinfo)
col += 1
row += 1
def drawDataTable(
self,
tab): # Called when user switches tabWidget to the Table Preview
if tab != 1 or self.needsRedraw == False: return
fields = self.fields
self.dataTable.clear()
self.repaint()
self.dataTable.setColumnCount(len(fields))
self.dataTable.setRowCount(self.provider.featureCount())
header = []
for i in fields.values():
header.append(i.name())
self.dataTable.setHorizontalHeaderLabels(header)
self.progressBar.setRange(0, len(self.data) + 1)
self.progressBar.setFormat(self.tr('Drawing table') + ': %p%')
formatting = True
if formatting: # slower procedure, with formatting the table items
for i in range(len(self.data)):
self.progressBar.setValue(i + 1)
for j in range(len(self.data[i])):
item = QTableWidgetItem(unicode(self.data[i][j] or 'NULL'))
item.setFlags(Qt.ItemIsSelectable)
if fields[i].type() == 6 or fields[i].type() == 2:
item.setTextAlignment(Qt.AlignRight | Qt.AlignVCenter)
self.dataTable.setItem(j, i, item)
else: # about 25% faster procedure, without formatting
for i in range(len(self.data)):
self.progressBar.setValue(i + 1)
for j in range(len(self.data[i])):
self.dataTable.setItem(
j, i,
QTableWidgetItem(unicode(self.data[i][j] or 'NULL')))
self.dataTable.resizeColumnsToContents()
self.needsRedraw = False
self.progressBar.reset()
def setTableContent(self):
numOutputs = 0
for output in self.alg.outputs:
if isinstance(output, (OutputVector, OutputRaster)):
if not output.hidden:
numOutputs += 1
self.tblStyles.setRowCount(numOutputs)
i = 0
for output in self.alg.outputs:
if isinstance(output, (OutputVector, OutputRaster)):
if not output.hidden:
item = QTableWidgetItem(output.description + '<' +
output.__class__.__name__ + '>')
item.setFlags(Qt.ItemIsEnabled)
self.tblStyles.setItem(i, 0, item)
item = RenderingStyleFilePanel()
style = \
RenderingStyles.getStyle(self.alg.commandLineName(),
output.name)
if style:
item.setText(str(style))
self.valueItems[output.name] = item
self.tblStyles.setCellWidget(i, 1, item)
self.tblStyles.setRowHeight(i, 22)
i += 1
def setTableContent(self):
params = self._alg.parameters
outputs = self._alg.outputs
visibleParams = [p for p in params if not p.hidden]
visibleOutputs = [p for o in outputs if not o.hidden]
self.tableWidget.setRowCount(len(visibleParams) + len(visibleOutputs))
for i, param in visibleParams:
item = QTableWidgetItem(param.description)
item.setFlags(Qt.ItemIsEnabled)
self.tableWidget.setItem(i, 0, item)
item = self.getWidgetFromParameter(param)
self.valueItems[param.name] = item
self.tableWidget.setCellWidget(i, 1, item)
self.tableWidget.setRowHeight(i, 22)
for i, output in visibleOutputs:
item = QTableWidgetItem(output.description + '<' +
output.__module__.split('.')[-1] + '>')
item.setFlags(Qt.ItemIsEnabled)
self.tableWidget.setItem(i, 0, item)
item = QLineEdit()
if hasattr(item, 'setPlaceholderText'):
item.setPlaceholderText(ModelerParametersDialog.ENTER_NAME)
self.valueItems[output.name] = item
self.tableWidget.setCellWidget(i, 1, item)
self.tableWidget.setRowHeight(i, 22)
def setTableContent(self):
numOutputs = 0
for output in self.alg.outputs:
if isinstance(output, (OutputVector, OutputRaster)):
if not output.hidden:
numOutputs += 1
self.tblStyles.setRowCount(numOutputs)
i = 0
for output in self.alg.outputs:
if isinstance(output, (OutputVector, OutputRaster)):
if not output.hidden:
item = QTableWidgetItem(output.description + '<'
+ output.__class__.__name__ + '>')
item.setFlags(Qt.ItemIsEnabled)
self.tblStyles.setItem(i, 0, item)
item = RenderingStyleFilePanel()
style = \
RenderingStyles.getStyle(self.alg.commandLineName(),
output.name)
if style:
item.setText(unicode(style))
self.valueItems[output.name] = item
self.tblStyles.setCellWidget(i, 1, item)
self.tblStyles.setRowHeight(i, 22)
i += 1
def addLayerFields(self, layer_source):
layer = layer_source.layer
if layer.type() != QgsMapLayer.VectorLayer:
return
for i, field in enumerate(layer.fields()):
row = self.rowCount()
ews = layer.editorWidgetSetup(i)
if ews.type() == 'ExternalResource':
# for later: if ews.config().get('DocumentViewer', QgsExternalResourceWidget.NoContent) == QgsExternalResourceWidget.Image:
self.insertRow(row)
item = QTableWidgetItem(layer.name())
item.setData(Qt.UserRole, layer_source)
item.setFlags(Qt.ItemIsEnabled)
self.setItem(row, 0, item)
item = QTableWidgetItem(field.name())
item.setFlags(Qt.ItemIsEnabled)
self.setItem(row, 1, item)
ew = QgsFieldExpressionWidget()
ew.setLayer(layer)
expression = layer_source.photo_naming(field.name())
ew.setExpression(expression)
self.setCellWidget(row, 2, ew)
self.resizeColumnsToContents()
def update_matrix_list(self):
if self.matrix_count > 0:
self.but_save_for_single_use.setEnabled(True)
self.but_permanent_save.setEnabled(True)
else:
self.but_save_for_single_use.setEnabled(False)
self.but_permanent_save.setEnabled(False)
self.matrix_list_view.clearContents()
self.matrix_list_view.setRowCount(self.matrix_count)
self.matrix_list_view.blockSignals(True)
i = 0
for key, value in self.matrices.items():
r = np.unique(value['from']).shape[0]
c = np.unique(value['to']).shape[0]
dimensions = "{:,}".format(r) + " x " + "{:,}".format(c)
total = "{:,.2f}".format(float(value['flow'].sum()))
item_1 = QTableWidgetItem(key)
self.matrix_list_view.setItem(i, 0, item_1)
item_2 = QTableWidgetItem(dimensions)
item_2.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable)
self.matrix_list_view.setItem(i, 1, item_2)
item_3 = QTableWidgetItem(total)
item_3.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable)
self.matrix_list_view.setItem(i, 2, item_3)
i += 1
self.matrix_list_view.blockSignals(False)
def setTableContent(self):
numOutputs = 0
for output in self.alg.outputDefinitions():
if isinstance(output, (QgsProcessingOutputVectorLayer,
QgsProcessingOutputRasterLayer)):
numOutputs += 1
self.tblStyles.setRowCount(numOutputs)
i = 0
for output in self.alg.outputDefinitions():
if isinstance(output, (QgsProcessingOutputVectorLayer,
QgsProcessingOutputRasterLayer)):
item = QTableWidgetItem(output.description() + '<' +
output.__class__.__name__ + '>')
item.setFlags(Qt.ItemIsEnabled)
self.tblStyles.setItem(i, 0, item)
item = RenderingStyleFilePanel()
style = \
RenderingStyles.getStyle(self.alg.id(),
output.name())
if style:
item.setText(str(style))
self.valueItems[output.name()] = item
self.tblStyles.setCellWidget(i, 1, item)
self.tblStyles.setRowHeight(i, 22)
i += 1
def add_row(self):
row_pos = self.table.rowCount()
self.table.insertRow(row_pos)
col = 0
item = QTableWidgetItem(str(row_pos))
if self.edit_type == self.edit_patterns:
self.table.setItem(row_pos, col, item)
item.setFlags(QtCore.Qt.ItemIsSelectable)
def set_value_widget(self, value, row):
"""
Sets the property value into the given row of the job table.
:param value: str: Property value of the row.
:param row: int: Row number to but the value in
"""
qitem = QTableWidgetItem(str(value))
qitem.setFlags(QtCore.Qt.ItemIsEnabled)
self.jobInfoTableWidget.setItem(row, 1, qitem)
def create_checkbox():
"""
Create a simple checkbox item
:return: QTableWidgetItem - The item to insert
"""
item = QTableWidgetItem()
item.setFlags(Qt.ItemIsUserCheckable | Qt.ItemIsEnabled)
item.setCheckState(Qt.Unchecked)
return item
def insertNewRow(self):
self.tableWidget.insertRow(self.tableWidget.rowCount())
for i in range(self.tableWidget.columnCount()):
editItem = QTableWidgetItem('', 0)
if i == 0:
editItem.setFlags(self.defFlags | Qt.ItemIsUserCheckable)
editItem.setCheckState(Qt.Checked)
else:
editItem.setFlags(self.defFlags)
self.tableWidget.setItem(self.tableWidget.rowCount()-1, i, editItem)
def _set_checkbox_item(self):
"""
Sets the checkbox item
:return: Table widget item
:rtype: Object
"""
check_box = QTableWidgetItem()
check_box.setCheckState(Qt.Checked)
check_box.setFlags(Qt.ItemIsUserCheckable | Qt.ItemIsEnabled | Qt.ItemIsSelectable)
return check_box
def create_label(text):
"""
Create a simple label item
:param text: String - The text to insert inside the cell
:return: QTableWidgetItem - The item to insert
"""
item = QTableWidgetItem(text)
item.setFlags(Qt.NoItemFlags)
item.setTextAlignment(Qt.AlignCenter)
return item
def _getTextCell(self,
text: str,
enabled: bool = False) -> QTableWidgetItem:
widget = QTableWidgetItem(text)
widget.setTextAlignment(Qt.AlignHCenter | Qt.AlignVCenter)
if not enabled:
widget.setFlags(Qt.ItemIsEditable)
return widget
def refresh_jobs(self):
"""
Refreshes the job table, so fetches all jobs of the user from the backend and lists them in the table.
This method also generates the "Execute" and "Display" buttons.
"""
jobs = self.connection.user_jobs()
self.init_jobs()
self.jobsTableWidget.setRowCount(len(jobs))
row = 0
for val in jobs:
if "id" in val:
qitem = QTableWidgetItem(val["id"])
qitem.setFlags(QtCore.Qt.ItemIsEnabled)
self.jobsTableWidget.setItem(row, 0, qitem)
if "error" in val:
if val["error"]:
if "message" in val["error"]:
qitem = QTableWidgetItem(val["error"]["message"])
qitem.setFlags(QtCore.Qt.ItemIsEnabled)
self.jobsTableWidget.setItem(row, 1, qitem)
elif "description" in val:
qitem = QTableWidgetItem(val["description"])
qitem.setFlags(QtCore.Qt.ItemIsEnabled)
self.jobsTableWidget.setItem(row, 1, qitem)
if "submitted" in val:
qitem = QTableWidgetItem(val["submitted"])
qitem.setFlags(QtCore.Qt.ItemIsEnabled)
self.jobsTableWidget.setItem(row, 2, qitem)
execBtn = QPushButton(self.jobsTableWidget)
execBtn.setText('Execute')
if "status" in val:
qitem = QTableWidgetItem(val["status"])
qitem.setFlags(QtCore.Qt.ItemIsEnabled)
self.jobsTableWidget.setItem(row, 3, qitem)
if val["status"] == "finished":
dispBtn = QPushButton(self.jobsTableWidget)
dispBtn.setText('Display')
self.jobsTableWidget.setCellWidget(row, 5, dispBtn)
dispBtn.clicked.connect(
lambda *args, row=row: self.job_display(row))
self.jobsTableWidget.setCellWidget(row, 4, execBtn)
execBtn.clicked.connect(
lambda *args, row=row: self.job_execute(row))
row += 1
def new_process_to_table(self, process_id):
"""
Gets called if a new process is selected at the "add process" combo box.
It loads all arguments with their types into the process table.
"""
self.processTableWidget.clear()
self.cur_process = None
self.cur_node = None
self.cur_row = None
# Set label with the process name and the bold font
pr = self.backend.get_process(process_id)
p_id = self.processIdText.text()
self.processLabel.setText("New Process: {}".format(p_id))
my_font = QtGui.QFont()
my_font.setBold(True)
self.processLabel.setFont(my_font)
self.init_process_table()
self.processTableWidget.setRowCount(len(pr.parameters))
par_row = 0
for param in pr.parameters:
qitem = QTableWidgetItem(param.name)
qitem.setFlags(QtCore.Qt.ItemIsEnabled)
if not param.optional:
bold_font = QFont()
bold_font.setBold(True)
qitem.setFont(bold_font)
self.processTableWidget.setItem(par_row, 0, qitem)
p_type = QTableWidgetItem(str(param.get_type()))
p_type.setFlags(QtCore.Qt.ItemIsEnabled)
self.processTableWidget.setItem(par_row, 1, p_type)
val_item = QTableWidgetItem("")
if "process-graph" in str(param.get_type()):
val_item = QTableWidgetItem('{ "process_graph": {} }')
self.processTableWidget.setItem(par_row, 2, val_item)
self.set_complex_edit_element(param, process_id, "", par_row)
par_row += 1
self.resultCheckBox.setChecked(False)
self.processTableWidget.resizeRowsToContents()
self.cloneprocessButton.setEnabled(False)
def set_property_widget(self, prop, row):
"""
Sets the property name into the given row of the job table.
:param prop: str: Property name of the row.
:param row: int: Row number to but the value in
"""
qitem = QTableWidgetItem(str(prop))
font = QFont()
font.setBold(True)
qitem.setFont(font)
qitem.setFlags(QtCore.Qt.ItemIsEnabled)
self.jobInfoTableWidget.setItem(row, 0, qitem)
def process_selected(self):
"""
Gets called if a new process is selected at the process combobox.
It loads all agruments with their type and an example (if exist) into the value
"""
self.processTableWidget.clear()
for p in self.processes:
if "id" in p:
if p['id'] == str(self.processBox.currentText()):
process = p
if "parameters" in process:
#info(self.iface, "New Process {}".format(process['parameters']))
self.processTableWidget.setRowCount(
len(process['parameters']))
self.processTableWidget.setColumnCount(3)
self.processTableWidget.setHorizontalHeaderLabels(
['Parameter', 'Type', 'Value'])
header = self.processTableWidget.horizontalHeader()
header.setSectionResizeMode(
0, QtWidgets.QHeaderView.ResizeToContents)
header.setSectionResizeMode(
1, QtWidgets.QHeaderView.ResizeToContents)
header.setSectionResizeMode(
2, QtWidgets.QHeaderView.Stretch)
counter = 0
for key, val in process['parameters'].items():
# if key != "data" and key != "imagery":
qitem = QTableWidgetItem(key)
qitem.setFlags(QtCore.Qt.ItemIsEnabled)
if "required" in val:
if val["required"]:
boldFont = QtGui.QFont()
boldFont.setBold(True)
qitem.setFont(boldFont)
self.processTableWidget.setItem(counter, 0, qitem)
if "schema" in val:
if "type" in val["schema"]:
type = QTableWidgetItem(
str(val['schema']['type']))
type.setFlags(QtCore.Qt.ItemIsEnabled)
self.processTableWidget.setItem(
counter, 1, type)
if "examples" in val["schema"]:
example = QTableWidgetItem(
str(val['schema']['examples'][0]))
self.processTableWidget.setItem(
counter, 2, example)
counter += 1
return
else:
info(self.iface, "New Process: Parameters not found")
def create_table(self):
from AcATaMa.gui.acatama_dockwidget import AcATaMaDockWidget as AcATaMa
header = ["Pix Val", "Color", "Select"]
# get color table from raster
thematic_table = {"color_table": get_color_table(
AcATaMa.dockwidget.QCBox_ThematicRaster.currentLayer(),
band=int(AcATaMa.dockwidget.QCBox_band_ThematicRaster.currentText()),
nodata=int(AcATaMa.dockwidget.nodata_ThematicRaster.value()))}
if not thematic_table["color_table"]:
# clear table
self.tableOfClasses.setRowCount(0)
self.tableOfClasses.setColumnCount(0)
return
thematic_table["row_count"] = len(list(thematic_table["color_table"].values())[0])
# init table
self.tableOfClasses.setRowCount(thematic_table["row_count"])
self.tableOfClasses.setColumnCount(3)
# hidden row labels
self.tableOfClasses.verticalHeader().setVisible(False)
# add Header
self.tableOfClasses.setHorizontalHeaderLabels(header)
# insert items
for n, h in enumerate(header):
if h == "Pix Val":
for m, item in enumerate(thematic_table["color_table"]["Pixel Value"]):
item_table = QTableWidgetItem(str(item))
item_table.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
item_table.setTextAlignment(Qt.AlignCenter | Qt.AlignVCenter)
self.tableOfClasses.setItem(m, n, item_table)
if h == "Color":
for m in range(thematic_table["row_count"]):
item_table = QTableWidgetItem()
item_table.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
item_table.setBackground(QColor(thematic_table["color_table"]["Red"][m],
thematic_table["color_table"]["Green"][m],
thematic_table["color_table"]["Blue"][m],
thematic_table["color_table"]["Alpha"][m]))
self.tableOfClasses.setItem(m, n, item_table)
if h == "Select":
for m in range(thematic_table["row_count"]):
item_table = QPushButton("Select this")
item_table.clicked.connect(self.select_clicked)
self.tableOfClasses.setCellWidget(m, n, item_table)
# adjust size of Table
self.tableOfClasses.resizeColumnsToContents()
self.tableOfClasses.resizeRowsToContents()
# adjust the dialog based on table content
dialog_width = self.tableOfClasses.horizontalHeader().length() + 50
self.resize(dialog_width, self.height())
def __init__(self, parent=None):
settings = Settings()
QDialog.__init__(self, parent)
SettingDialog.__init__(self,
setting_manager=settings,
mode=UpdateMode.DialogAccept)
self.setupUi(self)
self.search_line_edit.textChanged.connect(self.filter_rows)
self.select_all_button.pressed.connect(self.select_all)
self.unselect_all_button.pressed.connect(
lambda: self.select_all(False))
self.keep_scale.toggled.connect(self.point_scale.setDisabled)
self.keep_scale.toggled.connect(self.scale_label.setDisabled)
self.skipped_dataproducts.setRowCount(len(DATA_PRODUCTS))
self.skipped_dataproducts.setColumnCount(2)
self.skipped_dataproducts.setHorizontalHeaderLabels(
(self.tr('Name'), self.tr('ID')))
self.skipped_dataproducts.setSelectionBehavior(
QAbstractItemView.SelectRows)
self.skipped_dataproducts.setSelectionMode(
QAbstractItemView.SingleSelection)
r = 0
for _id, name in DATA_PRODUCTS.items():
item = QTableWidgetItem(name)
item.setData(Qt.UserRole, _id)
item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsUserCheckable)
self.skipped_dataproducts.setItem(r, 0, item)
self.skipped_dataproducts.setItem(r, 1, QTableWidgetItem(_id))
r += 1
self.skipped_dataproducts.horizontalHeader().setStretchLastSection(
True)
self.skipped_dataproducts.resizeColumnsToContents()
self.settings = settings
self.init_widgets()
sd_widget: TableWidgetStringListWidget = self.setting_widget(
'skipped_dataproducts')
sd_widget.column = 0
sd_widget.userdata = True
sd_widget.invert = True
self.setting_widget('wms_image_format').auto_populate()
self.setting_widget('default_layer_loading_mode').auto_populate()
self.pg_service.setPlaceholderText(DEFAULT_PG_SERVICE)
self.pg_host.setPlaceholderText(DEFAULT_PG_HOST)
self.service_url.setPlaceholderText(DEFAULT_BASE_URL)
self.pg_host.setShowClearButton(True)
self.service_url.setShowClearButton(True)
def __init__(self, results, onlySymbology, geodataServer, metadataServer,
parent):
super(PublishReportDialog, self).__init__(parent)
self.results = results
self.setupUi(self)
self.tableWidget.horizontalHeader().setSectionResizeMode(
QHeaderView.Stretch)
if geodataServer is not None:
url = geodataServer.url
self.labelUrlMapServer.setText('<a href="%s">%s</a>' % (url, url))
else:
self.labelUrlMapServer.setText("----")
if metadataServer is not None:
url = metadataServer.url
self.labelUrlMetadataServer.setText('<a href="%s">%s</a>' %
(url, url))
else:
self.labelUrlMetadataServer.setText("----")
publishData = geodataServer is not None
self.labelPublishMapData.setText(
"ON" if publishData and not onlySymbology else "OFF")
self.labelPublishSymbology.setText("ON" if publishData else "OFF")
self.labelPublishMetadata.setText(
"ON" if metadataServer is not None else "OFF")
self.tableWidget.setRowCount(len(results))
for i, name in enumerate(results.keys()):
warnings, errors = results[name]
item = QTableWidgetItem(name)
item.setFlags(item.flags() ^ Qt.ItemIsEditable)
self.tableWidget.setItem(i, 0, item)
if geodataServer is not None:
dataPublished = geodataServer.layerExists(name)
stylePublished = geodataServer.styleExists(name)
else:
dataPublished = False
stylePublished = False
item = QTableWidgetItem("Yes" if dataPublished else "No")
item.setFlags(item.flags() ^ Qt.ItemIsEditable)
self.tableWidget.setItem(i, 1, item)
item = QTableWidgetItem("Yes" if stylePublished else "No")
item.setFlags(item.flags() ^ Qt.ItemIsEditable)
self.tableWidget.setItem(i, 2, item)
metadataPublished = metadataServer is not None
item = QTableWidgetItem(
self.tr("Yes") if metadataPublished else self.tr("No"))
item.setFlags(item.flags() ^ Qt.ItemIsEditable)
self.tableWidget.setItem(i, 3, item)
txt = self.tr("warnings(%i), errors(%i)") % (len(warnings),
len(errors))
widget = QWidget()
button = QPushButton()
button.setText(txt)
button.clicked.connect(partial(self.openDetails, name))
layout = QHBoxLayout(widget)
layout.addWidget(button)
layout.setAlignment(Qt.AlignCenter)
layout.setContentsMargins(0, 0, 0, 0)
widget.setLayout(layout)
self.tableWidget.setCellWidget(i, 4, widget)
def _populate_attributes(self, combination):
"""
Populate the attributes
"""
data = list(combination)
self.tableWidget.setRowCount(len(data))
for row_index, row in enumerate(data):
for index in range(4):
item = QTableWidgetItem(str(row[index]))
if index == 0:
item.setFlags(QtCore.Qt.ItemIsEnabled)
self.tableWidget.setItem(row_index, index, item)
self.tableWidget.resizeColumnsToContents()
def drawFieldsTable(
self
): # Draws the fields table on startup and redraws it when changed
fields = self.fields
self.fieldsTable.setRowCount(0)
for i in range(len(fields)):
self.fieldsTable.setRowCount(i + 1)
item = QTableWidgetItem(fields[i].name())
item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
item.setData(Qt.UserRole, i) # set field index
self.fieldsTable.setItem(i, 0, item)
item = QTableWidgetItem(self.formatFieldType(fields[i]))
item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
self.fieldsTable.setItem(i, 1, item)
self.fieldsTable.setColumnWidth(0, 128)
self.fieldsTable.setColumnWidth(1, 96)
def selectSource(self):
'''
source feature selection procedure
'''
if self.layerHighlighted:
self.resetSource()
try:
self.dock.tableWidget.itemChanged.disconnect(self.highLightCellOverride)
except:
pass
#take first selected feature as source feature
self.sourceFeat = self.selectedFeature
#hightlight source feature with rubberband
self.sourceEvid.setToGeometry(self.sourceFeat.geometry(),self.selectedLayer)
#get current layer attributes labels list
field_names = self.scanLayerFieldsNames(self.selectedLayer)
field_types = self.scanLayerFieldsTypes(self.selectedLayer)
self.sourceAttrsTab=[]
self.dock.tableWidget.setRowCount(len(field_names))
#loading attributes labels and values in QTableWidget
for n in range(0,len(field_names)):
item=QTableWidgetItem()
item.setFlags(item.flags() | Qt.ItemIsUserCheckable)
item.setCheckState(Qt.Unchecked)
item.setText("")
#set first column as checkbox
self.dock.tableWidget.setItem(n,0,item)
#set second colunm as attribute label as qcombobox widget
self.dock.tableWidget.setCellWidget(n,1,self.setComboField(field_names[n],field_types[n],self.canvas.currentLayer()))
#set third column as attribute value
item = QTableWidgetItem()
item.setData(Qt.DisplayRole,self.sourceFeat.attributes()[n])
self.dock.tableWidget.setItem(n,2,item)
#resize table to contents
self.dock.tableWidget.resizeColumnsToContents()
self.dock.tableWidget.horizontalHeader().setStretchLastSection(True)
#procedure to recover same field selection if current source feature has the same layer of the precedent one
if self.selectedLayer.id() != self.activeLayer:
self.sourceAttrs={}
self.activeLayer = self.selectedLayer.id()
else:
for Attr in self.sourceAttrs:
self.dock.tableWidget.item(Attr,0).setCheckState(Qt.Checked)
#Enable button to apply or reset
self.dock.ResetSource.setEnabled(True)
self.dock.tableWidget.itemChanged.connect(self.highLightCellOverride)
self.checkOnLayerChange(self.canvas.currentLayer())
def populateLayerFields(self):
if self.currentLayer.type() == self.currentLayer.VectorLayer:
fields = [f.name() for f in self.currentLayer.fields()]
self.tabLayerInfo.setTabEnabled(1, True)
self.tableFields.setRowCount(len(fields))
for i, field in enumerate(fields):
item = QTableWidgetItem()
item.setFlags(item.flags() ^ Qt.ItemIsEditable)
check = Qt.Checked if self.fieldsToPublish[
self.currentLayer][field] else Qt.Unchecked
item.setCheckState(check)
self.tableFields.setItem(i, 0, item)
item = QTableWidgetItem(field)
item.setFlags(item.flags() ^ Qt.ItemIsEditable)
self.tableFields.setItem(i, 1, item)
else:
self.tabLayerInfo.setTabEnabled(1, False)
def onAdd(self, qgs_type_storage: str = "file"):
"""Add a new line to the table.
:param qgs_type_storage: project storage type, defaults to "file"
:type qgs_type_storage: str, optional
"""
row = self.tableWidget.rowCount()
self.tableWidget.setRowCount(row + 1)
# edit button
self.addEditButton(row, qgs_type_storage)
# project name
itemName = QTableWidgetItem()
itemName.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
self.tableWidget.setItem(row, self.cols.name, itemName)
name_lineedit = QLineEdit()
name_lineedit.setPlaceholderText(self.tr("Use project title"))
self.tableWidget.setCellWidget(row, self.cols.name, name_lineedit)
# project storage type
self.tableWidget.setCellWidget(
row, self.cols.type_storage,
self.mk_prj_storage_icon(qgs_type_storage))
# menu location
location_combo = QComboBox()
for pk in self.LOCATIONS:
if not (pk == "merge" and row == 0):
location_combo.addItem(self.LOCATIONS[pk]["label"], pk)
location_combo.setCurrentIndex(0)
self.tableWidget.setCellWidget(row, self.cols.type_menu_location,
location_combo)
# project file path
itemFile = QTableWidgetItem()
itemFile.setData(Qt.UserRole, qgs_type_storage)
itemFile.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
self.tableWidget.setItem(row, self.cols.uri, itemFile)
filepath_lineedit = QLineEdit()
filepath_lineedit.textChanged.connect(self.onTextChanged)
self.tableWidget.setCellWidget(row, self.cols.uri, filepath_lineedit)
# apply table styling
self.tableTunning()
def populate_function_table_1(self):
"""Populate the tblFunctions1 table with available functions."""
hazards = deepcopy(hazard_all)
exposures = exposure_all
self.lblAvailableFunctions1.clear()
self.tblFunctions1.clear()
self.tblFunctions1.setColumnCount(len(hazards))
self.tblFunctions1.setRowCount(len(exposures))
for i in range(len(hazards)):
hazard = hazards[i]
item = QTableWidgetItem()
item.setIcon(QIcon(get_image_path(hazard)))
item.setText(hazard['name'].capitalize())
item.setTextAlignment(Qt.AlignLeft)
self.tblFunctions1.setHorizontalHeaderItem(i, item)
for i in range(len(exposures)):
exposure = exposures[i]
item = QTableWidgetItem()
item.setIcon(QIcon(get_image_path(exposure)))
item.setText(exposure['name'].capitalize())
self.tblFunctions1.setVerticalHeaderItem(i, item)
developer_mode = setting('developer_mode', False, bool)
for hazard in hazards:
for exposure in exposures:
item = QTableWidgetItem()
if (exposure in hazard['disabled_exposures'] and not
developer_mode):
background_colour = unavailable_option_color
# Set it disable and un-selectable
item.setFlags(
item.flags() & ~
Qt.ItemIsEnabled & ~
Qt.ItemIsSelectable
)
else:
background_colour = available_option_color
item.setBackground(QBrush(background_colour))
item.setFont(big_font)
item.setTextAlignment(Qt.AlignCenter | Qt.AlignHCenter)
item.setData(RoleHazard, hazard)
item.setData(RoleExposure, exposure)
self.tblFunctions1.setItem(
exposures.index(exposure), hazards.index(hazard), item)
self.parent.pbnNext.setEnabled(False)
def populate_function_table_1(self):
"""Populate the tblFunctions1 table with available functions."""
hazards = deepcopy(hazard_all)
exposures = exposure_all
self.lblAvailableFunctions1.clear()
self.tblFunctions1.clear()
self.tblFunctions1.setColumnCount(len(hazards))
self.tblFunctions1.setRowCount(len(exposures))
for i in range(len(hazards)):
hazard = hazards[i]
item = QTableWidgetItem()
item.setIcon(QIcon(get_image_path(hazard)))
item.setText(hazard['name'].capitalize())
item.setTextAlignment(Qt.AlignLeft)
self.tblFunctions1.setHorizontalHeaderItem(i, item)
for i in range(len(exposures)):
exposure = exposures[i]
item = QTableWidgetItem()
item.setIcon(QIcon(get_image_path(exposure)))
item.setText(exposure['name'].capitalize())
self.tblFunctions1.setVerticalHeaderItem(i, item)
developer_mode = setting('developer_mode', False, bool)
for hazard in hazards:
for exposure in exposures:
item = QTableWidgetItem()
if (exposure in hazard['disabled_exposures'] and not
developer_mode):
background_colour = unavailable_option_color
# Set it disable and un-selectable
item.setFlags(
item.flags() & ~
Qt.ItemIsEnabled & ~
Qt.ItemIsSelectable
)
else:
background_colour = available_option_color
item.setBackground(QBrush(background_colour))
item.setFont(big_font)
item.setTextAlignment(Qt.AlignCenter | Qt.AlignHCenter)
item.setData(RoleHazard, hazard)
item.setData(RoleExposure, exposure)
self.tblFunctions1.setItem(
exposures.index(exposure), hazards.index(hazard), item)
self.parent.pbnNext.setEnabled(False)
def addCoord(self, lat, lon, label):
'''Add a coordinate to the list.'''
if self.numcoord >= self.maxResults:
return
self.resultsTable.insertRow(self.numcoord)
self.llitems.append(LatLonItem(lat, lon, label))
self.resultsTable.blockSignals(True)
self.resultsTable.setItem(self.numcoord, 2, QTableWidgetItem(label))
item = QTableWidgetItem(str(lat))
item.setFlags(item.flags() & ~Qt.ItemIsEditable)
self.resultsTable.setItem(self.numcoord, 0, item)
item = QTableWidgetItem(str(lon))
item.setFlags(item.flags() & ~Qt.ItemIsEditable)
self.resultsTable.setItem(self.numcoord, 1, item)
self.resultsTable.blockSignals(False)
self.numcoord += 1
if self.showAllCheckBox.checkState():
self.showAllChange()
def addNewRow(self, row=None):
"""
Adds a new row of items and fill it into table.
:param row: (int) position to add the new row.
"""
row = row if row is not None else self.rowCount()
self.tableWidget.insertRow(row)
for col, properties in self.headers.items():
if properties["type"] == "item":
item = QTableWidgetItem()
# it "flips" current state, which, by default, is "editable"
if not properties["editable"]:
item.setFlags(Qt.ItemIsEditable)
self.tableWidget.setItem(row, col, item)
else:
self.tableWidget.setCellWidget(row, col,
properties["widget"]())
self.rowAdded.emit(row)
def setTableContent(self):
self.table.clear()
self.table.setColumnCount(2)
self.table.setColumnWidth(0, 200)
self.table.setColumnWidth(1, 200)
self.table.setHorizontalHeaderLabels(["Name", "URL"])
self.table.horizontalHeader().setResizeMode(QHeaderView.Stretch)
self.table.setRowCount(len(self.remotes))
for i, name in enumerate(self.remotes):
url = self.remotes[name]
self.table.setRowHeight(i, 22)
item = QTableWidgetItem(name, 0)
item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable)
self.table.setItem(i, 0, item)
item = QTableWidgetItem(url, 0)
item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable)
self.table.setItem(i, 1, item)
self.table.itemSelectionChanged.connect(self.selectionChanged)
def restoreState(self,layer,table):
if layer.id() in self.states.keys():
table.blockSignals(True)
#clear dock widget
while table.rowCount()>0:
table.removeRow(0)
#add rows
table.setRowCount(len(self.states[layer.id()]))
for n in range(0, len(self.states[layer.id()])):
row = self.states[layer.id()][n]
#set first column as checkbox
item=QTableWidgetItem()
item.setFlags(item.flags() | Qt.ItemIsUserCheckable)
if row[0]:
item.setCheckState(Qt.Checked)
else:
item.setCheckState(Qt.Unchecked)
item.setText("")
table.setItem(n,0,item)
#set second column as combobox
combo = QComboBox();
combo.addItems(row[1])
#print (row[1],row[2])
combo.setCurrentIndex(row[2])
table.setCellWidget(n,1,combo)
#set third column as attribute value
item = QTableWidgetItem(row[3])
item.setData(Qt.DisplayRole,row[4])
if row[5]:
item.setForeground(QBrush(QColor(0,0,0)))
else:
item.setForeground(QBrush(QColor(130,130,130)))
if row[6]:
item.setBackground(QBrush(QColor(183,213,225)))
table.setItem(n,2,item)
table.blockSignals(False)
return True
else:
return None
def addCoord(self, lat, lon, label='', data=[]):
'''Add a coordinate to the list.'''
rowcnt = self.resultsTable.rowCount()
if rowcnt >= self.maxResults:
return
self.resultsTable.blockSignals(True)
self.resultsTable.insertRow(rowcnt)
item = QTableWidgetItem(str(lat))
item.setData(Qt.UserRole, LatLonItem(lat, lon, label, data))
item.setFlags(item.flags() & ~Qt.ItemIsEditable)
self.resultsTable.setItem(rowcnt, 0, item)
item = QTableWidgetItem(str(lon))
item.setFlags(item.flags() & ~Qt.ItemIsEditable)
self.resultsTable.setItem(rowcnt, 1, item)
self.resultsTable.setItem(rowcnt, 2, QTableWidgetItem(label))
if self.numCol > 3 and len(data) > 0:
for i in range( min(self.numCol-3, len(data))):
self.resultsTable.setItem(rowcnt, i+3, QTableWidgetItem(data[i]))
self.resultsTable.blockSignals(False)
return(rowcnt)
def readConfiguration(self, filePath=None):
if filePath is None:
filePath = self.configFilePath
# Clear the QTableWidget in case it contains any old data
self.tableWidget.clear()
self.tableWidget.setRowCount(0)
# First set up the TableWidget
self.tableWidget.setColumnCount(6)
labels = ['Constraint',
'Schema',
'Table',
'Geometry Column',
'Search Distance',
'Columns For Reporting']
self.tableWidget.setHorizontalHeaderLabels(labels)
# Read the config
config = configparser.ConfigParser()
config.read(filePath)
i = 0
for section in config.sections():
self.tableWidget.insertRow(i)
editItem = QTableWidgetItem(section, 0)
editItem.setFlags(self.defFlags | Qt.ItemIsUserCheckable)
include = config.get(section, 'include')
if include.lower() == 't':
editItem.setCheckState(Qt.Checked)
else:
editItem.setCheckState(Qt.Unchecked)
self.tableWidget.setItem(i, 0, editItem)
schema = config.get(section, 'schema')
editItem = QTableWidgetItem(schema, 0)
editItem.setFlags(self.defFlags)
self.tableWidget.setItem(i, 1, editItem)
table = config.get(section, 'table')
editItem = QTableWidgetItem(table, 0)
editItem.setFlags(self.defFlags)
self.tableWidget.setItem(i, 2, editItem)
geom_col = config.get(section, 'geom_column')
editItem = QTableWidgetItem(geom_col, 0)
editItem.setFlags(self.defFlags)
self.tableWidget.setItem(i, 3, editItem)
buffer_distance = config.get(section, 'buffer_distance')
editItem = QTableWidgetItem(buffer_distance, 0)
editItem.setFlags(self.defFlags)
self.tableWidget.setItem(i, 4, editItem)
columns = config.get(section, 'columns')
editItem = QTableWidgetItem(columns, 0)
editItem.setFlags(self.defFlags)
self.tableWidget.setItem(i, 5, editItem)
i += 1
self.tableWidget.resizeColumnsToContents()
self.tableWidget.setSelectionBehavior(QAbstractItemView.SelectRows)
def update_local_data_sources(self, local_layers, local_raster_layers):
# update table names lookup
local_layers += local_raster_layers
self.update_data_sources_table_names()
self.local_data_sources.update_local_data_sources(local_layers)
# update GUI
self.ui.tblLocalLayers.setRowCount(0)
schema_list = []
if self.ui.cbUploadDatabase.count() == 1:
schema_list = self.fetch_schemas(self.ui.cbUploadDatabase.currentText())
elif self.ui.cbUploadDatabase.currentIndex() > 0:
schema_list = self.fetch_schemas(self.ui.cbUploadDatabase.currentText())
for data_source, layers in list(self.local_data_sources.iteritems()):
layer_names = []
for layer in layers:
layer_names.append(str(layer.name()))
layers_item = QTableWidgetItem(", ".join(layer_names))
layers_item.setToolTip("\n".join(layer_names))
data_source_item = QTableWidgetItem(data_source)
data_source_item.setToolTip(data_source)
# find a better table name if there are multiple layers with same
# data source?
table_name = layers[0].name()
if data_source in self.data_sources_table_names:
# use current table name if available to keep changes by user
table_name = self.data_sources_table_names[data_source]
table_name_item = QTableWidgetItem(self.launder_pg_name(table_name))
if layers[0].providerType() == 'gdal':
geometry_type_item = QTableWidgetItem('Raster')
else:
wkbType = layers[0].wkbType()
if wkbType not in self.GEOMETRY_TYPES:
QMessageBox.warning(self.iface.mainWindow(), self.tr("Unsupported geometry type"), self.tr(
"Unsupported geometry type '{type}' in layer '{layer}'").format(type=self.__wkbTypeString(wkbType), layer=layers[0].name()))
continue
geometry_type_item = QTableWidgetItem(self.GEOMETRY_TYPES[wkbType])
if layers[0].providerType() == "ogr":
geometry_type_item.setToolTip(
self.tr("Note: OGR features will be converted to MULTI-type"))
srid_item = QTableWidgetItem(layers[0].crs().authid())
row = self.ui.tblLocalLayers.rowCount()
self.ui.tblLocalLayers.insertRow(row)
layers_item.setFlags( Qt.ItemIsSelectable | Qt.ItemIsEnabled )
self.ui.tblLocalLayers.setItem(
row, self.COLUMN_LAYERS, layers_item)
data_source_item.setFlags( Qt.ItemIsSelectable | Qt.ItemIsEnabled )
self.ui.tblLocalLayers.setItem(
row, self.COLUMN_DATA_SOURCE, data_source_item)
# create combo box in schema column filled with all schema names of the selected database
cmb_schema = QComboBox()
cmb_schema.setEditable(True)
cmb_schema.addItems(schema_list)
self.ui.tblLocalLayers.setCellWidget(row, self.COLUMN_SCHEMA_NAME, cmb_schema)
table_name_item.setFlags( Qt.ItemIsSelectable | Qt.ItemIsEditable | Qt.ItemIsEnabled )
self.ui.tblLocalLayers.setItem(
row, self.COLUMN_TABLE_NAME, table_name_item)
geometry_type_item.setFlags( Qt.ItemIsSelectable | Qt.ItemIsEnabled )
self.ui.tblLocalLayers.setItem(
row, self.COLUMN_GEOMETRY_TYPE, geometry_type_item)
srid_item.setFlags( Qt.ItemIsSelectable | Qt.ItemIsEnabled )
self.ui.tblLocalLayers.setItem(row, self.COLUMN_SRID, srid_item)
if self.local_data_sources.count() > 0:
self.ui.tblLocalLayers.resizeColumnsToContents()
self.ui.tblLocalLayers.setColumnWidth(self.COLUMN_LAYERS, 100)
self.ui.tblLocalLayers.setColumnWidth(self.COLUMN_DATA_SOURCE, 100)
self.ui.tblLocalLayers.sortItems(self.COLUMN_DATA_SOURCE)
self.ui.tblLocalLayers.setSortingEnabled(False)
else:
self.ui.btnUploadData.setEnabled(False)
self.statusBar().showMessage(self.tr("Updated local data sources"))