def applyConceptToColumn(self,costumURI=False):
fieldnames = [field.name() for field in self.layer.fields()]
item=QTableWidgetItem(self.searchResult.currentItem().text()[0:self.searchResult.currentItem().text().rfind('(')-1])
#item.setFlags(QtCore.Qt.ItemIsEnabled)
row = self.enrichtable.rowCount()
self.enrichtable.insertRow(row)
self.enrichtable.setItem(row,0,item)
item=QTableWidgetItem()
item.setData(1,self.searchResult.currentItem().data(1))
item.setText(self.searchResult.currentItem().text())
self.enrichtable.setItem(row,1,item)
item=QTableWidgetItem()
item.setText(self.triplestoreconf[self.tripleStoreEdit.currentIndex()+1]["endpoint"])
self.enrichtable.setItem(row,2,item)
cbox=QComboBox()
cbox.addItem("Get Remote")
cbox.addItem("No Enrichment")
cbox.addItem("Exclude")
self.enrichtable.setCellWidget(row,3,cbox)
cbox=QComboBox()
cbox.addItem("Enrich Value")
cbox.addItem("Enrich URI")
cbox.addItem("Enrich Both")
self.enrichtable.setCellWidget(row,4,cbox)
cbox=QComboBox()
for fieldd in fieldnames:
cbox.addItem(fieldd)
self.enrichtable.setCellWidget(row,5,cbox)
itemm=QTableWidgetItem("http://www.w3.org/2000/01/rdf-schema#label")
self.enrichtable.setItem(row,6,itemm)
itemm=QTableWidgetItem(self.conceptSearchEdit.text())
self.enrichtable.setItem(row,7,itemm)
itemm=QTableWidgetItem("")
self.enrichtable.setItem(row,8,itemm)
self.close()
def _refresh_defects_list(self):
if self.layer is None:
return
self._clear_defects_list()
excluded_fields = self._get_excluded_columns_list()
fields = []
for f in self.layer.fields():
if not f.name() in excluded_fields:
fields.append(f.name())
labels = [self.layer.attributeAlias(i) for i in range(len(fields))]
self.defects_list.setColumnCount(len(fields))
self.defects_list.setHorizontalHeaderLabels(labels)
row = 0
for feature in self._get_features():
self.defects_list.insertRow(row)
column = 0
for field in fields:
if type(feature[field]) is QDateTime:
item = QTableWidgetItem(feature[field].toString())
elif type(feature[field]) is long \
or type(feature[field]) is int:
item = QCustomTableWidgetItem(str(feature[field]))
else:
item = QTableWidgetItem(str(feature[field]))
item.setData(Qt.UserRole, feature.id())
item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
self.defects_list.setItem(row, column, item)
column += 1
row += 1
self.defects_list.resizeColumnsToContents()
def addLayerFields(self, layer_source):
layer = layer_source.layer
if layer.type() != QgsMapLayer.VectorLayer:
return
for i, field in enumerate(layer.fields()):
row = self.rowCount()
ews = layer.editorWidgetSetup(i)
if ews.type() == 'ExternalResource':
# for later: if ews.config().get('DocumentViewer', QgsExternalResourceWidget.NoContent) == QgsExternalResourceWidget.Image:
self.insertRow(row)
item = QTableWidgetItem(layer.name())
item.setData(Qt.UserRole, layer_source)
self.setItem(row, 0, item)
item = QTableWidgetItem(field.name())
self.setItem(row, 1, item)
ew = QgsFieldExpressionWidget()
ew.setLayer(layer)
expression = layer_source.photo_naming(field.name())
ew.setExpression(expression)
self.setCellWidget(row, 2, ew)
self.resizeColumnsToContents()
def populateTableResult(self, table, objects_dict):
table.reset()
table.sortItems(-1)
if not objects_dict:
print("not found")
return
first_feature_data = list(objects_dict.items())[0][1]
headers_labels_list = list(first_feature_data.keys())
columns_cnt = len(headers_labels_list)
rows_cnt = len(list(objects_dict.keys()))
table.setRowCount(rows_cnt)
table.setColumnCount(columns_cnt)
for rownum, f_id in enumerate(objects_dict):
attr_values_list = list(objects_dict[f_id].values())
for columnnum, attr_value in enumerate(attr_values_list):
item = QTableWidgetItem()
item.setData(Qt.EditRole, attr_value)
table.setItem(rownum, columnnum, item)
table.setHorizontalHeaderLabels(headers_labels_list)
table.resizeColumnsToContents()
table.resizeRowsToContents()
table.setColumnHidden(0, True)
table.setColumnHidden(1, True)
table.setColumnHidden(2, False)
def append_row(table, label, data):
"""Append new row to table widget.
:param table: The table that shall have the row added to it.
:type table: QTableWidget
:param label: Label for the row.
:type label: str
:param data: custom data associated with label value.
:type data: str
"""
# noinspection PyUnresolvedReferences
count = table.rowCount()
# noinspection PyUnresolvedReferences
table.insertRow(table.rowCount())
items = QTableWidgetItem(label)
# see for details of why we follow this pattern
# http://stackoverflow.com/questions/9257422/
# how-to-get-the-original-python-data-from-qvariant
# Make the value immutable.
variant = (data,)
# To retrieve it again you would need to do:
# value = myVariant.toPyObject()[0]
items.setData(Qt.UserRole, variant)
# set scenario status (ready or not) into table
# noinspection PyUnresolvedReferences
table.setItem(count, 0, items)
# noinspection PyUnresolvedReferences
table.setItem(count, 1, QTableWidgetItem(data['status']))
def on_connectBtn_clicked(self):
self.setCursor(Qt.WaitCursor)
wfs = self.wfs()
self.featureTypesTableWidget.clear()
self.featureTypesTableWidget.setRowCount(0)
self.featureTypesTableWidget.setHorizontalHeaderLabels(
["Feature type", "Title"])
row = 0
for feature_type, md in wfs.contents.items():
self.featureTypesTableWidget.insertRow(row)
item = QTableWidgetItem(feature_type)
item.setData(Qt.UserRole, feature_type)
self.featureTypesTableWidget.setItem(row, 0, item)
item = QTableWidgetItem(md.title)
self.featureTypesTableWidget.setItem(row, 1, item)
row += 1
self.featureTypesTableWidget.sortItems(1)
self.storedQueriesListWidget.clear()
if hasattr(wfs, "storedqueries"):
for stored_query in list(wfs.storedqueries):
params = ', '.join([
"{}: {}".format(p.name, p.type)
for p in stored_query.parameters
])
self.storedQueriesListWidget.addItem("{}({})".format(
stored_query.id, params))
self.storedQueriesListWidget.sortItems()
self.unsetCursor()
def fill_row(self, receiver_t_id, receiver_name, receiver_docid, row):
item = QTableWidgetItem(receiver_name)
item.setData(Qt.UserRole, receiver_t_id)
self.tbl_receivers.setItem(row, 0, item)
item2 = QTableWidgetItem(receiver_docid)
item2.setData(Qt.UserRole, receiver_t_id)
self.tbl_receivers.setItem(row, 1, item2)
def createTableItem(column_name, layer, value):
idx_field = layer.fields().indexFromName(column_name)
if idx_field > -1:
value = CommonTools.representFieldValueByType(
idx_field, layer, value)
item = QTableWidgetItem()
item.setData(Qt.EditRole, value)
return item
def reloadProject(self):
"""
Load all layers from the map layer registry into the table.
"""
self.layersTable.setRowCount(0)
self.layersTable.setSortingEnabled(False)
for layer in self.project.mapLayers().values():
layer_source = LayerSource(layer)
count = self.layersTable.rowCount()
self.layersTable.insertRow(count)
item = QTableWidgetItem(layer.name())
item.setData(Qt.UserRole, layer_source)
item.setData(Qt.EditRole, layer.name())
self.layersTable.setItem(count, 0, item)
cbx = QComboBox()
for action, description in layer_source.available_actions:
cbx.addItem(description)
cbx.setItemData(cbx.count() - 1, action)
if layer_source.action == action:
cbx.setCurrentIndex(cbx.count() - 1)
self.layersTable.setCellWidget(count, 1, cbx)
self.layersTable.resizeColumnsToContents()
self.layersTable.sortByColumn(0, Qt.AscendingOrder)
self.layersTable.setSortingEnabled(True)
# Load Map Themes
for theme in self.project.mapThemeCollection().mapThemes():
self.mapThemeComboBox.addItem(theme)
self.layerComboBox.setFilters(QgsMapLayerProxyModel.RasterLayer)
self.__project_configuration = ProjectConfiguration(self.project)
self.createBaseMapGroupBox.setChecked(
self.__project_configuration.create_base_map)
if self.__project_configuration.base_map_type == ProjectProperties.BaseMapType.SINGLE_LAYER:
self.singleLayerRadioButton.setChecked(True)
else:
self.mapThemeRadioButton.setChecked(True)
self.mapThemeComboBox.setCurrentIndex(
self.mapThemeComboBox.findText(
self.__project_configuration.base_map_theme))
layer = self.project.mapLayer(
self.__project_configuration.base_map_layer)
self.layerComboBox.setLayer(layer)
self.mapUnitsPerPixel.setText(
str(self.__project_configuration.base_map_mupp))
self.tileSize.setText(
str(self.__project_configuration.base_map_tile_size))
self.onlyOfflineCopyFeaturesInAoi.setChecked(
self.__project_configuration.offline_copy_only_aoi)
def __init__(self, parent=None):
settings = Settings()
QDialog.__init__(self, parent)
SettingDialog.__init__(self,
setting_manager=settings,
mode=UpdateMode.DialogAccept)
self.setupUi(self)
self.search_line_edit.textChanged.connect(self.filter_rows)
self.select_all_button.pressed.connect(self.select_all)
self.unselect_all_button.pressed.connect(
lambda: self.select_all(False))
self.keep_scale.toggled.connect(self.point_scale.setDisabled)
self.keep_scale.toggled.connect(self.scale_label.setDisabled)
self.skipped_dataproducts.setRowCount(len(DATA_PRODUCTS))
self.skipped_dataproducts.setColumnCount(2)
self.skipped_dataproducts.setHorizontalHeaderLabels(
(self.tr('Name'), self.tr('ID')))
self.skipped_dataproducts.setSelectionBehavior(
QAbstractItemView.SelectRows)
self.skipped_dataproducts.setSelectionMode(
QAbstractItemView.SingleSelection)
r = 0
for _id, name in DATA_PRODUCTS.items():
item = QTableWidgetItem(name)
item.setData(Qt.UserRole, _id)
item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsUserCheckable)
self.skipped_dataproducts.setItem(r, 0, item)
self.skipped_dataproducts.setItem(r, 1, QTableWidgetItem(_id))
r += 1
self.skipped_dataproducts.horizontalHeader().setStretchLastSection(
True)
self.skipped_dataproducts.resizeColumnsToContents()
self.settings = settings
self.init_widgets()
sd_widget: TableWidgetStringListWidget = self.setting_widget(
'skipped_dataproducts')
sd_widget.column = 0
sd_widget.userdata = True
sd_widget.invert = True
self.setting_widget('wms_image_format').auto_populate()
self.setting_widget('default_layer_loading_mode').auto_populate()
self.pg_service.setPlaceholderText(DEFAULT_PG_SERVICE)
self.pg_host.setPlaceholderText(DEFAULT_PG_HOST)
self.service_url.setPlaceholderText(DEFAULT_BASE_URL)
self.pg_host.setShowClearButton(True)
self.service_url.setShowClearButton(True)
def 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 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_party_item(self, value):
# Party's info comes in a list or a list of lists if it's a group party
display_value = ''
if value != NULL:
if type(value) is list and value:
display_value = "{} {}".format(len(value),
QCoreApplication.translate("DockWidgetChanges", "parties") if len(value)>1 else QCoreApplication.translate("DockWidgetChanges", "party"))
#else:
# display_value = QCoreApplication.translate("DockWidgetChanges", "0 parties")
item = QTableWidgetItem(display_value)
item.setData(Qt.UserRole, value)
return item
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 restore_setting_1d_table(self, name, table):
elements = get_layer_setting(self.layer, name)
if elements is None:
array_str = QSettings().value('irmt/%s' % name, None)
if array_str:
elements = json.loads(array_str)
else:
elements = list(RECOVERY_DEFAULTS[name])
table.setRowCount(1)
table.setColumnCount(len(elements))
for col in range(table.columnCount()):
item = QTableWidgetItem()
item.setData(Qt.DisplayRole, elements[col])
table.setItem(0, col, item)
table.resizeRowsToContents()
table.resizeColumnsToContents()
def drawFieldsTable(
self
): # Draws the fields table on startup and redraws it when changed
fields = self.fields
self.fieldsTable.setRowCount(0)
for i in range(len(fields)):
self.fieldsTable.setRowCount(i + 1)
item = QTableWidgetItem(fields[i].name())
item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
item.setData(Qt.UserRole, i) # set field index
self.fieldsTable.setItem(i, 0, item)
item = QTableWidgetItem(self.formatFieldType(fields[i]))
item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
self.fieldsTable.setItem(i, 1, item)
self.fieldsTable.setColumnWidth(0, 128)
self.fieldsTable.setColumnWidth(1, 96)
def selectSource(self):
'''
source feature selection procedure
'''
if self.layerHighlighted:
self.resetSource()
try:
self.dock.tableWidget.itemChanged.disconnect(self.highLightCellOverride)
except:
pass
#take first selected feature as source feature
self.sourceFeat = self.selectedFeature
#hightlight source feature with rubberband
self.sourceEvid.setToGeometry(self.sourceFeat.geometry(),self.selectedLayer)
#get current layer attributes labels list
field_names = self.scanLayerFieldsNames(self.selectedLayer)
field_types = self.scanLayerFieldsTypes(self.selectedLayer)
self.sourceAttrsTab=[]
self.dock.tableWidget.setRowCount(len(field_names))
#loading attributes labels and values in QTableWidget
for n in range(0,len(field_names)):
item=QTableWidgetItem()
item.setFlags(item.flags() | Qt.ItemIsUserCheckable)
item.setCheckState(Qt.Unchecked)
item.setText("")
#set first column as checkbox
self.dock.tableWidget.setItem(n,0,item)
#set second colunm as attribute label as qcombobox widget
self.dock.tableWidget.setCellWidget(n,1,self.setComboField(field_names[n],field_types[n],self.canvas.currentLayer()))
#set third column as attribute value
item = QTableWidgetItem()
item.setData(Qt.DisplayRole,self.sourceFeat.attributes()[n])
self.dock.tableWidget.setItem(n,2,item)
#resize table to contents
self.dock.tableWidget.resizeColumnsToContents()
self.dock.tableWidget.horizontalHeader().setStretchLastSection(True)
#procedure to recover same field selection if current source feature has the same layer of the precedent one
if self.selectedLayer.id() != self.activeLayer:
self.sourceAttrs={}
self.activeLayer = self.selectedLayer.id()
else:
for Attr in self.sourceAttrs:
self.dock.tableWidget.item(Attr,0).setCheckState(Qt.Checked)
#Enable button to apply or reset
self.dock.ResetSource.setEnabled(True)
self.dock.tableWidget.itemChanged.connect(self.highLightCellOverride)
self.checkOnLayerChange(self.canvas.currentLayer())
def onAdd(self, qgs_type_storage: str = "file"):
"""Add a new line to the table.
:param qgs_type_storage: project storage type, defaults to "file"
:type qgs_type_storage: str, optional
"""
row = self.tableWidget.rowCount()
self.tableWidget.setRowCount(row + 1)
# edit button
self.addEditButton(row, qgs_type_storage)
# project name
itemName = QTableWidgetItem()
itemName.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
self.tableWidget.setItem(row, self.cols.name, itemName)
name_lineedit = QLineEdit()
name_lineedit.setPlaceholderText(self.tr("Use project title"))
self.tableWidget.setCellWidget(row, self.cols.name, name_lineedit)
# project storage type
self.tableWidget.setCellWidget(
row, self.cols.type_storage,
self.mk_prj_storage_icon(qgs_type_storage))
# menu location
location_combo = QComboBox()
for pk in self.LOCATIONS:
if not (pk == "merge" and row == 0):
location_combo.addItem(self.LOCATIONS[pk]["label"], pk)
location_combo.setCurrentIndex(0)
self.tableWidget.setCellWidget(row, self.cols.type_menu_location,
location_combo)
# project file path
itemFile = QTableWidgetItem()
itemFile.setData(Qt.UserRole, qgs_type_storage)
itemFile.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
self.tableWidget.setItem(row, self.cols.uri, itemFile)
filepath_lineedit = QLineEdit()
filepath_lineedit.textChanged.connect(self.onTextChanged)
self.tableWidget.setCellWidget(row, self.cols.uri, filepath_lineedit)
# apply table styling
self.tableTunning()
def populate_function_table_1(self):
"""Populate the tblFunctions1 table with available functions."""
hazards = deepcopy(hazard_all)
exposures = exposure_all
self.lblAvailableFunctions1.clear()
self.tblFunctions1.clear()
self.tblFunctions1.setColumnCount(len(hazards))
self.tblFunctions1.setRowCount(len(exposures))
for i in range(len(hazards)):
hazard = hazards[i]
item = QTableWidgetItem()
item.setIcon(QIcon(get_image_path(hazard)))
item.setText(hazard['name'].capitalize())
item.setTextAlignment(Qt.AlignLeft)
self.tblFunctions1.setHorizontalHeaderItem(i, item)
for i in range(len(exposures)):
exposure = exposures[i]
item = QTableWidgetItem()
item.setIcon(QIcon(get_image_path(exposure)))
item.setText(exposure['name'].capitalize())
self.tblFunctions1.setVerticalHeaderItem(i, item)
developer_mode = setting('developer_mode', False, bool)
for hazard in hazards:
for exposure in exposures:
item = QTableWidgetItem()
if (exposure in hazard['disabled_exposures'] and not
developer_mode):
background_colour = unavailable_option_color
# Set it disable and un-selectable
item.setFlags(
item.flags() & ~
Qt.ItemIsEnabled & ~
Qt.ItemIsSelectable
)
else:
background_colour = available_option_color
item.setBackground(QBrush(background_colour))
item.setFont(big_font)
item.setTextAlignment(Qt.AlignCenter | Qt.AlignHCenter)
item.setData(RoleHazard, hazard)
item.setData(RoleExposure, exposure)
self.tblFunctions1.setItem(
exposures.index(exposure), hazards.index(hazard), item)
self.parent.pbnNext.setEnabled(False)
def populate_function_table_1(self):
"""Populate the tblFunctions1 table with available functions."""
hazards = deepcopy(hazard_all)
exposures = exposure_all
self.lblAvailableFunctions1.clear()
self.tblFunctions1.clear()
self.tblFunctions1.setColumnCount(len(hazards))
self.tblFunctions1.setRowCount(len(exposures))
for i in range(len(hazards)):
hazard = hazards[i]
item = QTableWidgetItem()
item.setIcon(QIcon(get_image_path(hazard)))
item.setText(hazard['name'].capitalize())
item.setTextAlignment(Qt.AlignLeft)
self.tblFunctions1.setHorizontalHeaderItem(i, item)
for i in range(len(exposures)):
exposure = exposures[i]
item = QTableWidgetItem()
item.setIcon(QIcon(get_image_path(exposure)))
item.setText(exposure['name'].capitalize())
self.tblFunctions1.setVerticalHeaderItem(i, item)
developer_mode = setting('developer_mode', False, bool)
for hazard in hazards:
for exposure in exposures:
item = QTableWidgetItem()
if (exposure in hazard['disabled_exposures'] and not
developer_mode):
background_colour = unavailable_option_color
# Set it disable and un-selectable
item.setFlags(
item.flags() & ~
Qt.ItemIsEnabled & ~
Qt.ItemIsSelectable
)
else:
background_colour = available_option_color
item.setBackground(QBrush(background_colour))
item.setFont(big_font)
item.setTextAlignment(Qt.AlignCenter | Qt.AlignHCenter)
item.setData(RoleHazard, hazard)
item.setData(RoleExposure, exposure)
self.tblFunctions1.setItem(
exposures.index(exposure), hazards.index(hazard), item)
self.parent.pbnNext.setEnabled(False)
def applyConceptToColumn(self, costumURI=False):
print("test")
if costumURI:
if self.costumproperty.text() == "":
return
toinsert = self.costumproperty.text()
else:
if self.searchResult.count() == 0:
return
toinsert = str(self.searchResult.currentItem().data(1))
if self.bothOptions == True:
haschanged = False
if self.currentprefixes != None:
for prefix in self.currentprefixes:
if self.currentprefixes[prefix] in toinsert:
toinsert = toinsert.replace(
self.currentprefixes[prefix], prefix + ":")
haschanged = True
if haschanged:
self.table.insertPlainText(toinsert)
else:
self.table.insertPlainText("<" + toinsert + ">")
elif self.interlinkOrEnrich == -1:
self.table.setText(str(toinsert))
else:
if costumURI:
item = QTableWidgetItem(toinsert)
item.setText(toinsert)
else:
item = QTableWidgetItem(self.searchResult.currentItem().text())
item.setText(self.searchResult.currentItem().text())
item.setData(1, toinsert)
if self.interlinkOrEnrich:
self.table.setItem(self.currentrow, self.currentcol, item)
else:
item2 = QTableWidgetItem()
item2.setText(self.tripleStoreEdit.currentText())
item2.setData(
0,
self.triplestoreconf[self.tripleStoreEdit.currentIndex() +
1]["endpoint"])
self.table.setItem(self.currentrow, self.currentcol, item)
self.table.setItem(self.currentrow, (self.currentcol + 1),
item2)
self.close()
def restoreState(self,layer,table):
if layer.id() in self.states.keys():
table.blockSignals(True)
#clear dock widget
while table.rowCount()>0:
table.removeRow(0)
#add rows
table.setRowCount(len(self.states[layer.id()]))
for n in range(0, len(self.states[layer.id()])):
row = self.states[layer.id()][n]
#set first column as checkbox
item=QTableWidgetItem()
item.setFlags(item.flags() | Qt.ItemIsUserCheckable)
if row[0]:
item.setCheckState(Qt.Checked)
else:
item.setCheckState(Qt.Unchecked)
item.setText("")
table.setItem(n,0,item)
#set second column as combobox
combo = QComboBox();
combo.addItems(row[1])
#print (row[1],row[2])
combo.setCurrentIndex(row[2])
table.setCellWidget(n,1,combo)
#set third column as attribute value
item = QTableWidgetItem(row[3])
item.setData(Qt.DisplayRole,row[4])
if row[5]:
item.setForeground(QBrush(QColor(0,0,0)))
else:
item.setForeground(QBrush(QColor(130,130,130)))
if row[6]:
item.setBackground(QBrush(QColor(183,213,225)))
table.setItem(n,2,item)
table.blockSignals(False)
return True
else:
return None
def addCoord(self, lat, lon, label='', data=[]):
'''Add a coordinate to the list.'''
rowcnt = self.resultsTable.rowCount()
if rowcnt >= self.maxResults:
return
self.resultsTable.blockSignals(True)
self.resultsTable.insertRow(rowcnt)
item = QTableWidgetItem(str(lat))
item.setData(Qt.UserRole, LatLonItem(lat, lon, label, data))
item.setFlags(item.flags() & ~Qt.ItemIsEditable)
self.resultsTable.setItem(rowcnt, 0, item)
item = QTableWidgetItem(str(lon))
item.setFlags(item.flags() & ~Qt.ItemIsEditable)
self.resultsTable.setItem(rowcnt, 1, item)
self.resultsTable.setItem(rowcnt, 2, QTableWidgetItem(label))
if self.numCol > 3 and len(data) > 0:
for i in range( min(self.numCol-3, len(data))):
self.resultsTable.setItem(rowcnt, i+3, QTableWidgetItem(data[i]))
self.resultsTable.blockSignals(False)
return(rowcnt)
def addCoord(self, lat, lon, label='', data=[]):
'''Add a coordinate to the list.'''
rowcnt = self.resultsTable.rowCount()
if rowcnt >= self.maxResults:
return
self.resultsTable.blockSignals(True)
self.resultsTable.insertRow(rowcnt)
item = QTableWidgetItem(str(lat))
item.setData(Qt.UserRole, LatLonItem(lat, lon, label, data))
item.setFlags(item.flags() & ~Qt.ItemIsEditable)
self.resultsTable.setItem(rowcnt, 0, item)
item = QTableWidgetItem(str(lon))
item.setFlags(item.flags() & ~Qt.ItemIsEditable)
self.resultsTable.setItem(rowcnt, 1, item)
self.resultsTable.setItem(rowcnt, 2, QTableWidgetItem(label))
if self.numCol > 3 and len(data) > 0:
for i in range(min(self.numCol - 3, len(data))):
self.resultsTable.setItem(rowcnt, i + 3, QTableWidgetItem(data[i]))
self.resultsTable.blockSignals(False)
return(rowcnt)
def update_from_layers(self, is_new=False):
layers = QgsProject.instance().mapLayers()
n = 0
for name, layer in layers.items():
if layer.name() == "Mask":
continue
# skip non vector layers
if not isinstance(layer, QgsVectorLayer):
continue
# skip layers without labels
if layer.labeling() is None:
continue
do_limit = False
did_limit = layer.id() in self.limited
do_limit = mask_filter.has_mask_filter(layer)
if do_limit and not did_limit:
self.limited.append(layer.id())
if not do_limit and did_limit:
self.limited.remove(layer.id())
self.ui.layerTable.insertRow(n)
name_item = QTableWidgetItem()
name_item.setData(Qt.DisplayRole, layer.name())
self.ui.layerTable.setItem(n, 1, name_item)
w = QCheckBox(self.ui.layerTable)
w.setEnabled(layer.labeling() is not None)
w.setChecked(do_limit or is_new)
self.ui.layerTable.setCellWidget(n, 0, w)
item = QTableWidgetItem()
item.setData(Qt.UserRole, layer)
self.ui.layerTable.setItem(n, 0, item)
n += 1
self.ui.selectAllBtn.setEnabled(n != 0)
self.ui.unselectAllBtn.setEnabled(n != 0)
def applyMapping(self):
resmap = {}
for row in range(self.valmaptable.rowCount()):
fromm = self.valmaptable.item(row, 0).text()
to = self.valmaptable.item(row, 1).text()
resmap[fromm] = to
msgBox = QMessageBox()
msgBox.setText(str(resmap))
msgBox.exec()
item = QTableWidgetItem("ValueMap{}")
item.setData(1, str(json.dumps(resmap)))
if "SELECT ?item\n WHERE {\n ?item ?rel %%" + self.fieldname + "%% . \n}" != self.queryedit.toPlainText(
):
item.setData(2, self.queryedit.toPlainText())
item.setData(3, self.tripleStoreEdit.currentText())
self.table.setItem(self.currentrow, self.currentcol, item)
self.close()
return resmap
def _edit_row(self, row, server_url):
""" Internal function to edit a row. """
# URL
cell = QTableWidgetItem()
cell.setText(server_url)
cell.setData(Qt.UserRole, server_url)
self.table.setItem(row, 0, cell)
# Version
cell = QTableWidgetItem()
cell.setText(tr(''))
cell.setData(Qt.UserRole, None)
self.table.setItem(row, 1, cell)
# Action
cell = QTableWidgetItem()
cell.setText('')
cell.setData(Qt.UserRole, '')
self.table.setItem(row, 2, cell)
self.table.clearSelection()
self.fetch(server_url, row)
def reloadProject(self):
"""
Load all layers from the map layer registry into the table.
"""
self.unsupportedLayersList = list()
self.layersTable.setRowCount(0)
self.layersTable.setSortingEnabled(False)
for layer in list(self.project.mapLayers().values()):
layer_source = LayerSource(layer)
if not layer_source.is_supported:
self.unsupportedLayersList.append(layer_source)
count = self.layersTable.rowCount()
self.layersTable.insertRow(count)
item = QTableWidgetItem(layer.name())
item.setData(Qt.UserRole, layer_source)
item.setData(Qt.EditRole, layer.name())
self.layersTable.setItem(count, 0, item)
cbx = QComboBox()
for action, description in layer_source.available_actions:
cbx.addItem(description)
cbx.setItemData(cbx.count() - 1, action)
if layer_source.action == action:
cbx.setCurrentIndex(cbx.count() - 1)
self.layersTable.setCellWidget(count, 1, cbx)
self.layersTable.resizeColumnsToContents()
self.layersTable.sortByColumn(0, Qt.AscendingOrder)
self.layersTable.setSortingEnabled(True)
# Load Map Themes
for theme in self.project.mapThemeCollection().mapThemes():
self.mapThemeComboBox.addItem(theme)
self.layerComboBox.setFilters(QgsMapLayerProxyModel.RasterLayer)
self.__project_configuration = ProjectConfiguration(self.project)
self.createBaseMapGroupBox.setChecked(self.__project_configuration.create_base_map)
if self.__project_configuration.base_map_type == ProjectProperties.BaseMapType.SINGLE_LAYER:
self.singleLayerRadioButton.setChecked(True)
else:
self.mapThemeRadioButton.setChecked(True)
self.mapThemeComboBox.setCurrentIndex(
self.mapThemeComboBox.findText(self.__project_configuration.base_map_theme))
layer = QgsProject.instance().mapLayer(self.__project_configuration.base_map_layer)
self.layerComboBox.setLayer(layer)
self.mapUnitsPerPixel.setText(str(self.__project_configuration.base_map_mupp))
self.tileSize.setText(str(self.__project_configuration.base_map_tile_size))
self.onlyOfflineCopyFeaturesInAoi.setChecked(self.__project_configuration.offline_copy_only_aoi)
if self.unsupportedLayersList:
self.unsupportedLayers.setVisible(True)
unsuppoerted_layers_text = '<b>{}</b><br>'.format(self.tr('Warning'))
unsuppoerted_layers_text += self.tr("There are unsupported layers in your project. They will not be available on QField.")
unsuppoerted_layers_text += '<ul>'
for layer in self.unsupportedLayersList:
unsuppoerted_layers_text += '<li>' + '<b>' + layer.name + ':</b> ' + layer.warning
unsuppoerted_layers_text += '<ul>'
self.unsupportedLayers.setText(unsuppoerted_layers_text)
def __init__(self, parent, plugin):
self.plugin = plugin
self.parent = parent
QDialog.__init__(self, parent)
self.setupUi(self)
self.defaultcursor = self.cursor
self.setWindowTitle(self.windowTitle() +
" - {} v{}".format(__title__, __version__))
self.setWindowIcon(QIcon(str(DIR_PLUGIN_ROOT /
"resources/gear.svg")), )
# column order reference
self.cols = TABLE_COLUMNS_ORDER(edit=0,
name=1,
type_menu_location=3,
type_storage=2,
uri=4)
# menu locations
self.LOCATIONS = {
"new": {
"index": 0,
"label": QgsApplication.translate("ConfDialog", "New menu",
None),
},
"layer": {
"index":
1,
"label":
QgsApplication.translate("ConfDialog", "Add layer menu", None),
},
"merge": {
"index":
2,
"label":
QgsApplication.translate("ConfDialog", "Merge with previous",
None),
},
}
# -- Configured projects (table and related buttons)
self.tableWidget.horizontalHeader().setSectionResizeMode(
QHeaderView.ResizeToContents)
self.tableWidget.setRowCount(len(self.plugin.projects))
self.buttonBox.accepted.connect(self.onAccepted)
self.btnDelete.clicked.connect(self.onDelete)
self.btnDelete.setText(None)
self.btnDelete.setIcon(
QIcon(QgsApplication.iconPath("mActionDeleteSelected.svg")))
self.btnUp.clicked.connect(self.onMoveUp)
self.btnUp.setText(None)
self.btnUp.setIcon(QIcon(
QgsApplication.iconPath("mActionArrowUp.svg")))
self.btnDown.clicked.connect(self.onMoveDown)
self.btnDown.setText(None)
self.btnDown.setIcon(
QIcon(QgsApplication.iconPath("mActionArrowDown.svg")))
# add button
self.btnAdd.setIcon(QIcon(QgsApplication.iconPath("mActionAdd.svg")))
self.addMenu = QMenu(self.btnAdd)
add_option_file = QAction(
QIcon(QgsApplication.iconPath("mIconFile.svg")),
self.tr("Add from file"),
self.addMenu,
)
add_option_pgdb = QAction(
QIcon(QgsApplication.iconPath("mIconPostgis.svg")),
self.tr("Add from PostgreSQL database"),
self.addMenu,
)
add_option_http = QAction(
QIcon(str(DIR_PLUGIN_ROOT / "resources/globe.svg")),
self.tr("Add from URL"),
self.addMenu,
)
add_option_file.triggered.connect(partial(self.onAdd, "file"))
add_option_http.triggered.connect(partial(self.onAdd, "http"))
add_option_pgdb.triggered.connect(partial(self.onAdd, "database"))
self.addMenu.addAction(add_option_file)
self.addMenu.addAction(add_option_pgdb)
self.addMenu.addAction(add_option_http)
self.btnAdd.setMenu(self.addMenu)
for idx, project in enumerate(self.plugin.projects):
# edit project
self.addEditButton(idx, guess_type_from_uri(project.get("file")))
# project name
itemName = QTableWidgetItem(project.get("name"))
itemName.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
self.tableWidget.setItem(idx, self.cols.name, itemName)
le = QLineEdit()
le.setText(project.get("name"))
le.setPlaceholderText(self.tr("Use project title"))
self.tableWidget.setCellWidget(idx, self.cols.name, le)
# project storage type
self.tableWidget.setCellWidget(
idx,
self.cols.type_storage,
self.mk_prj_storage_icon(
guess_type_from_uri(project.get("file"))),
)
# project menu location
location_combo = QComboBox()
for pk in self.LOCATIONS:
if not (pk == "merge" and idx == 0):
location_combo.addItem(self.LOCATIONS[pk]["label"], pk)
try:
location_combo.setCurrentIndex(
self.LOCATIONS[project["location"]]["index"])
except Exception:
location_combo.setCurrentIndex(0)
self.tableWidget.setCellWidget(idx, self.cols.type_menu_location,
location_combo)
# project path (guess type stored into data)
itemFile = QTableWidgetItem(project.get("file"))
itemFile.setData(Qt.UserRole,
guess_type_from_uri(project.get("file")))
itemFile.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
self.tableWidget.setItem(idx, self.cols.uri, itemFile)
le = QLineEdit()
le.setText(project.get("file"))
try:
le.setStyleSheet("color: {};".format(
"black" if project["valid"] else "red"))
except Exception:
le.setStyleSheet("color: {};".format("black"))
self.tableWidget.setCellWidget(idx, self.cols.uri, le)
le.textChanged.connect(self.onTextChanged)
# -- Options
self.cbxLoadAll.setChecked(self.plugin.optionLoadAll)
self.cbxLoadAll.setTristate(False)
self.cbxCreateGroup.setCheckState(self.plugin.optionCreateGroup)
self.cbxCreateGroup.setTristate(False)
self.cbxShowTooltip.setCheckState(self.plugin.optionTooltip)
self.cbxShowTooltip.setTristate(False)
self.tableTunning()
def _edit_row(self, row, data):
"""Internal function to edit a row."""
self._layer = None
for i, key in enumerate(data.keys()):
value = data[key]
cell = QTableWidgetItem()
input_type = self.definitions.layer_config[key]['type']
if input_type == InputType.Layer:
layer = QgsProject.instance().mapLayer(value)
self._layer = layer
cell.setText(layer.name())
cell.setData(Qt.UserRole, layer.id())
cell.setData(
Qt.ToolTipRole, '{} ({})'.format(layer.name(),
layer.crs().authid()))
cell.setIcon(QgsMapLayerModel.iconForLayer(layer))
elif input_type == InputType.Field:
cell.setText(value)
cell.setData(Qt.UserRole, value)
cell.setData(Qt.ToolTipRole, value)
# Get the icon for the field
if self._layer:
index = self._layer.fields().indexFromName(value)
if index >= 0:
cell.setIcon(self._layer.fields().iconForField(index))
elif input_type == InputType.Fields:
cell.setText(value)
cell.setData(Qt.UserRole, value)
cell.setData(Qt.ToolTipRole, value)
elif input_type == InputType.Color:
cell.setText(value)
cell.setData(Qt.UserRole, value)
cell.setData(Qt.ToolTipRole, value)
if value:
cell.setData(Qt.DecorationRole, QColor(value))
elif input_type == InputType.CheckBox:
if value:
cell.setText('✓')
cell.setData(Qt.UserRole, True)
cell.setData(Qt.ToolTipRole, tr('True'))
else:
cell.setText('')
cell.setData(Qt.UserRole, False)
cell.setData(Qt.ToolTipRole, tr('False'))
cell.setTextAlignment(Qt.AlignCenter)
elif input_type == InputType.List:
cell.setData(Qt.UserRole, value)
cell.setData(Qt.ToolTipRole, value)
items = self.definitions.layer_config[key].get('items')
if items:
for item_enum in items:
if item_enum.value['data'] == value:
text = item_enum.value['label']
icon = item_enum.value.get('icon')
break
else:
raise Exception(
'Error with list value="{}"'.format(value))
cell.setText(text)
if icon:
cell.setIcon(QIcon(icon))
else:
cell.setText(value)
elif input_type == InputType.SpinBox:
cell.setText(str(value))
cell.setData(Qt.UserRole, value)
cell.setData(Qt.ToolTipRole, value)
elif input_type == InputType.Text:
cell.setText(value)
cell.setData(Qt.UserRole, value)
cell.setData(Qt.ToolTipRole, value)
else:
raise Exception(
'InputType "{}" not implemented'.format(input_type))
self.table.setItem(row, i, cell)
self._layer = None
self.table.clearSelection()
def _edit_trace_row(self, row, data):
"""Internal function to edit a row."""
for i, key in enumerate(self.config.layer_config['traces']['items']):
cell = QTableWidgetItem()
value = data.get(key)
if not value:
cell.setText('')
cell.setData(Qt.UserRole, '')
self.traces.setItem(row, i, cell)
continue
input_type = self.config.layer_config[key]['type']
if input_type == InputType.Field:
cell.setText(value)
cell.setData(Qt.UserRole, value)
cell.setData(Qt.ToolTipRole, value)
# Get the icon for the field
if self.layer:
index = self.layer.currentLayer().fields().indexFromName(
value)
if index >= 0:
cell.setIcon(
self.layer.currentLayer().fields().iconForField(
index))
elif input_type == InputType.Color:
cell.setText(value)
cell.setData(Qt.UserRole, value)
cell.setData(Qt.ToolTipRole, value)
if value:
cell.setData(Qt.DecorationRole, QColor(value))
else:
raise Exception(
'InputType "{}" not implemented'.format(input_type))
self.traces.setItem(row, i, cell)
self.traces.clearSelection()
def create_checkbox_item(attribute):
item = QTableWidgetItem()
item.setFlags(Qt.ItemIsUserCheckable | Qt.ItemIsEnabled)
item.setCheckState(Qt.Unchecked)
item.setData(1, attribute)
return item
def reloadProject(self):
"""
Load all layers from the map layer registry into the table.
"""
self.unsupportedLayersList = list()
self.layersTable.setRowCount(0)
self.layersTable.setSortingEnabled(False)
for layer in list(self.project.mapLayers().values()):
layer_source = LayerSource(layer)
if not layer_source.is_supported:
self.unsupportedLayersList.append(layer_source)
count = self.layersTable.rowCount()
self.layersTable.insertRow(count)
item = QTableWidgetItem(layer.name())
item.setData(Qt.UserRole, layer_source)
item.setData(Qt.EditRole, layer.name())
self.layersTable.setItem(count, 0, item)
cbx = QComboBox()
for action, description in layer_source.available_actions:
cbx.addItem(description)
cbx.setItemData(cbx.count() - 1, action)
if layer_source.action == action:
cbx.setCurrentIndex(cbx.count() - 1)
self.layersTable.setCellWidget(count, 1, cbx)
self.layersTable.resizeColumnsToContents()
self.layersTable.sortByColumn(0, Qt.AscendingOrder)
self.layersTable.setSortingEnabled(True)
# Load Map Themes
for theme in self.project.mapThemeCollection().mapThemes():
self.mapThemeComboBox.addItem(theme)
self.layerComboBox.setFilters(QgsMapLayerProxyModel.RasterLayer)
self.__project_configuration = ProjectConfiguration(self.project)
self.createBaseMapGroupBox.setChecked(
self.__project_configuration.create_base_map)
if self.__project_configuration.base_map_type == ProjectProperties.BaseMapType.SINGLE_LAYER:
self.singleLayerRadioButton.setChecked(True)
else:
self.mapThemeRadioButton.setChecked(True)
self.mapThemeComboBox.setCurrentIndex(
self.mapThemeComboBox.findText(
self.__project_configuration.base_map_theme))
layer = QgsProject.instance().mapLayer(
self.__project_configuration.base_map_layer)
self.layerComboBox.setLayer(layer)
self.mapUnitsPerPixel.setText(
str(self.__project_configuration.base_map_mupp))
self.tileSize.setText(
str(self.__project_configuration.base_map_tile_size))
self.onlyOfflineCopyFeaturesInAoi.setChecked(
self.__project_configuration.offline_copy_only_aoi)
if self.unsupportedLayersList:
self.unsupportedLayers.setVisible(True)
unsuppoerted_layers_text = '<b>{}</b><br>'.format(
self.tr('Warning'))
unsuppoerted_layers_text += self.tr(
"There are unsupported layers in your project. They will not be available on QField."
)
unsuppoerted_layers_text += '<ul>'
for layer in self.unsupportedLayersList:
unsuppoerted_layers_text += '<li>' + '<b>' + layer.name + ':</b> ' + layer.warning
unsuppoerted_layers_text += '<ul>'
self.unsupportedLayers.setText(unsuppoerted_layers_text)
def reloadProject(self):
"""
Load all layers from the map layer registry into the table.
"""
self.unsupportedLayersList = list()
self.photoNamingTable = PhotoNamingTableWidget()
self.photoNamingTab.layout().addWidget(self.photoNamingTable)
self.layersTable.setRowCount(0)
self.layersTable.setSortingEnabled(False)
for layer in self.project.mapLayers().values():
layer_source = LayerSource(layer)
count = self.layersTable.rowCount()
self.layersTable.insertRow(count)
item = QTableWidgetItem(layer.name())
item.setData(Qt.UserRole, layer_source)
item.setData(Qt.EditRole, layer.name())
self.layersTable.setItem(count, 0, item)
cmb = QComboBox()
set_available_actions(cmb, layer_source)
cbx = QCheckBox()
cbx.setEnabled(layer_source.can_lock_geometry)
cbx.setChecked(layer_source.is_geometry_locked)
# it's more UI friendly when the checkbox is centered, an ugly workaround to achieve it
cbx_widget = QWidget()
cbx_layout = QHBoxLayout()
cbx_layout.setAlignment(Qt.AlignCenter)
cbx_layout.setContentsMargins(0, 0, 0, 0)
cbx_layout.addWidget(cbx)
cbx_widget.setLayout(cbx_layout)
# NOTE the margin is not updated when the table column is resized, so better rely on the code above
# cbx.setStyleSheet("margin-left:50%; margin-right:50%;")
self.layersTable.setCellWidget(count, 1, cbx_widget)
self.layersTable.setCellWidget(count, 2, cmb)
if not layer_source.is_supported:
self.unsupportedLayersList.append(layer_source)
self.layersTable.item(count,0).setFlags(Qt.NoItemFlags)
self.layersTable.cellWidget(count,1).setEnabled(False)
self.layersTable.cellWidget(count,2).setEnabled(False)
cmb.setCurrentIndex(cmb.findData(SyncAction.REMOVE))
# make sure layer_source is the same instance everywhere
self.photoNamingTable.addLayerFields(layer_source)
self.layersTable.resizeColumnsToContents()
self.layersTable.sortByColumn(0, Qt.AscendingOrder)
self.layersTable.setSortingEnabled(True)
# Remove the tab when not yet suported in QGIS
if Qgis.QGIS_VERSION_INT < 31300:
self.tabWidget.removeTab(self.tabWidget.count() - 1)
# Load Map Themes
for theme in self.project.mapThemeCollection().mapThemes():
self.mapThemeComboBox.addItem(theme)
self.layerComboBox.setFilters(QgsMapLayerProxyModel.RasterLayer)
self.__project_configuration = ProjectConfiguration(self.project)
self.createBaseMapGroupBox.setChecked(self.__project_configuration.create_base_map)
if self.__project_configuration.base_map_type == ProjectProperties.BaseMapType.SINGLE_LAYER:
self.singleLayerRadioButton.setChecked(True)
else:
self.mapThemeRadioButton.setChecked(True)
self.mapThemeComboBox.setCurrentIndex(
self.mapThemeComboBox.findText(self.__project_configuration.base_map_theme))
layer = QgsProject.instance().mapLayer(self.__project_configuration.base_map_layer)
self.layerComboBox.setLayer(layer)
self.mapUnitsPerPixel.setText(str(self.__project_configuration.base_map_mupp))
self.tileSize.setText(str(self.__project_configuration.base_map_tile_size))
self.onlyOfflineCopyFeaturesInAoi.setChecked(self.__project_configuration.offline_copy_only_aoi)
if self.unsupportedLayersList:
self.unsupportedLayersLabel.setVisible(True)
unsupported_layers_text = '<b>{}: </b>'.format(self.tr('Warning'))
unsupported_layers_text += self.tr("There are unsupported layers in your project which will not be available in QField.")
unsupported_layers_text += self.tr(" If needed, you can create a Base Map to include those layers in your packaged project.")
self.unsupportedLayersLabel.setText(unsupported_layers_text)
def populateRow(self, item, idx):
id = item["place_id"]
name = item["display_name"]
try:
className = QApplication.translate("nominatim", item["class"],
None)
except:
className = ""
try:
typeName = QApplication.translate("nominatim", item["type"], None)
except:
typeName = ""
try:
wkt = item["geotext"]
except:
wkt = None
try:
osm_type = item["osm_type"]
except:
osm_type = None
bbox = {}
if osm_type == "node":
lat = item["lat"]
lng = item["lon"]
poFD = ogr.FeatureDefn("Point")
poFD.SetGeomType(ogr.wkbPoint)
oFLD = ogr.FieldDefn("id", ogr.OFTString)
poFD.AddFieldDefn(oFLD)
oFLD = ogr.FieldDefn("name", ogr.OFTString)
poFD.AddFieldDefn(oFLD)
ogrFeature = ogr.Feature(poFD)
wkt = "POINT({} {})".format(lng, lat)
ogrGeom = ogr.CreateGeometryFromWkt(wkt)
else:
try:
bbox = item["boundingbox"]
poFD = ogr.FeatureDefn("Rectangle")
poFD.SetGeomType(ogr.wkbPolygon)
oFLD = ogr.FieldDefn("id", ogr.OFTString)
poFD.AddFieldDefn(oFLD)
oFLD = ogr.FieldDefn("name", ogr.OFTString)
poFD.AddFieldDefn(oFLD)
ogrFeature = ogr.Feature(poFD)
if wkt is None:
wkt = "POLYGON(({b[2]} {b[0]}, {b[2]} {b[1]}, {b[3]} {b[1]}, {b[3]} {b[0]}, {b[2]} {b[0]}))".format(
b=bbox)
ogrGeom = ogr.CreateGeometryFromWkt(wkt)
except:
lat = item["lat"]
lng = item["lon"]
poFD = ogr.FeatureDefn("Point")
poFD.SetGeomType(ogr.wkbPoint)
oFLD = ogr.FieldDefn("id", ogr.OFTString)
poFD.AddFieldDefn(oFLD)
oFLD = ogr.FieldDefn("name", ogr.OFTString)
poFD.AddFieldDefn(oFLD)
ogrFeature = ogr.Feature(poFD)
wkt = "POINT({} {})".format(lng, lat)
ogrGeom = ogr.CreateGeometryFromWkt(wkt)
ogrFeature.SetGeometry(ogrGeom)
ogrFeature.SetFID(int(idx + 1))
ogrFeature.SetField(str("id"), str(id))
ogrFeature.SetField(str("name"), name)
item = QTableWidgetItem(name)
item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
item.setData(Qt.UserRole, ogrFeature)
self.tableResult.setItem(idx, 0, item)
itemLibelle = QTableWidgetItem(className)
itemLibelle.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
self.tableResult.setItem(idx, 1, itemLibelle)
itemType = QTableWidgetItem(typeName)
itemType.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
self.tableResult.setItem(idx, 2, itemType)
