def __init__(self, parent, definitions: BaseDefinitions,
edition: Type[QDialog], table, remove_button, edit_button,
up_button, down_button):
self.parent = parent
self.definitions = definitions
self.edition = edition
self.table = table
self.remove_button = remove_button
self.edit_button = edit_button
self.up_button = up_button
self.down_button = down_button
self.table.setColumnCount(len(self.definitions.layer_config.keys()))
for i, item in enumerate(self.definitions.layer_config.values()):
column = QTableWidgetItem(item['header'])
tooltip = item.get('tooltip')
if tooltip:
column.setToolTip(tooltip)
self.table.setHorizontalHeaderItem(i, column)
visible = item.get('visible', True)
if not visible:
self.table.setColumnHidden(i, True)
self.table.setSelectionMode(QAbstractItemView.SingleSelection)
self.table.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.table.setSelectionBehavior(QAbstractItemView.SelectRows)
self.table.setAlternatingRowColors(True)
self.table.cellDoubleClicked.connect(self.edit_existing_row)
# This is a hack to get the layer and then field icons.
self._layer = None
def __refresh_wms_layers(self) -> None:
self.wms_layers = self.wms_layer_handler.list_wms_layers()
self.tbl_wms_layers.setColumnCount(3)
self.tbl_wms_layers.setRowCount(len(self.wms_layers))
for idx, wms_layer in enumerate(self.wms_layers):
self.tbl_wms_layers.setItem(idx, 0, QTableWidgetItem(wms_layer.name))
self.tbl_wms_layers.setItem(idx, 1, QTableWidgetItem(wms_layer.title))
abstract_item = QTableWidgetItem(wms_layer.abstract)
abstract_item.setToolTip(wms_layer.abstract)
self.tbl_wms_layers.setItem(idx, 2, abstract_item)
def display_action(self, row, level, message):
""" Display the action if needed to the user with a color. """
cell = QTableWidgetItem()
cell.setText(message)
cell.setToolTip(message)
if level == Qgis.Success:
color = QColor("green")
elif level == Qgis.Critical:
color = QColor("red")
else:
color = QColor("orange")
cell.setData(Qt.ForegroundRole, QVariant(color))
self.table.setItem(row, 2, cell)
def __refresh_stored_wfs_queries(self) -> None:
self.stored_queries: List[StoredQuery] = self.sq_factory.list_queries(
) # type: ignore # noqa E501
self.tbl_wdgt_stored_queries.setRowCount(len(self.stored_queries))
self.tbl_wdgt_stored_queries.setColumnCount(3)
for i, sq in enumerate(self.stored_queries):
self.tbl_wdgt_stored_queries.setItem(i, 0,
QTableWidgetItem(sq.title))
abstract_item = QTableWidgetItem(sq.abstract)
abstract_item.setToolTip(sq.abstract)
self.tbl_wdgt_stored_queries.setItem(i, 1, abstract_item)
id_item = QTableWidgetItem(sq.id)
id_item.setToolTip(sq.id)
self.tbl_wdgt_stored_queries.setItem(i, 2, id_item)
def bandSelected(self, action):
layer_id = action.data()[0]
layerBand = action.data()[1]
j = action.data()[2]
toggleAll = action.data()[3]
activeBands = self.layerBands[layer_id] if (
layer_id in self.layerBands) else []
# special actions All/None
if layerBand == -1:
for layer in [ltl.layer() for ltl in self.legend.findLayers()]:
if layer.id() == layer_id:
if toggleAll:
activeBands = list(range(1, layer.bandCount() + 1))
else:
activeBands = []
# toggle all band# actions
group = action.parent()
if group and not isinstance(group, QActionGroup):
group = None
if group:
group.blockSignals(True)
for a in group.actions():
if a.isCheckable():
a.setChecked(toggleAll)
group.blockSignals(False)
# any Band# action
else:
if action.isChecked():
activeBands.append(layerBand)
else:
if layerBand in activeBands:
activeBands.remove(layerBand)
activeBands.sort()
self.layerBands[layer_id] = activeBands
# update UI
item = QTableWidgetItem(str(activeBands))
item.setToolTip(str(activeBands))
self.selectionTable.setItem(j, 3, item)
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)
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)
self.ui.tblLocalLayers.setItem(
row, self.COLUMN_LAYERS, layers_item)
self.ui.tblLocalLayers.setItem(
row, self.COLUMN_DATA_SOURCE, data_source_item)
self.ui.tblLocalLayers.setItem(
row, self.COLUMN_TABLE_NAME, table_name_item)
self.ui.tblLocalLayers.setItem(
row, self.COLUMN_GEOMETRY_TYPE, geometry_type_item)
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"))
def __init__(self, parent=None, unicity=None):
super().__init__(parent, unicity)
self.setupUi(self)
self.parent = parent
self.config = DatavizDefinitions()
self.config.add_layer_widget('title', self.title)
self.config.add_layer_widget('type', self.type_graph)
self.config.add_layer_widget('description', self.text_description)
self.config.add_layer_widget('layerId', self.layer)
self.config.add_layer_widget('x_field', self.x_field)
self.config.add_layer_widget('aggregation', self.aggregation)
self.config.add_layer_widget('traces', self.traces)
self.config.add_layer_widget('html_template', self.html_template)
self.config.add_layer_widget('layout', self.json_layout)
self.config.add_layer_widget('horizontal', self.horizontal)
self.config.add_layer_widget('stacked', self.stacked)
self.config.add_layer_widget('popup_display_child_plot',
self.popup_display_child_plot)
self.config.add_layer_widget('only_show_child', self.only_show_child)
self.config.add_layer_widget('display_legend', self.display_legend)
self.config.add_layer_widget('display_when_layer_visible',
self.display_when_layer_visible)
self.config.add_layer_label('title', self.label_title)
self.config.add_layer_label('type', self.label_type)
self.config.add_layer_label('description', self.label_description)
self.config.add_layer_label('layerId', self.label_layer)
self.config.add_layer_label('x_field', self.label_x_field)
self.config.add_layer_label('aggregation', self.label_aggregation)
self.config.add_layer_label('traces', self.label_traces)
self.config.add_layer_label('html_template', self.label_html_template)
self.config.add_layer_label('html_template', self.label_layout)
# noinspection PyCallByClass,PyArgumentList
self.add_trace.setText('')
self.add_trace.setIcon(
QIcon(QgsApplication.iconPath('symbologyAdd.svg')))
self.add_trace.setToolTip(tr('Add a new trace to the chart.'))
self.remove_trace.setText('')
self.remove_trace.setIcon(
QIcon(QgsApplication.iconPath('symbologyRemove.svg')))
self.remove_trace.setToolTip(
tr('Remove the selected trace from the chart.'))
# Set traces table
items = self.config.layer_config['traces']['items']
self.traces.setColumnCount(len(items))
for i, item in enumerate(items):
sub_definition = self.config.layer_config[item]
column = QTableWidgetItem(sub_definition['header'])
column.setToolTip(sub_definition['tooltip'])
self.traces.setHorizontalHeaderItem(i, column)
header = self.traces.horizontalHeader()
header.setSectionResizeMode(QHeaderView.ResizeToContents)
header.setSectionResizeMode(0, QHeaderView.Stretch)
self.traces.setSelectionMode(QAbstractItemView.SingleSelection)
self.traces.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.traces.setSelectionBehavior(QAbstractItemView.SelectRows)
self.traces.setAlternatingRowColors(True)
self.layer.setFilters(QgsMapLayerProxyModel.VectorLayer)
self.layer.layerChanged.connect(self.current_layer_changed)
self.x_field.setLayer(self.layer.currentLayer())
self.type_graph.currentTextChanged.connect(self.check_form_graph_type)
self.add_trace.clicked.connect(self.add_new_trace)
self.remove_trace.clicked.connect(self.remove_selection)
self.lwc_versions[LwcVersions.Lizmap_3_4] = [self.label_graph_34]
self.setup_ui()
self.check_form_graph_type()
def __init__(self, parent, table, add_button, remove_button, edit_button,
refresh_button, label_no_server, up_button, down_button):
self.parent = parent
self.table = table
self.add_button = add_button
self.remove_button = remove_button
self.edit_button = edit_button
self.refresh_button = refresh_button
self.up_button = up_button
self.down_button = down_button
self.label_no_server = label_no_server
# Network
self.fetchers = {}
# Icons and tooltips
self.remove_button.setIcon(
QIcon(QgsApplication.iconPath('symbologyRemove.svg')))
self.remove_button.setText('')
self.remove_button.setToolTip(
tr('Remove the selected server from the list'))
self.add_button.setIcon(
QIcon(QgsApplication.iconPath('symbologyAdd.svg')))
self.add_button.setText('')
self.add_button.setToolTip(tr('Add a new server in the list'))
self.edit_button.setIcon(
QIcon(QgsApplication.iconPath('symbologyEdit.svg')))
self.edit_button.setText('')
self.edit_button.setToolTip(tr('Edit the selected server in the list'))
self.refresh_button.setIcon(
QIcon(QgsApplication.iconPath('mActionRefresh.svg')))
self.refresh_button.setText('')
self.refresh_button.setToolTip(tr('Refresh all servers'))
self.up_button.setIcon(
QIcon(QgsApplication.iconPath('mActionArrowUp.svg')))
self.up_button.setText('')
self.up_button.setToolTip(tr('Move the server up'))
self.down_button.setIcon(
QIcon(QgsApplication.iconPath('mActionArrowDown.svg')))
self.down_button.setText('')
self.down_button.setToolTip(tr('Move the server down'))
# Table
self.table.setColumnCount(3)
self.table.setSelectionMode(QAbstractItemView.SingleSelection)
self.table.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.table.setSelectionBehavior(QAbstractItemView.SelectRows)
self.table.setAlternatingRowColors(True)
self.table.cellDoubleClicked.connect(self.edit_row)
# Headers
header = self.table.horizontalHeader()
header.setSectionResizeMode(QHeaderView.ResizeToContents)
item = QTableWidgetItem(tr('URL'))
item.setToolTip(tr('URL of the server.'))
self.table.setHorizontalHeaderItem(0, item)
item = QTableWidgetItem(tr('Version'))
item.setToolTip(tr('Version detected on the server'))
self.table.setHorizontalHeaderItem(1, item)
item = QTableWidgetItem(tr('Action'))
item.setToolTip(tr('If there is any action to do on the server'))
self.table.setHorizontalHeaderItem(2, item)
# Connect
self.add_button.clicked.connect(self.add_row)
self.remove_button.clicked.connect(self.remove_row)
self.edit_button.clicked.connect(self.edit_row)
self.refresh_button.clicked.connect(self.refresh_table)
self.up_button.clicked.connect(self.move_server_up)
self.down_button.clicked.connect(self.move_server_down)
# Actions
self.load_table()
def update_layers(self):
if self.tabWidget.currentIndex() != 2:
return
if self.layerSelection.currentIndex() == 3: # by selection string
self.selectionStringLineEdit.setEnabled(True)
else:
self.selectionStringLineEdit.setEnabled(False)
if self.layerSelection.currentIndex() == 0: # visible layers
layers = self.activeRasterLayers(0)
elif self.layerSelection.currentIndex() == 3: # by selection string
layers = self.activeRasterLayers(3)
else:
layers = self.activeRasterLayers(1) # All layers
self.selectionTable.blockSignals(True)
self.selectionTable.clearContents()
self.selectionTable.setRowCount(len(layers))
self.selectionTable.horizontalHeader().resizeSection(0, 20)
self.selectionTable.horizontalHeader().resizeSection(2, 20)
j = 0
for layer in layers:
item = QTableWidgetItem()
item.setFlags(item.flags() | Qt.ItemIsUserCheckable)
if self.layerSelection.currentIndex() != 2:
item.setFlags(item.flags() & ~Qt.ItemIsEnabled)
item.setCheckState(Qt.Checked)
else:
# manual selection
if layer.id() in self.layersSelected:
item.setCheckState(Qt.Checked)
else:
item.setCheckState(Qt.Unchecked)
self.selectionTable.setItem(j, 0, item)
item = QTableWidgetItem(layer.name())
item.setData(Qt.UserRole, layer.id())
self.selectionTable.setItem(j, 1, item)
activeBands = self.activeBandsForRaster(layer)
button = QToolButton()
button.setIcon(QIcon(':/plugins/mutant/img/bands.jpg'))
# button.setIconSize(QtCore.QSize(400, 400))
button.setPopupMode(QToolButton.InstantPopup)
group = QActionGroup(button)
group.setExclusive(False)
group.triggered.connect(self.bandSelected)
if self.bandSelection.currentIndex(
) == 2 and layer.bandCount() > 1:
menu = QMenu()
menu.installEventFilter(self)
for iband in range(1, layer.bandCount() + 1):
action = QAction(str(layer.bandName(iband)), group)
action.setData([layer.id(), iband, j, False])
action.setCheckable(True)
action.setChecked(iband in activeBands)
menu.addAction(action)
if layer.bandCount() > 1:
action = QAction(str(self.tr("All")), group)
action.setData([layer.id(), -1, j, True])
action.setCheckable(False)
menu.addAction(action)
action = QAction(str(self.tr("None")), group)
action.setData([layer.id(), -1, j, False])
action.setCheckable(False)
menu.addAction(action)
button.setMenu(menu)
else:
button.setEnabled(False)
self.selectionTable.setCellWidget(j, 2, button)
item = QTableWidgetItem(str(activeBands))
item.setToolTip(str(activeBands))
self.selectionTable.setItem(j, 3, item)
j += 1
self.selectionTable.blockSignals(False)
def __init__(self, parent, definitions: BaseDefinitions,
edition: Type[QDialog], table, remove_button, edit_button,
up_button, down_button):
self.parent = parent
self.definitions = definitions
self.edition = edition
self.table = table
self.remove_button = remove_button
self.edit_button = edit_button
self.up_button = up_button
self.down_button = down_button
self.lwc_versions = list()
self.lwc_versions.append(LwcVersions.Lizmap_3_1)
self.lwc_versions.append(LwcVersions.Lizmap_3_2)
self.lwc_versions.append(LwcVersions.Lizmap_3_3)
self.lwc_versions.append(LwcVersions.Lizmap_3_4)
self.keys = [
i for i, j in self.definitions.layer_config.items()
if j.get('plural') is None
]
self.table.setColumnCount(len(self.keys))
for i, key in enumerate(self.keys):
item = self.definitions.layer_config[key]
column = QTableWidgetItem(item['header'])
tooltip = item.get('tooltip')
if tooltip:
column.setToolTip(tooltip)
self.table.setHorizontalHeaderItem(i, column)
self.table.setSelectionMode(QAbstractItemView.SingleSelection)
self.table.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.table.setSelectionBehavior(QAbstractItemView.SelectRows)
self.table.setAlternatingRowColors(True)
self.table.cellDoubleClicked.connect(self.edit_existing_row)
# This is a hack to get the layer and then field icons.
self._layer = None
# header = self.table.horizontalHeader()
# header.setSectionResizeMode(QHeaderView.ResizeToContents)
# header.setSectionResizeMode(0, QHeaderView.Stretch)
if self.definitions.key() == 'datavizLayers' and self.parent:
self.definitions.add_general_widget('datavizLocation',
self.parent.liDatavizContainer)
self.definitions.add_general_widget('datavizTemplate',
self.parent.inDatavizTemplate)
self.definitions.add_general_widget('theme',
self.parent.combo_theme)
self.definitions.add_general_label(
'datavizLocation', self.parent.label_dataviz_location)
self.definitions.add_general_label(
'datavizTemplate', self.parent.label_dataviz_template)
self.definitions.add_general_label('theme',
self.parent.label_dataviz_theme)
# Set tooltips
for general_config in self.definitions.general_config.values():
widget = general_config.get('widget')
if not widget:
continue
tooltip = general_config.get('tooltip')
if tooltip:
widget.setToolTip(tooltip)
label = general_config.get('label')
if label:
label.setToolTip(tooltip)
# Set versions
current_version = QgsSettings().value(
'lizmap/lizmap_web_client_version', DEFAULT_LWC_VERSION.value, str)
current_version = LwcVersions(current_version)
self.set_lwc_version(current_version)
def populateLayerTable(self, layerType):
"""
Fill the table for a given layer type
"""
# Get parameters for the widget
lt = self.layersTable[layerType]
table = lt['tableWidget']
# Reset layerBoardChangedData
self.layerBoardChangedData[layerType] = {}
# disconnect itemChanged signal
try:
table.itemChanged.disconnect()
except Exception:
pass
attributes = self.layersTable['generic']['attributes'] + lt['attributes']
self.layersAttributes[layerType] = attributes
self.layerBoardData[layerType] = []
headerData = [a['key'] for a in attributes]
self.layerBoardData[layerType].append(headerData)
# empty previous content
for row in range(table.rowCount()):
table.removeRow(row)
table.setRowCount(0)
table.setColumnCount(0)
# create columns and header row
columns = [a['key'] for a in attributes]
columnsLabels = [a['label'] for a in attributes]
colCount = len(columns)
table.setColumnCount(colCount)
table.setHorizontalHeaderLabels(tuple(columnsLabels))
# load content from project layers
lr = QgsProject().instance()
for lid in lr.mapLayers():
layer = lr.mapLayer(lid)
if layerType == 'vector' and layer.type() != QgsMapLayer.VectorLayer:
continue
if layerType == 'raster' and layer.type() != QgsMapLayer.RasterLayer:
continue
# Add layer in the layerBoardChangedData
self.layerBoardChangedData[layerType][lid] = {}
lineData = []
# Set row and column count
twRowCount = table.rowCount()
# add a new line
table.setRowCount(twRowCount + 1)
table.setColumnCount(colCount)
i = 0
# get information
for attr in attributes:
newItem = QTableWidgetItem()
newItem.setToolTip(layer.name())
if layerType == 'vector' and not layer.isSpatial() and attr.get('spatial_only'):
newItem.setFlags(Qt.NoItemFlags)
# Is editable or not
elif attr.get('editable'):
newItem.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEditable | Qt.ItemIsEnabled)
else:
newItem.setFlags(Qt.ItemIsSelectable)
# Item value
if layerType == 'vector' and not layer.isSpatial() and attr.get('spatial_only'):
value = None
else:
value = self.getLayerProperty(layer, attr['key'])
newItem.setData(Qt.EditRole, value)
# Add cell data to lineData
# encode it in the file system encoding, only if needed
# TODO DISABLED due to migration to Python 3, related to CSV export
# if hasattr(value, 'encode'):
# value = value.encode(sys.getfilesystemencoding())
lineData.append(value)
if attr['key'] == 'name':
icon = QgsMapLayerModel.iconForLayer(layer)
newItem.setIcon(icon)
# Add item
table.setItem(twRowCount, i, newItem)
i += 1
# Add data to layerBoardData
self.layerBoardData[layerType].append(lineData)
# Launch slot on item changed slot
slot = partial(self.onItemChanged, layerType)
table.itemChanged.connect(slot)
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"))
def update_srs_table_content(dockwidget, srs_table):
with block_signals_to(dockwidget.QTableW_StraRS):
# init table
dockwidget.QTableW_StraRS.setRowCount(srs_table["row_count"])
dockwidget.QTableW_StraRS.setColumnCount(srs_table["column_count"])
# enter data onto Table
for n, key in enumerate(srs_table["header"]):
if key == "Pix Val":
for m, item in enumerate(
srs_table["color_table"]["Pixel Value"]):
item_table = QTableWidgetItem(str(item))
item_table.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
item_table.setTextAlignment(Qt.AlignCenter
| Qt.AlignVCenter)
dockwidget.QTableW_StraRS.setItem(m, n, item_table)
if key == "Color":
for m in range(srs_table["row_count"]):
item_table = QTableWidgetItem()
item_table.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
item_table.setBackground(
QColor(srs_table["color_table"]["Red"][m],
srs_table["color_table"]["Green"][m],
srs_table["color_table"]["Blue"][m],
srs_table["color_table"]["Alpha"][m]))
dockwidget.QTableW_StraRS.setItem(m, n, item_table)
if key == "Num Samples":
for m in range(srs_table["row_count"]):
item_table = QTableWidgetItem(srs_table["num_samples"][m])
item_table.setTextAlignment(Qt.AlignCenter
| Qt.AlignVCenter)
item_table.setToolTip(
"Total number of samples for this class, this is generated\n"
"automatically based on the area proportion by the activated\n"
"classes, overall standard error and its standard deviation."
)
if not srs_table["On"][m]:
item_table.setForeground(QColor("lightGrey"))
item_table.setFlags(Qt.ItemIsSelectable
| Qt.ItemIsEnabled)
dockwidget.QTableW_StraRS.setItem(m, n, item_table)
if key == "Std Dev":
for m in range(srs_table["row_count"]):
item_table = QTableWidgetItem(srs_table["std_dev"][m])
item_table.setTextAlignment(Qt.AlignCenter
| Qt.AlignVCenter)
item_table.setToolTip(
"Set the standard deviation for this class")
if not srs_table["On"][m]:
item_table.setForeground(QColor("lightGrey"))
item_table.setFlags(Qt.ItemIsSelectable
| Qt.ItemIsEnabled)
dockwidget.QTableW_StraRS.setItem(m, n, item_table)
if key == "On":
for m in range(srs_table["row_count"]):
item_table = QTableWidgetItem()
item_table.setFlags(Qt.ItemIsUserCheckable
| Qt.ItemIsEnabled)
item_table.setTextAlignment(Qt.AlignCenter
| Qt.AlignVCenter)
item_table.setToolTip("Enable/disable this class")
if srs_table["On"][m]:
item_table.setCheckState(Qt.Checked)
else:
item_table.setCheckState(Qt.Unchecked)
dockwidget.QTableW_StraRS.setItem(m, n, item_table)
# hidden row labels
dockwidget.QTableW_StraRS.verticalHeader().setVisible(False)
# add Header
dockwidget.QTableW_StraRS.setHorizontalHeaderLabels(
srs_table["header"])
# adjust size of Table
dockwidget.QTableW_StraRS.resizeColumnsToContents()
dockwidget.QTableW_StraRS.resizeRowsToContents()
# set label total samples
total_num_samples = sum(
[int(x) for x in mask(srs_table["num_samples"], srs_table["On"])])
dockwidget.TotalNumSamples.setText(str(total_num_samples))
# set maximum and reset the value in progress bar status
dockwidget.widget_generate_StraRS.QPBar_GenerateSampling.setValue(0)
dockwidget.widget_generate_StraRS.QPBar_GenerateSampling.setMaximum(
total_num_samples)
def create_table(self):
from AcATaMa.gui.acatama_dockwidget import AcATaMaDockWidget as AcATaMa
header = ["Classification Name", "Color", "Thematic Class", ""]
# clear table
self.tableBtnsConfig.clear()
# init table
self.tableBtnsConfig.setRowCount(len(self.table_buttons))
self.tableBtnsConfig.setColumnCount(4)
# hidden row labels
self.tableBtnsConfig.verticalHeader().setVisible(False)
# add Header
self.tableBtnsConfig.setHorizontalHeaderLabels(header)
# insert items
for n, h in enumerate(header):
if h == "Classification Name":
for m, (key, item) in enumerate(self.table_buttons.items()):
if m + 1 in self.buttons_config:
item_table = QTableWidgetItem(
self.buttons_config[m + 1]["name"])
else:
item_table = QTableWidgetItem(str(item))
item_table.setTextAlignment(Qt.AlignCenter
| Qt.AlignVCenter)
item_table.setToolTip(
"Classification button ID: {}".format(key))
self.tableBtnsConfig.setItem(m, n, item_table)
if h == "Color":
for m, item in enumerate(self.table_buttons.values()):
item_table = QTableWidgetItem()
if m + 1 in self.buttons_config:
item_table.setBackground(
QColor(self.buttons_config[m + 1]["color"]))
item_table.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
item_table.setTextAlignment(Qt.AlignCenter
| Qt.AlignVCenter)
self.tableBtnsConfig.setItem(m, n, item_table)
if h == "Thematic Class":
for m, item in enumerate(self.table_buttons.values()):
if valid_file_selected_in(
AcATaMa.dockwidget.QCBox_ThematicRaster):
if m + 1 in self.buttons_config and self.buttons_config[
m + 1]["thematic_class"] is not None:
item_table = QTableWidgetItem(
self.buttons_config[m + 1]["thematic_class"])
else:
item_table = QTableWidgetItem(str(item))
item_table.setToolTip(
"Click to open the pixel value/color table of the thematic classes"
)
else:
item_table = QTableWidgetItem("none")
item_table.setFlags(Qt.ItemIsSelectable
| Qt.ItemIsEnabled)
item_table.setForeground(QColor("lightGrey"))
item_table.setToolTip(
"No thematic layer, if you want enable the thematic classes,\n"
"select first a valid thematic layer in thematic tab"
)
item_h = QTableWidgetItem(h)
item_h.setForeground(QColor("lightGrey"))
self.tableBtnsConfig.setHorizontalHeaderItem(2, item_h)
item_table.setTextAlignment(Qt.AlignCenter
| Qt.AlignVCenter)
self.tableBtnsConfig.setItem(m, n, item_table)
if h == "":
for m, item in enumerate(self.table_buttons.values()):
item_table = QTableWidgetItem()
path = ':/plugins/AcATaMa/icons/trash.svg'
icon = QIcon(path)
item_table.setIcon(icon)
item_table.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
item_table.setTextAlignment(Qt.AlignCenter
| Qt.AlignVCenter)
item_table.setToolTip("Clean this row")
self.tableBtnsConfig.setItem(m, n, item_table)
# set the minimum width to 0 for headers
self.tableBtnsConfig.horizontalHeader().setMinimumSectionSize(0)
# adjust size of Table
self.tableBtnsConfig.resizeColumnsToContents()
self.tableBtnsConfig.resizeRowsToContents()
# adjust the dialog based on table content
dialog_width = self.tableBtnsConfig.horizontalHeader().length() + 50
self.resize(dialog_width, self.height())
