def fill_item(self, supplies_party, collected_party, row):
self.tbl_changes_parties.setCellWidget(
row, 0, self.get_widget_with_party_info_formatted(supplies_party))
self.tbl_changes_parties.setCellWidget(
row, 1, self.get_widget_with_party_info_formatted(collected_party))
type_item = QTableWidgetItem()
type_item.setBackground(Qt.green if supplies_party ==
collected_party else Qt.red)
self.tbl_changes_parties.setItem(row, 2, type_item)
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 fill_row(self, parcel_fid, parcel_number, receiver, row):
item = QTableWidgetItem(parcel_number)
item.setData(Qt.UserRole, parcel_fid)
self.tbl_parcels.setItem(row, 0, item)
item2 = QTableWidgetItem(receiver or '')
if not receiver:
item2.setBackground(QBrush(NOT_ALLOCATED_PARCEL_COLOR))
self.tbl_parcels.setItem(row, self.STATUS_COL, item2)
if parcel_fid in self.__selected_items:
item.setSelected(True)
item2.setSelected(True)
def fill_row(self, parcel_fid, parcel_number, allocated, row):
item = QTableWidgetItem(parcel_number)
item.setData(Qt.UserRole, parcel_fid)
self.tbl_parcels.setItem(row, 0, item)
text = QCoreApplication.translate(
"BaseAllocateParcelsToReceiverPanelWidget",
"Already allocated") if allocated else QCoreApplication.translate(
"BaseAllocateParcelsToReceiverPanelWidget", "To be allocated")
item2 = QTableWidgetItem(text)
item2.setData(Qt.UserRole, allocated)
if not allocated:
item2.setBackground(QBrush(NOT_ALLOCATED_PARCEL_COLOR))
self.tbl_parcels.setItem(row, 1, item2)
def on_details_result(self, result):
self._container.lbl_page_current.setText(
"%d of %d" % (self.current_page, self.total_pages))
QgsMessageLog.logMessage("MonitorWidget.on_details_result: %d" %
len(result),
tag="OAW",
level=Qgis.Info)
row_number = 0
for i in range(self.rows_per_page - len(result)):
result.append((
"",
"",
"",
"",
"",
"",
"",
))
for row_data in result:
for column_number, data in enumerate(row_data):
value = str(data) if data is not None else ""
cell = QTableWidgetItem(value)
if column_number == 2:
if value == "completed":
cell.setBackground(QColor(0, 200, 50))
elif value == "failed":
cell.setBackground(QColor(200, 0, 50))
elif value == "running":
cell.setBackground(QColor(50, 0, 200))
elif value == "running":
cell.setBackground(QColor(255, 255, 255))
self._container.table_monitor.setItem(row_number,
column_number, cell)
row_number += 1
self._container.table_monitor.viewport().update()
def createAttributeItems(self, fullTableName, currentDict, qmlDict, count, colour = None):
"""
Creates a QTableWidgetItem for each attribute.
The cell can have different types according to the data type used (i.e QCombobox, QLineEdit or QListWidget)
"""
if fullTableName in currentDict:
for attr in currentDict[fullTableName]:
self.attributeTableWidget.insertRow(count)
item = QTableWidgetItem()
item.setText(attr)
if colour:
item.setBackground(colour)
self.attributeTableWidget.setItem(count, 0, item)
#creating the specific cell widget. It can be a QCombobox, a QLineEdit or a QListWidget
self.createCellWidget(qmlDict, attr, count)
count+=1
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 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 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)
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 Error":
for m in range(srs_table["row_count"]):
item_table = QTableWidgetItem(srs_table["std_error"][m])
item_table.setTextAlignment(Qt.AlignCenter
| Qt.AlignVCenter)
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)
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 set_pixel_table(self):
# clear table
self.PixelTable.clear()
self.PixelTable.setRowCount(0)
self.PixelTable.setColumnCount(0)
if not self.thematic_file_classes:
return
with block_signals_to(self.PixelTable):
header = ["", "class value", "select"]
row_length = len(self.pixel_classes)
# init table
self.PixelTable.setRowCount(row_length)
self.PixelTable.setColumnCount(3)
self.PixelTable.horizontalHeader().setMinimumSectionSize(45)
# hidden row labels
self.PixelTable.verticalHeader().setVisible(False)
# add Header
self.PixelTable.setHorizontalHeaderLabels(header)
# insert items
for col_idx, header in enumerate(header):
if header == "":
for row_idx, pixel in enumerate(self.pixel_classes):
item_table = QTableWidgetItem()
item_table.setFlags(item_table.flags()
& ~Qt.ItemIsSelectable)
item_table.setBackground(
QColor(pixel["color"]["R"], pixel["color"]["G"],
pixel["color"]["B"], pixel["color"]["A"]))
self.PixelTable.setItem(row_idx, col_idx, item_table)
if header == "class value":
for row_idx, pixel in enumerate(self.pixel_classes):
item_table = QTableWidgetItem(str(pixel["value"]))
item_table.setFlags(item_table.flags()
& ~Qt.ItemIsSelectable)
item_table.setFlags(item_table.flags()
& ~Qt.ItemIsEditable)
item_table.setTextAlignment(Qt.AlignCenter
| Qt.AlignVCenter)
self.PixelTable.setItem(row_idx, col_idx, item_table)
if header == "select":
for row_idx, pixel in enumerate(self.pixel_classes):
item_table = QTableWidgetItem()
item_table.setFlags(item_table.flags()
| Qt.ItemIsUserCheckable)
item_table.setFlags(item_table.flags()
| Qt.ItemIsEnabled)
item_table.setFlags(item_table.flags()
& ~Qt.ItemIsSelectable)
item_table.setTextAlignment(Qt.AlignCenter
| Qt.AlignVCenter)
if pixel["select"]:
item_table.setCheckState(Qt.Checked)
else:
item_table.setCheckState(Qt.Unchecked)
self.PixelTable.setItem(row_idx, col_idx, item_table)
# adjust size of Table
self.PixelTable.resizeColumnsToContents()
self.PixelTable.resizeRowsToContents()
# adjust the editor block based on table content
table_width = self.PixelTable.horizontalHeader().length() + 40
self.TableBlock.setMaximumWidth(table_width)
self.TableBlock.setMinimumWidth(table_width)
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())
