def testGettersSetters(self):
""" test combobox getters/setters """
l = create_layer()
w = QgsFieldComboBox()
w.setLayer(l)
self.assertEqual(w.layer(), l)
w.setField('fldint')
self.assertEqual(w.currentField(), 'fldint')
def testGettersSetters(self):
""" test combobox getters/setters """
l = create_layer()
w = QgsFieldComboBox()
w.setLayer(l)
self.assertEqual(w.layer(), l)
w.setField('fldint')
self.assertEqual(w.currentField(), 'fldint')
def testFilter(self):
""" test setting field with filter """
l = create_layer()
w = QgsFieldComboBox()
w.setLayer(l)
w.setFilters(QgsFieldProxyModel.Int)
self.assertEqual(w.layer(), l)
w.setField('fldint')
self.assertEqual(w.currentField(), 'fldint')
def testFilter(self):
""" test setting field with filter """
l = create_layer()
w = QgsFieldComboBox()
w.setLayer(l)
w.setFilters(QgsFieldProxyModel.Int)
self.assertEqual(w.layer(), l)
w.setField('fldint')
self.assertEqual(w.currentField(), 'fldint')
def testGettersSetters(self):
""" test combobox getters/setters """
l = create_layer()
w = QgsFieldComboBox()
w.setLayer(l)
self.assertEqual(w.layer(), l)
w.setField('fldint')
self.assertEqual(w.currentField(), 'fldint')
fields = QgsFields()
fields.append(QgsField('test1', QVariant.String))
fields.append(QgsField('test2', QVariant.String))
w.setFields(fields)
self.assertIsNone(w.layer())
self.assertEqual(w.fields(), fields)
def testSignals(self):
l = create_layer()
w = QgsFieldComboBox()
w.setLayer(l)
spy = QSignalSpy(w.fieldChanged)
w.setField('fldint2')
self.assertEqual(len(spy), 1)
self.assertEqual(spy[-1][0], 'fldint2')
w.setField('fldint2')
self.assertEqual(len(spy), 1)
self.assertEqual(spy[-1][0], 'fldint2')
w.setField('fldint')
self.assertEqual(len(spy), 2)
self.assertEqual(spy[-1][0], 'fldint')
w.setField(None)
self.assertEqual(len(spy), 3)
self.assertEqual(spy[-1][0], None)
w.setField(None)
self.assertEqual(len(spy), 3)
self.assertEqual(spy[-1][0], None)
class SettingsDialog(QDialog):
def __init__(self, parent=None):
QDialog.__init__(self, parent)
self.resize(500, 100)
self.setWindowTitle("Settings")
layout = QGridLayout(self)
csTargetLayerName = getCSLayerName()
bufferTargetLayerName = getRZLayerName()
csLable = QLabel("Compressor staitions layer:")
csLable.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
layout.addWidget(csLable, 0, 0)
self.__csLayerName = QgsMapLayerComboBox()
self.__csLayerName.setEditable(True)
self.__csLayerName.setFilters(QgsMapLayerProxyModel.PointLayer)
self.__csLayerName.setEditText(csTargetLayerName)
self.__csLayerName.layerChanged.connect(self.csLayerChooze)
self.__csLayerName.editTextChanged.connect(self.csLayernameSave)
self.__csLayerName.setSizePolicy(QSizePolicy.Preferred,
QSizePolicy.Fixed)
layout.addWidget(self.__csLayerName, 0, 1)
self.__csIdField = QgsFieldComboBox()
self.__csIdField.setEditable(True)
self.__csIdField.fieldChanged.connect(self.csIdFiledChooze)
self.__csIdField.editTextChanged.connect(self.csIdFieldSave)
self.__csIdField.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.csIdFieldFill()
layout.addWidget(self.__csIdField, 0, 2)
bufferLable = QLabel("Buffer layer:")
bufferLable.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
layout.addWidget(bufferLable, 1, 0)
# self.__bufferLayerName = QLineEdit(bufferTargetLayerName, self)
# self.__bufferLayerName.editingFinished.connect(self.bufferTargetLayernameSave)
self.__bufferLayerName = QgsMapLayerComboBox()
self.__bufferLayerName.setEditable(True)
self.__bufferLayerName.setFilters(QgsMapLayerProxyModel.PolygonLayer)
self.__bufferLayerName.setEditText(bufferTargetLayerName)
self.__bufferLayerName.layerChanged.connect(self.bufferLayerChooze)
self.__bufferLayerName.editTextChanged.connect(
self.bufferLayernameSave)
layout.addWidget(self.__bufferLayerName, 1, 1)
def csLayerChooze(self, qgsMapLayer):
self.__csLayerName.setEditText(qgsMapLayer.name())
def csLayernameSave(self, csTargetLayerName):
if csTargetLayerName == u"":
return
setCSLayerName(csTargetLayerName)
self.csIdFieldFill()
def csIdFieldFill(self):
csIdField = getCSIdField()
csTargetLayerName = getCSLayerName()
layers = QgsMapLayerRegistry.instance().mapLayersByName(
csTargetLayerName)
if len(layers) > 0:
self.__csIdField.setLayer(layers[0])
else:
self.__csIdField.setLayer(None)
self.__csIdField.setEditText(csIdField)
def csIdFiledChooze(self, fieldName):
self.__csIdField.setEditText(fieldName)
def csIdFieldSave(self, fieldName):
settings = QSettings()
if fieldName == u"":
return
setCSIdField(fieldName)
def bufferLayerChooze(self, qgsMapLayer):
self.__bufferLayerName.setEditText(qgsMapLayer.name())
def bufferLayernameSave(self, bufferTargetLayerName):
settings = QSettings()
if bufferTargetLayerName == u"":
return
setRZLayerName(bufferTargetLayerName)
class BpejPuCaWidget(PuCaWidget):
"""A widget for 'BPEJ' analysis."""
def _build_widgets(self):
"""Builds own widgets."""
self.lastBpejLayer = None
self.bpejMapLayerComboBox = QgsMapLayerComboBox(self)
self.bpejMapLayerComboBox.setObjectName(u'bpejMapLayerComboBox')
self.bpejMapLayerComboBox.setFilters(
QgsMapLayerProxyModel.PolygonLayer)
self.bpejMapLayerComboBox.activated.connect(self._set_last_bpej_layer)
QgsMapLayerRegistry.instance().layersAdded.connect(
self._rollback_bpej_layer)
QgsMapLayerRegistry.instance().layersRemoved.connect(
self._reset_bpej_layer)
self.set_bpej_layer(self.lastBpejLayer)
self.vBoxLayout.addWidget(self.bpejMapLayerComboBox)
self.bpejFieldComboBox = QgsFieldComboBox(self)
self.bpejFieldComboBox.setObjectName(u'bpejFieldComboBox')
self.bpejFieldComboBox.setLayer(
self.bpejMapLayerComboBox.currentLayer())
self.vBoxLayout.addWidget(self.bpejFieldComboBox)
self.bpejMapLayerComboBox.layerChanged.connect(
self.bpejFieldComboBox.setLayer)
def set_bpej_layer(self, bpejLayer, lastBpejLayer=True):
"""Sets the BPEJ layer in the bpejMapLayerComboBox.
Args:
bpejLayer (QgsVectorLayer): A reference to the BPEJ layer.
lastBpejLayer (bool): True to set self.lastBpejLayer,
False otherwise.
"""
if lastBpejLayer:
self.lastBpejLayer = bpejLayer
self.bpejMapLayerComboBox.setLayer(bpejLayer)
def _set_last_bpej_layer(self):
"""Sets the lastBpejLayer.
Sets the lastBpejLayer according to the current layer
in the bpejMapLayerComboBox.
"""
bpejLayer = self.bpejMapLayerComboBox.currentLayer()
if bpejLayer != self.lastBpejLayer:
self.lastBpejLayer = bpejLayer
def _reset_bpej_layer(self):
"""Resets the BPEJ layer."""
layers = self.iface.legendInterface().layers()
if self.lastBpejLayer not in layers:
self.set_bpej_layer(None)
def _rollback_bpej_layer(self):
"""Rolls the BPEJ layer back."""
if self.lastBpejLayer == None:
self.set_bpej_layer(self.lastBpejLayer, False)
else:
self.lastBpejLayer = self.bpejMapLayerComboBox.currentLayer()
def execute(self, layer):
"""Executes the analysis.
Args:
layer (QgsVectorLayer): A reference to the active layer.
"""
try:
editing = self.dW.check_editing()
bpejLayer = self.bpejMapLayerComboBox.currentLayer()
if bpejLayer == None:
self.pW.set_text_statusbar.emit(u'Žádná vrstva BPEJ.', 10, True)
return
if bpejLayer.featureCount() == 0:
self.pW.set_text_statusbar.emit(
u'Vrstva BPEJ neobsahuje žádný prvek.', 10, True)
return
bpejLayerCrs = bpejLayer.crs().authid()
layerCrs = layer.crs().authid()
if bpejLayerCrs != layerCrs:
self.pW.set_text_statusbar.emit(
u'Aktivní vrstva a vrstva BPEJ nemají stejný '
u'souřadnicový systém.', 10, True)
return
bpejField = self.bpejFieldComboBox.currentField()
if bpejField == u'':
self.pW.set_text_statusbar.emit(
u'Není vybrán sloupec ceny.', 10, True)
return
self.pW.set_text_statusbar.emit(
u'Provádím analýzu - oceňování podle BPEJ...', 0, False)
layer.removeSelection()
bpejLayer.removeSelection()
editedBpejField = self._edit_bpej_field(bpejField, layer)
unionFilePath = processing.runalg(
'qgis:union',
layer, bpejLayer, None)['OUTPUT']
unionLayer = QgsVectorLayer(unionFilePath, 'unionLayer', 'ogr')
expression = QgsExpression(
"\"{}\" is null "
"or "
"\"{}\" is null "
"or "
"\"{}\" is null "
"or "
"\"{}\" != 2"
.format(
editedBpejField,
self.dW.defaultMajorParNumberColumnName[:10],
self.dW.puCategoryColumnName[:10],
self.dW.puCategoryColumnName[:10]))
self.dW.delete_features_by_expression(unionLayer, expression)
if unionLayer.featureCount() != 0:
multiToSingleFilePath = processing.runalg(
'qgis:multiparttosingleparts',
unionLayer, None)['OUTPUT']
multiToSingleLayer = QgsVectorLayer(
multiToSingleFilePath, 'multiToSingleLayer', 'ogr')
bpejCodePrices = self._get_bpej_code_prices()
rowidColumnName = self.dW.rowidColumnName
prices, missingBpejCodes, bpejCodeAreasPrices = \
self._calculate_feature_prices(
rowidColumnName, multiToSingleLayer,
editedBpejField, bpejCodePrices)
priceFieldName = self.dW.puPriceColumnName
priceFieldId = layer.fieldNameIndex(priceFieldName)
bpejCodeAreaPricesFieldName = \
self.dW.puBpejCodeAreaPricesColumnName
bpejCodeAreaPricesFielId = layer.fieldNameIndex(
bpejCodeAreaPricesFieldName)
layer.startEditing()
layer.updateFields()
features = layer.getFeatures()
for feature in features:
rowid = feature.attribute(rowidColumnName)
id = feature.id()
price = prices[rowid]
if price != 0:
layer.changeAttributeValue(id, priceFieldId, price)
bpejCodeAreaPrices = bpejCodeAreasPrices[rowid]
bpejCodeAreaPricesStr = self._get_bpej_string(
bpejCodeAreaPrices)
layer.changeAttributeValue(
id, bpejCodeAreaPricesFielId, bpejCodeAreaPricesStr)
layer.commitChanges()
if editing:
self.iface.actionToggleEditing()
if len(missingBpejCodes) != 0:
fields = bpejLayer.pendingFields()
for field in fields:
if field.name() == bpejField:
bpejFieldTypeName = field.typeName()
break
if bpejFieldTypeName.lower() == u'string':
missingBpejCodesStr = \
'\'' + '\', \''.join(missingBpejCodes) + '\''
else:
missingBpejCodesStr = ', '.join(missingBpejCodes)
expression = QgsExpression(
"\"{}\" in ({})".format(bpejField, missingBpejCodesStr))
self.dW.select_features_by_expression(bpejLayer, expression)
featureCount = bpejLayer.selectedFeatureCount()
duration = 15
if featureCount == 1:
self.iface.messageBar().pushMessage(
u'BPEJ kód vybraného prvku ve vrstvě BPEJ '
u'nebyl nalezen.', QgsMessageBar.WARNING, duration)
elif featureCount > 1:
self.iface.messageBar().pushMessage(
u'BPEJ kódy vybraných prvků ve vrstvě BPEJ '
u'nebyly nalezeny.',
QgsMessageBar.WARNING, duration)
self.pW.set_text_statusbar.emit(
u'Analýza oceňování podle BPEJ úspěšně dokončena.', 20, False)
except self.dW.puError:
QgsApplication.processEvents()
except:
QgsApplication.processEvents()
currentCheckAnalysisName = \
self.pW.checkAnalysisComboBox.currentText()
self.dW.display_error_messages(
self.pW,
u'Error executing "{}".'.format(currentCheckAnalysisName),
u'Chyba při provádění "{}".'.format(currentCheckAnalysisName))
def _edit_bpej_field(self, bpejField, layer):
"""Edits BPEJ field name according to the layer fields.
Args:
bpejField (str): A name of the BPEJ field.
layer (QgsVectorLayer): A reference to the active layer.
Returns:
str: An edited BPEJ field name
"""
bpejField = bpejField[:10]
parFields = layer.pendingFields()
for field in parFields:
if bpejField.lower() == field.name().lower():
if len(bpejField) <= 8:
bpejField = bpejField + '_2'
break
elif len(bpejField) == 9:
bpejField = bpejField + '_'
break
elif len(bpejField) == 10:
bpejField = bpejField[:8] + '_1'
break
return bpejField
def _get_bpej_code_prices(self):
"""Returns BPEJ code prices.
Returns:
dict: A dictionary with BPEJ codes as keys (int)
and prices as values (float).
"""
formatTimeStr = '%d.%m.%Y'
bpejDir = QDir(self.pluginDir.path() + u'/data/bpej')
bpejBaseName = u'SC_BPEJ'
bpejZipFileName = bpejBaseName + u'.zip'
bpejZipFilePath = bpejDir.filePath(bpejZipFileName)
bpejCsvFileName = bpejBaseName + u'.csv'
bpejCsvFilePath = bpejDir.filePath(bpejCsvFileName)
upToDate = self._check_bpej_csv(bpejCsvFilePath, formatTimeStr)
if not upToDate:
testInternetUrl, bpejZipUrl = self._get_url()
self._download_bpej_csv(
testInternetUrl, bpejZipUrl, bpejZipFilePath, bpejCsvFileName)
bpejCodePrices = self._read_bpej_csv(bpejCsvFilePath, formatTimeStr)
return bpejCodePrices
def _check_bpej_csv(self, bpejCsvFilePath, formatTimeStr):
"""Checks if the BPEJ CSV file is up-to-date.
Args:
bpejCsvFilePath (str): A full path to the BPEJ CSV file.
formatTimeStr (str): A string for time formatting.
Returns:
bool: True when the BPEJ CSV file is up-to-date, False otherwise.
"""
modificationEpochTime = os.path.getmtime(bpejCsvFilePath)
modificationDateTime = datetime.fromtimestamp(modificationEpochTime)
todayDateTime = datetime.now()
bpejTodayDateTime = todayDateTime.replace(
hour=03, minute=06, second=0, microsecond=0)
if modificationDateTime > bpejTodayDateTime:
return True
else:
return False
def _get_url(self):
"""Returns URL.
Returns an URL for testing the internet connection
and an URL of the BPEJ ZIP file.
Returns:
str: An URL for testing the internet connection.
str: An URL of the BPEJ ZIP file.
"""
config = RawConfigParser()
config.read(self.pluginDir.filePath(u'puplugin.cfg'))
testInternetUrl = config.get('BPEJ', 'testinterneturl')
bpejZipUrl = config.get('BPEJ', 'bpejzipurl')
return testInternetUrl, bpejZipUrl
def _download_bpej_csv(
self,
testInternetUrl, bpejZipUrl, bpejZipFilePath, bpejCsvFileName):
"""Downloads BPEJ CSV file and unzips it.
Args:
testInternetUrl (str): An URL for testing the internet connection.
bpejZipUrl (str): An URL of the BPEJ ZIP file.
bpejZipFilePath (str): A full path to the BPEJ ZIP file.
bpejCsvFileName (str): A name of the BPEJ CSV file.
Raises:
dw.puError: When a connection to the CUZK website failed.
"""
try:
testInternetConnection = urllib.urlopen(testInternetUrl)
except:
return
else:
testInternetConnection.close()
try:
testBpejConnection = urllib.urlopen(bpejZipUrl)
except:
raise self.dW.puError(
self.dW, self.pW,
u'A Connection to "{}" failed.'.format(bpejZipUrl),
u'Nepodařilo se připojit k "{}"'.format(bpejZipUrl))
else:
testBpejConnection.close()
urllib.urlretrieve(bpejZipUrl, bpejZipFilePath)
self._unzip_bpej_zip(bpejZipFilePath, bpejCsvFileName)
os.remove(bpejZipFilePath)
def _unzip_bpej_zip(self, bpejZipFilePath, bpejCsvFileName):
"""Unzips BPEJ ZIP file into the same directory.
Args:
bpejZipFilePath (str): A full path to the BPEJ ZIP file.
bpejCsvFileName (str): A name of the BPEJ CSV file.
"""
fileInfo = QFileInfo(bpejZipFilePath)
bpejDir = fileInfo.absolutePath()
bpejZip = zipfile.ZipFile(bpejZipFilePath, 'r')
bpejZipContent = bpejZip.namelist()
if len(bpejZipContent) != 1:
bpejZip.close()
raise self.dW.puError(
self.dW, self.pW,
u'The structure of the BPEJ ZIP file has changed. '
u'The BPEJ ZIP file contains more than one file.',
u'Struktura stahovaného BPEJ ZIP souboru se změnila.')
bpejZipFirstMember = bpejZipContent[0]
bpejZip.extract(bpejZipFirstMember, bpejDir)
bpejZip.close()
if bpejZipFirstMember != bpejCsvFileName:
bpejDir = QDir(bpejDir)
bpejZipFirstMemberFilePath = bpejDir.filePath(bpejZipFirstMember)
bpejCsvFilePath = bpejDir.filePath(bpejCsvFileName)
os.rename(bpejZipFirstMemberFilePath, bpejCsvFilePath)
def _read_bpej_csv(self, bpejCsvFilePath, formatTimeStr):
"""Reads the BPEJ CSV file.
Args:
bpejCsvFilePath (str): A full path to the BPEJ CSV file.
formatTimeStr (str): A string for time formatting.
Returns:
dict: A dictionary with BPEJ codes as keys (int)
and prices as values (float).
"""
with open(bpejCsvFilePath, 'rb') as bpejCsvFile:
bpejCsvReader = csv.reader(bpejCsvFile, delimiter=';')
columnNames = bpejCsvReader.next()
codeColumnIndex = columnNames.index('KOD')
priceColumnIndex = columnNames.index('CENA')
validFromColumnIndex = columnNames.index('PLATNOST_OD')
validToColumnIndex = columnNames.index('PLATNOST_DO')
todayDate = datetime.now().date()
bpejCodePrices = {}
for row in bpejCsvReader:
if len(row) == 0:
break
validFromDateStr = row[validFromColumnIndex]
validFromDate = datetime.strptime(
validFromDateStr, formatTimeStr).date()
validToDateStr = row[validToColumnIndex]
if validToDateStr == '':
validToDate = todayDate
else:
validToDate = datetime.strptime(
validToDateStr, formatTimeStr).date()
if validFromDate <= todayDate <= validToDate:
code = int(row[codeColumnIndex])
price = row[priceColumnIndex]
bpejCodePrices[code] = float(price)
return bpejCodePrices
def _calculate_feature_prices(
self,
rowidColumnName, multiToSingleLayer, bpejField, bpejCodePrices):
"""Calculates feature prices.
Args:
rowidColumnName (str): A name of rowid column.
multiToSingleLayer (QgsVectorLayer): A reference to the single
features layer.
bpejField (str): A name of the BPEJ field.
bpejCodePrices (dict): A dictionary with BPEJ codes as keys (int)
and prices as values (float).
Returns:
defaultdict: A defaultdict with rowids as keys (long)
and prices as values (float).
set: A set of BPEJ codes that are not in BPEJ SCV file.
defaultdict: A defaultdict with rowids as keys (long)
and defaultdicts as values.
defaultdict: A defaultdict with BPEJ codes (without dots)
as keys (str) and defaultdicts as values.
defaultdict: A defaultdict with area and prices
as keys (str) and their values as values (float).
"""
prices = defaultdict(float)
bpejCodeAreasPrices = defaultdict(
lambda : defaultdict(lambda : defaultdict(float)))
missingBpejCodes = set()
features = multiToSingleLayer.getFeatures()
for feature in features:
rowid = feature.attribute(rowidColumnName)
bpejCode = str(feature.attribute(bpejField))
geometry = feature.geometry()
editedBpejCode = int(bpejCode.replace('.', ''))
if editedBpejCode in bpejCodePrices:
bpejPrice = bpejCodePrices[editedBpejCode]
else:
bpejPrice = 0.0
missingBpejCodes.add(bpejCode)
if geometry != None:
area = geometry.area()
price = bpejPrice*area
bpejCodeAreasPrices[rowid][editedBpejCode]['bpejPrice'] += \
bpejPrice
bpejCodeAreasPrices[rowid][editedBpejCode]['area'] += area
for rowid, bpejCode in bpejCodeAreasPrices.items():
for editedBpejCode, values in bpejCode.items():
values['roundedArea'] = round(values['area'])
values['price'] = values['roundedArea']*values['bpejPrice']
prices[rowid] += values['price']
return (prices, missingBpejCodes, bpejCodeAreasPrices)
def _get_bpej_string(self, bpejCodeAreaPrices):
"""Returns a BPEJ string.
Args:
bpejCodeAreaPrices (defaultdict): A defaultdict with BPEJ codes
(without dots) as keys (str) and defaultdicts as values.
defaultdict: A defaultdict with area and prices
as keys (str) and their values as values (float).
Returns:
str: A string that contains information about BPEJ.
The string consists of strings
'<BPEJ code>-<BPEJ price>-<rounded Area>-<price>'
for each BPEJ code in the input defaultdict separated by ', '.
"""
bpejCodeAreaPricesStr = ''
for bpejCode, values in bpejCodeAreaPrices.items():
bpejCodeAreaPricesStr += str(bpejCode)
bpejCodeAreaPricesStr += '-'
bpejCodeAreaPricesStr += str(values['bpejPrice'])
bpejCodeAreaPricesStr += '-'
bpejCodeAreaPricesStr += str(int(values['roundedArea']))
bpejCodeAreaPricesStr += '-'
bpejCodeAreaPricesStr += str(values['price'])
bpejCodeAreaPricesStr += ', '
bpejCodeAreaPricesStr = \
bpejCodeAreaPricesStr.strip(', ')
return bpejCodeAreaPricesStr
class SettingsDialog(QDialog):
def __init__(self, parent=None):
QDialog.__init__(self, parent)
self.resize(500, 100)
self.setWindowTitle("Settings")
layout = QGridLayout(self)
csTargetLayerName = getCSLayerName()
bufferTargetLayerName = getRZLayerName()
csLable = QLabel("Compressor staitions layer:")
csLable.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
layout.addWidget(csLable, 0, 0)
self.__csLayerName = QgsMapLayerComboBox()
self.__csLayerName.setEditable(True)
self.__csLayerName.setFilters(QgsMapLayerProxyModel.PointLayer)
self.__csLayerName.setEditText(csTargetLayerName)
self.__csLayerName.layerChanged.connect(self.csLayerChooze)
self.__csLayerName.editTextChanged.connect(self.csLayernameSave)
self.__csLayerName.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Fixed)
layout.addWidget(self.__csLayerName, 0, 1)
self.__csIdField = QgsFieldComboBox()
self.__csIdField.setEditable(True)
self.__csIdField.fieldChanged.connect(self.csIdFiledChooze)
self.__csIdField.editTextChanged.connect(self.csIdFieldSave)
self.__csIdField.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.csIdFieldFill()
layout.addWidget(self.__csIdField, 0, 2)
bufferLable = QLabel("Buffer layer:")
bufferLable.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
layout.addWidget(bufferLable, 1, 0)
# self.__bufferLayerName = QLineEdit(bufferTargetLayerName, self)
# self.__bufferLayerName.editingFinished.connect(self.bufferTargetLayernameSave)
self.__bufferLayerName = QgsMapLayerComboBox()
self.__bufferLayerName.setEditable(True)
self.__bufferLayerName.setFilters(QgsMapLayerProxyModel.PolygonLayer)
self.__bufferLayerName.setEditText(bufferTargetLayerName)
self.__bufferLayerName.layerChanged.connect(self.bufferLayerChooze)
self.__bufferLayerName.editTextChanged.connect(self.bufferLayernameSave)
layout.addWidget(self.__bufferLayerName, 1, 1)
def csLayerChooze(self, qgsMapLayer):
self.__csLayerName.setEditText(qgsMapLayer.name())
def csLayernameSave(self, csTargetLayerName):
if csTargetLayerName == u"":
return
setCSLayerName(csTargetLayerName)
self.csIdFieldFill()
def csIdFieldFill(self):
csIdField = getCSIdField()
csTargetLayerName = getCSLayerName()
layers = QgsMapLayerRegistry.instance().mapLayersByName(csTargetLayerName)
if len(layers) > 0:
self.__csIdField.setLayer(layers[0])
else:
self.__csIdField.setLayer(None)
self.__csIdField.setEditText(csIdField)
def csIdFiledChooze(self, fieldName):
self.__csIdField.setEditText(fieldName)
def csIdFieldSave(self, fieldName):
settings = QSettings()
if fieldName == u"":
return
setCSIdField(fieldName)
def bufferLayerChooze(self, qgsMapLayer):
self.__bufferLayerName.setEditText(qgsMapLayer.name())
def bufferLayernameSave(self, bufferTargetLayerName):
settings = QSettings()
if bufferTargetLayerName == u"":
return
setRZLayerName(bufferTargetLayerName)
class AddConnectorsDialog(QtWidgets.QDialog, FORM_CLASS):
def __init__(self, iface, project):
QtWidgets.QDialog.__init__(self)
self.iface = iface
self.setupUi(self)
self.NewLinks = False
self.NewNodes = False
self.project = project
if project is not None:
self.conn = project.conn
self.path_to_file = project.path_to_file
self._run_layout = QGridLayout()
spacer = QSpacerItem(5, 5, QSizePolicy.Expanding, QSizePolicy.Minimum)
# Centroid layer
frm1 = QHBoxLayout()
frm1.addItem(spacer)
self.CentroidLayer = QgsMapLayerComboBox()
self.CentroidLayer.layerChanged.connect(self.set_fields)
clabel = QLabel()
clabel.setText("Centroids layer")
frm1.addWidget(clabel)
frm1.addWidget(self.CentroidLayer)
self.CentroidLayer.setMinimumSize(450, 30)
wdgt1 = QWidget()
wdgt1.setLayout(frm1)
self.CentroidField = QgsFieldComboBox()
self.CentroidField.setMinimumSize(450, 30)
frm2 = QHBoxLayout()
frm2.addItem(spacer)
flabel = QLabel()
flabel.setText("Centroid ID field")
frm2.addWidget(flabel)
frm2.addWidget(self.CentroidField)
wdgt2 = QWidget()
wdgt2.setLayout(frm2)
self.CentroidLayer.setFilters(QgsMapLayerProxyModel.PointLayer)
frm3 = QHBoxLayout()
self.IfMaxLength = QCheckBox()
self.IfMaxLength.setChecked(True)
self.IfMaxLength.setText("Connector maximum length")
self.IfMaxLength.toggled.connect(self.allows_distance)
frm3.addWidget(self.IfMaxLength)
frm3.addItem(spacer)
self.MaxLength = QLineEdit()
frm3.addWidget(self.MaxLength)
frm3.addItem(spacer)
lblmeters = QLabel()
lblmeters.setText(" meters")
frm3.addWidget(lblmeters)
frm3.addItem(spacer)
lblnmbr = QLabel()
lblnmbr.setText("Connectors per centroid")
frm3.addWidget(lblnmbr)
self.NumberConnectors = QComboBox()
for i in range(1, 40):
self.NumberConnectors.addItem(str(i))
frm3.addWidget(self.NumberConnectors)
wdgt3 = QWidget()
wdgt3.setLayout(frm3)
layer_frame = QVBoxLayout()
layer_frame.addWidget(wdgt1)
layer_frame.addWidget(wdgt2)
layer_frame.addWidget(wdgt3)
lyrfrm = QWidget()
lyrfrm.setLayout(layer_frame)
# action buttons
self.but_process = QPushButton()
if self.project is None:
self.but_process.setText("Project not loaded")
self.but_process.setEnabled(False)
else:
self.but_process.setText("Run!")
self.but_process.clicked.connect(self.run)
self.but_cancel = QPushButton()
self.but_cancel.setText("Cancel")
self.but_cancel.clicked.connect(self.exit_procedure)
self.progressbar = QProgressBar()
self.progress_label = QLabel()
self.progress_label.setText("...")
but_frame = QHBoxLayout()
but_frame.addWidget(self.progressbar, 1)
but_frame.addWidget(self.progress_label, 1)
but_frame.addWidget(self.but_cancel, 1)
but_frame.addItem(spacer)
but_frame.addWidget(self.but_process, 1)
self.but_widget = QWidget()
self.but_widget.setLayout(but_frame)
# Progress bars and messagers
self.progress_frame = QVBoxLayout()
self.status_bar_files = QProgressBar()
self.progress_frame.addWidget(self.status_bar_files)
self.status_label_file = QLabel()
self.status_label_file.setText("Extracting: ")
self.progress_frame.addWidget(self.status_label_file)
self.status_bar_chunks = QProgressBar()
self.progress_frame.addWidget(self.status_bar_chunks)
self.progress_widget = QWidget()
self.progress_widget.setLayout(self.progress_frame)
self.progress_widget.setVisible(False)
self._run_layout.addWidget(lyrfrm)
self._run_layout.addWidget(self.but_widget)
self._run_layout.addWidget(self.progress_widget)
list = QWidget()
listLayout = QVBoxLayout()
self.list_types = QTableWidget()
self.list_types.setMinimumSize(180, 80)
lbl = QLabel()
lbl.setText("Allowed link types")
listLayout.addWidget(lbl)
listLayout.addWidget(self.list_types)
list.setLayout(listLayout)
if self.project is not None:
curr = self.conn.cursor()
curr.execute(
"SELECT DISTINCT link_type FROM links ORDER BY link_type")
ltypes = curr.fetchall()
self.list_types.setRowCount(len(ltypes))
self.list_types.setColumnCount(1)
for i, lt in enumerate(ltypes):
self.list_types.setItem(i, 0, QTableWidgetItem(lt[0]))
self.list_types.selectAll()
allStuff = QWidget()
allStuff.setLayout(self._run_layout)
allLayout = QHBoxLayout()
allLayout.addWidget(allStuff)
allLayout.addWidget(list)
self.setLayout(allLayout)
self.resize(700, 135)
# default directory
self.path = standard_path()
self.set_fields()
self.IfMaxLength.setChecked(False)
def allows_distance(self):
self.MaxLength.setEnabled(False)
if self.IfMaxLength.isChecked():
self.MaxLength.setEnabled(True)
def run_thread(self):
self.worker_thread.ProgressValue.connect(
self.progress_value_from_thread)
self.worker_thread.ProgressText.connect(self.progress_text_from_thread)
self.worker_thread.ProgressMaxValue.connect(
self.progress_range_from_thread)
self.worker_thread.jobFinished.connect(self.job_finished_from_thread)
self.worker_thread.start()
self.show()
def progress_range_from_thread(self, val):
self.progressbar.setRange(0, val)
def progress_value_from_thread(self, value):
self.progressbar.setValue(value)
def progress_text_from_thread(self, value):
self.progress_label.setText(value)
def set_fields(self):
self.CentroidField.setLayer(self.CentroidLayer.currentLayer())
def job_finished_from_thread(self, success):
self.but_process.setEnabled(True)
if self.worker_thread.error is not None:
qgis.utils.iface.messageBar().pushMessage(
"Error during procedure: ",
self.worker_thread.error,
level=Qgis.Warning,
duration=6)
self.exit_procedure()
def run(self):
if self.MaxLength.isEnabled():
max_length = float(self.MaxLength.text())
else:
max_length = 1000000000000
self.link_types = []
for i in range(self.list_types.rowCount()):
if self.list_types.item(i, 0).isSelected():
self.link_types.append(self.list_types.item(i, 0).text())
# If we selected all, we don;t need to filter by it
if len(self.link_types) == self.list_types.rowCount():
self.link_types = []
parameters = [
self.project.path_to_file,
self.CentroidLayer.currentText(),
self.CentroidField.currentText(), max_length,
int(self.NumberConnectors.currentText()), self.link_types
]
self.but_process.setEnabled(False)
self.worker_thread = AddsConnectorsProcedure(
qgis.utils.iface.mainWindow(), *parameters)
self.run_thread()
def exit_procedure(self):
self.close()
