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 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 _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 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 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 addSettingsToRow(settings, out_table):
s = settings
row = out_table.rowCount()
out_table.insertRow(row)
s = settings
# insert values
for i, value in enumerate([s.layerName, s.startTimeAttribute, s.endTimeAttribute,
s.isEnabled, s.layerId, s.timeFormat,
str(s.offset), s.interpolationEnabled, s.idAttribute,
s.interpolationMode,
not s.geometriesCount,
s.accumulate,
s.resetSubsetString]):
item = QTableWidgetItem()
if type(value) != bool:
item.setText(value)
else:
item.setCheckState(Qt.Checked if value else Qt.Unchecked)
out_table.setItem(row, i, item)
def addSettingsToRow(settings, out_table):
s = settings
row = out_table.rowCount()
out_table.insertRow(row)
s = settings
# insert values
for i, value in enumerate([
s.layerName, s.startTimeAttribute, s.endTimeAttribute, s.isEnabled,
s.layerId, s.timeFormat,
str(s.offset), s.interpolationEnabled, s.idAttribute,
s.interpolationMode, not s.geometriesCount, s.accumulate,
s.resetSubsetString
]):
item = QTableWidgetItem()
if type(value) != bool:
item.setText(value)
else:
item.setCheckState(Qt.Checked if value else Qt.Unchecked)
out_table.setItem(row, i, item)
def traerOperaciones(self):
#self.createAlert("Si conecto", QMessageBox().Information, "Si se hizo")
self.dlg.twOperaciones_7.clearContents()
self.dlg.twOperaciones_7.setRowCount(0)
row = self.dlg.twOperaciones_6.currentRow()
rol = self.dlg.twOperaciones_6.item(row, 1)
#print('---------------')
#print(rol.text())
#print(self.CFG.url_AU_getAllRole + rol.text())
#print('---------------')
self.roles = self.consumeWSGeneral(
url_cons=self.CFG.url_AU_getAllRequisitos + rol.text())
#print(self.roles)
if not self.roles:
return
# mostrar usuarios en tabla
self.dlg.twOperaciones_7.setRowCount(len(self.roles))
for x in range(0, len(self.roles)):
check = QTableWidgetItem(self.roles[x]['descripcion'])
#check = QTableWidgetItem(self.roles[x]['tipo'])
check.setFlags(QtCore.Qt.ItemIsUserCheckable
| QtCore.Qt.ItemIsEnabled)
if self.roles[x]['tipo'] == 'UNO' or self.roles[x][
'tipo'] == 'DOS' or self.roles[x][
'tipo'] == 'TRE' or self.roles[x][
'tipo'] == 'CUA' or self.roles[x]['tipo'] == 'CIN':
check.setCheckState(QtCore.Qt.Unchecked)
else:
check.setCheckState(QtCore.Qt.Checked)
#self.dlg.twOperaciones_7.setItem(x,0,check)
self.dlg.twOperaciones_7.setItem(x, 0, check)
self.dlg.twOperaciones_7.setItem(
x, 1, QtWidgets.QTableWidgetItem(str(self.roles[x]['id'])))
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 traerOperaciones(self):
#self.createAlert("Si conecto", QMessageBox().Information, "Si se hizo")
self.twDefinir.clearContents()
self.twDefinir.setRowCount(0)
dev = 'h'
#print('---------------')
#print(rol.text())
#print(self.CFG.url_AU_getAllRole + rol.text())
#print('---------------')
self.roles = self.consumeWSGeneral_2(
url_cons=self.CFG.url_AU_getAllRole + dev)
#print(self.roles)
if not self.roles:
return
# mostrar usuarios en tabla
self.twDefinir.setRowCount(len(self.roles))
for x in range(0, len(self.roles)):
check = QTableWidgetItem(self.roles[x]['nombre'])
#check = QTableWidgetItem(self.roles[x]['asignado'])
check.setFlags(QtCore.Qt.ItemIsUserCheckable
| QtCore.Qt.ItemIsEnabled)
if self.roles[x]['asignado'] == False:
check.setCheckState(QtCore.Qt.Unchecked)
else:
check.setCheckState(QtCore.Qt.Checked)
#self.twDefinir.setItem(x,0,check)
self.twDefinir.setItem(x, 0, check)
self.twDefinir.setItem(
x, 1, QtWidgets.QTableWidgetItem(str(self.roles[x]['id'])))
def loadLayerForInterlink(self):
layers = QgsProject.instance().layerTreeRoot().children()
selectedLayerIndex = self.chooseLayerInterlink.currentIndex()
if len(layers) == 0:
return
layer = layers[selectedLayerIndex].layer()
fieldnames = [field.name() for field in layer.fields()]
while self.interlinkTable.rowCount() > 0:
self.interlinkTable.removeRow(0)
row = 0
self.interlinkTable.setHorizontalHeaderLabels([
"Export?", "IDColumn?", "GeoColumn?", "Column", "ColumnProperty",
"PropertyType", "ColumnConcept", "ValueConcepts"
])
self.interlinkTable.setColumnCount(8)
for field in fieldnames:
item = QTableWidgetItem(field)
item.setFlags(QtCore.Qt.ItemIsEnabled)
item2 = QTableWidgetItem()
item2.setCheckState(True)
item3 = QTableWidgetItem()
item3.setCheckState(False)
item4 = QTableWidgetItem()
item4.setCheckState(False)
self.interlinkTable.insertRow(row)
self.interlinkTable.setItem(row, 3, item)
self.interlinkTable.setItem(row, 0, item2)
self.interlinkTable.setItem(row, 1, item3)
self.interlinkTable.setItem(row, 2, item4)
cbox = QComboBox()
cbox.addItem("Automatic")
cbox.addItem("AnnotationProperty")
cbox.addItem("DataProperty")
cbox.addItem("ObjectProperty")
cbox.addItem("SubClass")
self.interlinkTable.setCellWidget(row, 5, cbox)
currentRowCount = self.interlinkTable.rowCount()
row += 1
def create_checkbox_item(attribute):
item = QTableWidgetItem()
item.setFlags(Qt.ItemIsUserCheckable | Qt.ItemIsEnabled)
item.setCheckState(Qt.Unchecked)
item.setData(1, attribute)
return item
def checkbox():
item = QTableWidgetItem()
item.setFlags(Qt.ItemIsUserCheckable | Qt.ItemIsEnabled)
item.setCheckState(Qt.Unchecked)
return item
def loadModels(self, error=True):
self.settings.service = self.leSERVICE.text()
self.settings.host = self.leHOST.text()
self.settings.port = self.lePORT.text()
self.settings.dbname = self.leDBNAME.text()
self.settings.schema = self.leSCHEMA.text()
self.settings.uid = self.leUID.text()
self.settings.pwd = self.lePWD.text()
if hasattr(qgis.gui, 'QgsAuthConfigSelect'):
self.settings.authcfg = self.authCfgSelect.configId()
self.twModellarten.clearContents()
self.cbxSignaturkatalog.clear()
(db, conninfo) = self.plugin.opendb()
if not db:
if error:
QMessageBox.critical(None, "ALKIS", u"Datenbankverbindung schlug fehl.")
self.settings.load()
return
modelle = self.settings.modellarten
if modelle is None:
modelle = ['DLKM', 'DKKM1000']
qry = QSqlQuery(db)
if qry.exec_("""
SELECT modell,count(*)
FROM (
SELECT unnest(modell) AS modell FROM po_points UNION ALL
SELECT unnest(modell) AS modell FROM po_lines UNION ALL
SELECT unnest(modell) AS modell FROM po_polygons UNION ALL
SELECT unnest(modell) AS modell from po_lines UNION ALL
SELECT unnest(modell) AS modell from po_labels
) AS foo
GROUP BY modell
ORDER BY count(*) DESC
"""):
res = {}
while qry.next():
res[qry.value(0)] = qry.value(1)
self.twModellarten.setRowCount(len(res))
i = 0
for k, n in sorted(iter(list(res.items())), key=operator.itemgetter(1), reverse=True):
item = QTableWidgetItem(k)
item.setCheckState(Qt.Checked if (item.text() in modelle) else Qt.Unchecked)
self.twModellarten.setItem(i, 0, item)
item = QTableWidgetItem(str(n))
self.twModellarten.setItem(i, 1, item)
i += 1
self.twModellarten.resizeColumnsToContents()
self.twModellarten.setEnabled(True)
else:
self.twModellarten.clearContents()
self.twModellarten.setDisabled(True)
if qry.exec_("SELECT id,name FROM alkis_signaturkataloge"):
while qry.next():
self.cbxSignaturkatalog.addItem(qry.value(1), int(qry.value(0)))
self.cbxSignaturkatalog.setEnabled(True)
else:
self.cbxSignaturkatalog.addItem(u"Farbe", -1)
self.cbxSignaturkatalog.setCurrentIndex(max([0, self.cbxSignaturkatalog.findData(self.settings.signaturkatalog)]))
self.settings.load()
def loadModels(self, error=True):
self.settings.servicE = self.leSERVICE.text()
self.settings.host = self.leHOST.text()
self.settings.port = self.lePORT.text()
self.settings.dbname = self.leDBNAME.text()
self.settings.schema = self.leSCHEMA.text()
self.settings.uid = self.leUID.text()
self.settings.pwd = self.lePWD.text()
if hasattr(qgis.gui, 'QgsAuthConfigSelect'):
self.settings.authcfg = self.authCfgSelect.configId()
self.twModellarten.clearContents()
self.cbxSignaturkatalog.clear()
(db, conninfo) = self.plugin.opendb()
if not db:
if error:
QMessageBox.critical(None, "ALKIS", u"Datenbankverbindung schlug fehl.")
self.twModellarten.clearContents()
self.twModellarten.setDisabled(True)
self.twModellarten.setRowCount(0)
self.settings.load()
return
modelle = self.settings.modellarten
if modelle is None:
modelle = ['DLKM', 'DKKM1000']
qry = QSqlQuery(db)
if qry.exec_("SELECT 1 FROM information_schema.tables WHERE table_schema={} AND table_name='po_modelle'".format(quote(self.plugin.settings.schema))) and qry.next():
sql = "SELECT modell,n FROM po_modelle WHERE modell IS NOT NULL ORDER BY n DESC"
else:
sql = """
SELECT modell,count(*)
FROM (
SELECT unnest(modell) AS modell FROM po_points UNION ALL
SELECT unnest(modell) AS modell FROM po_lines UNION ALL
SELECT unnest(modell) AS modell FROM po_polygons UNION ALL
SELECT unnest(modell) AS modell from po_labels
) AS foo
WHERE modell IS NOT NULL
GROUP BY modell
ORDER BY count(*) DESC
"""
if qry.exec_(sql):
res = {}
while qry.next():
res[qry.value(0)] = qry.value(1)
self.twModellarten.setRowCount(len(res))
i = 0
for k, n in sorted(iter(list(res.items())), key=operator.itemgetter(1), reverse=True):
item = QTableWidgetItem(k)
item.setCheckState(Qt.Checked if (item.text() in modelle) else Qt.Unchecked)
self.twModellarten.setItem(i, 0, item)
item = QTableWidgetItem(str(n))
self.twModellarten.setItem(i, 1, item)
i += 1
self.twModellarten.resizeColumnsToContents()
self.twModellarten.setEnabled(True)
else:
self.twModellarten.clearContents()
self.twModellarten.setDisabled(True)
self.twModellarten.setRowCount(0)
if qry.exec_("SELECT id,name FROM alkis_signaturkataloge"):
while qry.next():
self.cbxSignaturkatalog.addItem(qry.value(1), int(qry.value(0)))
self.cbxSignaturkatalog.setEnabled(True)
else:
self.cbxSignaturkatalog.addItem(u"Farbe", -1)
self.cbxSignaturkatalog.setCurrentIndex(max([0, self.cbxSignaturkatalog.findData(self.settings.signaturkatalog)]))
self.settings.load()
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 saveParameters(self):
self.updateDistricts()
layers = self.iface.legendInterface().layers()
selectedLayerIndex = self.dlgparameters.cmbActiveLayer.currentIndex()
selectedLayer = layers[selectedLayerIndex]
self.activeLayer = selectedLayer
self.districts = self.dlgparameters.inpDistricts.value()
self.activedistrict = 1
self.dockwidget.lblActiveDistrict.setText("Active District: " +
str(self.activedistrict))
self.dockwidget.sliderDistricts.setMinimum(1)
self.dockwidget.sliderDistricts.setMaximum(self.districts)
self.dockwidget.sliderDistricts.setValue(1)
self.popfield = self.dlgparameters.cmbPopField.currentText()
self.distfield = self.dlgparameters.cmbDistField.currentText()
# self.dispfield1 = self.dlgparameters.cmbDispField1.currentText()
# self.dispfield2 = self.dlgparameters.cmbDispField1.currentText()
QgsMessageLog.logMessage("Popfield:" + str(self.popfield))
self.totalpop = 0
self.targetpop = 0
for feature in self.activeLayer.getFeatures():
self.totalpop = self.totalpop + feature[self.popfield]
self.targetpop = int(self.totalpop / self.districts)
self.targetpoppct = self.dlgparameters.inpTolerance.value()
targetpoprem = int((self.targetpop / 100) * self.targetpoppct)
self.targetpoplower = int(self.targetpop - targetpoprem)
self.targetpophigher = int(self.targetpop + targetpoprem + 1)
QgsMessageLog.logMessage("TargetPop:" + str(self.targetpop) + "(" +
str(self.targetpoplower) + ", " +
str(self.targetpophigher) + ")")
QgsMessageLog.logMessage("Districts:" + str(self.districts))
self.dockwidget.lblMainInfo.setText("Active Layer: " +
self.activeLayer.name() +
"\nActive District Field: " +
self.distfield +
"\nTarget Population: " +
str(self.targetpop) + " (" +
str(self.targetpoplower) + ", " +
str(self.targetpophigher) + ")")
self.attrdockwidget.tblPop.setRowCount(self.districts + 1)
numDataFields = 0
for d in dataFieldList:
numDataFields = numDataFields + 1
self.attrdockwidget.tblPop.setHorizontalHeaderItem(
2 + numDataFields, QTableWidgetItem(d.name))
self.attrdockwidget.tblPop.setColumnCount(4 + numDataFields)
for r in range(0, self.districts + 1):
chkBoxItem = QTableWidgetItem()
chkBoxItem.setFlags(Qt.ItemIsUserCheckable | Qt.ItemIsEnabled)
chkBoxItem.setCheckState(Qt.Unchecked)
self.attrdockwidget.tblPop.setItem(r, 1, chkBoxItem)
self.attrdockwidget.tblPop.setHorizontalHeaderLabels(
['#', 'Lock', 'Population', 'To Target'])
numDataFields = 0
for d in dataFieldList:
numDataFields = numDataFields + 1
if d.type == 1:
self.attrdockwidget.tblPop.setHorizontalHeaderItem(
3 + numDataFields, QTableWidgetItem(d.name))
else:
self.attrdockwidget.tblPop.setHorizontalHeaderItem(
3 + numDataFields, QTableWidgetItem(d.name + '%'))
if len(districtName) == 0:
self.initializeElectorates()
try:
self.saveParametersToFile()
QgsMessageLog.logMessage("Parameters file saved!")
except:
QgsMessageLog.logMessage("Parameters file could not be saved")
if self.dlgparameters.chkStyleMap.isChecked():
categories = []
for cat in range(0, self.districts + 1):
symbol = QgsSymbolV2.defaultSymbol(
self.activeLayer.geometryType())
layer_style = {}
layer_style['color'] = '%d, %d, %d' % (randrange(
0, 256), randrange(0, 256), randrange(0, 256))
layer_style['outline'] = '#000000'
symbol_layer = QgsSimpleFillSymbolLayerV2.create(layer_style)
# replace default symbol layer with the configured one
if symbol_layer is not None:
symbol.changeSymbolLayer(0, symbol_layer)
# create renderer object
category = QgsRendererCategoryV2(cat, symbol, str(cat))
# entry for the list of category items
categories.append(category)
renderer = QgsCategorizedSymbolRendererV2(self.distfield,
categories)
# assign the created renderer to the layer
if renderer is not None:
self.activeLayer.setRendererV2(renderer)
self.activeLayer.triggerRepaint()
self.updateFieldValues()
self.updateTable()
self.updateLockedFields()
self.updateDistricts()
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 saveParameters(self):
self.updateDistricts()
#layers = self.iface.legendInterface().layers()
layers = [
tree_layer.layer() for tree_layer in
QgsProject.instance().layerTreeRoot().findLayers()
]
selectedLayerIndex = self.dlgparameters.cmbActiveLayer.currentIndex()
selectedLayer = layers[selectedLayerIndex]
self.activeLayer = selectedLayer
self.districts = self.dlgparameters.inpDistricts.value()
self.activedistrict = 1
self.dockwidget.lblActiveDistrict.setText("Active District: " +
str(self.activedistrict))
self.dockwidget.sliderDistricts.setMinimum(1)
self.dockwidget.sliderDistricts.setMaximum(self.districts)
self.dockwidget.sliderDistricts.setValue(1)
self.popfield = self.dlgparameters.cmbPopField.currentText()
self.distfield = self.dlgparameters.cmbDistField.currentText()
# self.dispfield1 = self.dlgparameters.cmbDispField1.currentText()
# self.dispfield2 = self.dlgparameters.cmbDispField1.currentText()
QgsMessageLog.logMessage("Popfield:" + str(self.popfield))
self.totalpop = 0
self.targetpop = 0
for feature in self.activeLayer.getFeatures():
self.totalpop = self.totalpop + feature[self.popfield]
self.targetpop = int(self.totalpop / self.districts)
self.targetpoppct = self.dlgparameters.inpTolerance.value()
targetpoprem = int((self.targetpop / 100) * self.targetpoppct)
self.targetpoplower = int(self.targetpop - targetpoprem)
self.targetpophigher = int(self.targetpop + targetpoprem + 1)
QgsMessageLog.logMessage("TargetPop:" + str(self.targetpop) + "(" +
str(self.targetpoplower) + ", " +
str(self.targetpophigher) + ")")
QgsMessageLog.logMessage("Districts:" + str(self.districts))
self.dockwidget.lblMainInfo.setText("Active Layer: " +
self.activeLayer.name() +
"\nActive District Field: " +
self.distfield +
"\nTarget Population: " +
str(self.targetpop) + " (" +
str(self.targetpoplower) + ", " +
str(self.targetpophigher) + ")")
self.attrdockwidget.tblPop.setRowCount(self.districts + 1)
numDataFields = 0
for d in dataFieldList:
numDataFields = numDataFields + 1
self.attrdockwidget.tblPop.setHorizontalHeaderItem(
2 + numDataFields, QTableWidgetItem(d.name))
self.attrdockwidget.tblPop.setColumnCount(4 + numDataFields)
for r in range(0, self.districts + 1):
chkBoxItem = QTableWidgetItem()
chkBoxItem.setFlags(Qt.ItemIsUserCheckable | Qt.ItemIsEnabled)
chkBoxItem.setCheckState(Qt.Unchecked)
self.attrdockwidget.tblPop.setItem(r, 1, chkBoxItem)
self.attrdockwidget.tblPop.setHorizontalHeaderLabels(
['#', 'Lock', 'Population', 'To Target'])
numDataFields = 0
for d in dataFieldList:
numDataFields = numDataFields + 1
if d.type == 1:
self.attrdockwidget.tblPop.setHorizontalHeaderItem(
3 + numDataFields, QTableWidgetItem(d.name))
else:
self.attrdockwidget.tblPop.setHorizontalHeaderItem(
3 + numDataFields, QTableWidgetItem(d.name + '%'))
if len(districtName) == 0:
self.initializeElectorates()
try:
self.saveParametersToFile()
QgsMessageLog.logMessage("Parameters file saved!")
except:
QgsMessageLog.logMessage("Parameters file could not be saved")
if self.dlgparameters.chkStyleMap.isChecked():
self.styleMap()
self.updateFieldValues()
self.updateTable()
self.updateLockedFields()
self.updateDistricts()
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 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)
