def __init__(self, choicesJson, valueType, parent=None):
"""Constructor."""
super(QgisODKChoices, self).__init__(parent)
# Set up the user interface from Designer.
# After setupUI you can access any designer object by doing
# self.<objectname>, and you can use autoconnect slots - see
# http://qt-project.org/doc/qt-4.8/designer-using-a-ui-file.html
# #widgets-and-dialogs-with-auto-connect
self.setupUi(self)
self.choicesJson = choicesJson
choicesDict = json.loads(choicesJson)
self.choicesTable.setColumnCount(2)
self.choicesTable.setRowCount(len(choicesDict))
self.choicesTable.verticalHeader().setVisible(False)
self.choicesTable.setHorizontalHeaderItem(0,
QTableWidgetItem("Values"))
self.choicesTable.setHorizontalHeaderItem(1,
QTableWidgetItem("Labels"))
self.choicesTable.setColumnWidth(0, 127)
self.choicesTable.setColumnWidth(1, 127)
for i, choice in enumerate(choicesDict):
choiceValueWidget = QTableWidgetItem(valueType)
choiceLabelWidget = QTableWidgetItem()
choiceValueWidget.setData(Qt.EditRole, choice)
self.choicesTable.setItem(i, 0, choiceValueWidget)
choiceLabelWidget.setData(Qt.EditRole, choicesDict[choice])
self.choicesTable.setItem(i, 1, choiceLabelWidget)
self.choicesTable.sortItems(1)
self.buttonBox.accepted.connect(self.accept)
self.buttonBox.rejected.connect(self.reject)
self.rowAddButton.clicked.connect(self.rowAddAction)
self.rowRemoveButton.clicked.connect(self.rowRemoveAction)
def populateTableWidget(self, selectedLog=None):
logger.debug(">>populateTableWidget()")
selected = None
self.parametersTableWidget.clear()
self.parametersTableWidget.setSortingEnabled(False)
self.parametersTableWidget.setRowCount(
len(self._parameterTableModel._parameters))
self.parametersTableWidget.setColumnCount(
len(self._parameterTableModel.HEADERS))
self.parametersTableWidget.setHorizontalHeaderLabels(
self._parameterTableModel.HEADERS)
for row, parameter in enumerate(self._parameterTableModel._parameters):
item = QTableWidgetItem(parameter.mnemonic)
item.setData(Qt.UserRole, str(id(parameter)))
self.parametersTableWidget.setItem(row,
parametertablemodel.MNEMONIC,
item)
self.parametersTableWidget.setItem(
row, parametertablemodel.VALUE,
QTableWidgetItem(parameter.value))
self.parametersTableWidget.setItem(
row, parametertablemodel.UNIT,
QTableWidgetItem(parameter.unit))
self.parametersTableWidget.setItem(
row, parametertablemodel.DESCRIPTION,
QTableWidgetItem(parameter.description))
self.parametersTableWidget.setSortingEnabled(True)
self.parametersTableWidget.resizeColumnsToContents()
if selected is not None:
selected.setSelected(True)
self.parametersTableWidget.setCurrentItem(selected)
def update_TView(self):
if self.selected_id in self.layers.keys():
self.dockwidget.layersBox.enabled = False
attrs_names = [u"Идентификатор",u"Наименование",u"Описание",u"Условный знак"]
attrs_values = []
lif = self.iface.legendInterface()
lyrs = lif.layers()
for lyr in lyrs:
all_case = (self.selected_id == '0' and lif.isLayerVisible(lyr))
if isinstance(lyr, QgsVectorLayer) and (lyr.id() == self.selected_id or all_case):
#attrs_names = [a.name() for a in lyr.fields()]
features = lyr.getFeatures()
attrs_values += [[feat[i] for i in xrange(len(attrs_names))] for feat in features]
if not all_case:
break
self.dockwidget.tableView.setRowCount(len(attrs_values))
self.dockwidget.tableView.setColumnCount(len(attrs_names))
self.dockwidget.tableView.setHorizontalHeaderLabels(attrs_names)
for row in xrange(len(attrs_values)):
for col in xrange(len(attrs_names)):
if col < len(attrs_names) - 1:
item = QTableWidgetItem(u'%s' % attrs_values[row][col])
else:
pm = self.get_sign_image(attrs_values[row][col])
if pm:
item = QTableWidgetItem(self.config["signs"][attrs_values[row][col]].get("alias",""))
item.setData(Qt.DecorationRole, pm.scaled(20, 20))
else:
item = QTableWidgetItem(u'%s' % attrs_values[row][col])
self.dockwidget.tableView.setItem(row,col,item)
self.dockwidget.layersBox.enabled = True
def populateTable(self,filePath):
self.filePath = filePath
ui = self
table = ui.tableWidget
# table.clear()
table.setRowCount(0)
xml = file(filePath).read()
d = QtXml.QDomDocument()
d.setContent(xml)
maps = d.elementsByTagName("maplayer")
self.maps=maps
for i in range(maps.length()):
table.setRowCount(table.rowCount()+1)
info = getMapInfo(maps.item(i))
nameItem = QTableWidgetItem(info['name'])
nameItem.setFlags(QtCore.Qt.ItemIsUserCheckable|QtCore.Qt.ItemIsSelectable|QtCore.Qt.ItemIsEnabled)
nameItem.setCheckState(QtCore.Qt.Unchecked)
nameItem.setData(QtCore.Qt.UserRole,str(i))
table.setItem(i,0,nameItem)
table.setItem(i,1,FixedWidgetItem(info['mtype']))
table.setItem(i,2,FixedWidgetItem(info['geom']))
table.setItem(i,3,FixedWidgetItem(info['provider']))
ds = FixedWidgetItem(info['ds'])
ds.setData(QtCore.Qt.ToolTipRole,info['ds'])
table.setItem(i,4,ds)
def setData(self, role, value):
if role == Qt.CheckStateRole:
if value == Qt.Checked:
self.__parent.checked[self.event()] = True
else:
self.__parent.checked[self.event()] = False
QTableWidgetItem.setData(self, role, value)
def __populateLengths(self, selectedDim=None):
selected = None
self.ui.dimTableWidget.clear()
self.ui.dimTableWidget.setRowCount(self.rank)
while self.rank > len(self.lengths):
self.lengths.append(None)
headers = ["Length"]
self.ui.dimTableWidget.setColumnCount(len(headers))
self.ui.dimTableWidget.setHorizontalHeaderLabels(headers)
self.ui.dimTableWidget.setVerticalHeaderLabels(
[unicode(l + 1) for l in range(self.rank)])
for row, ln in enumerate(self.lengths):
if ln:
item = QTableWidgetItem(unicode(ln))
else:
item = QTableWidgetItem("")
item.setData(Qt.UserRole, QVariant(long(row)))
if selectedDim is not None and selectedDim == row:
selected = item
self.ui.dimTableWidget.setItem(row, 0, item)
self.ui.dimTableWidget.resizeColumnsToContents()
self.ui.dimTableWidget.horizontalHeader().setStretchLastSection(True)
if selected is not None:
selected.setSelected(True)
self.ui.dimTableWidget.setCurrentItem(selected)
self.ui.dimTableWidget.editItem(selected)
def _show_node_information(self, node):
# hide all rows
for r in range(self.info_table.rowCount()):
self.info_table.setRowHidden(r, True)
# add new information save dict[ecu_id][settings_id] = row_nr
comp_id = node.settings_dict['comp_id']
self.selection_label.setText("Selected ECU: %s" % comp_id)
for set_key in node.settings_dict.keys():
# if already exists -> show its row and skip
try:
row_nr = self._show_dict[comp_id][set_key]
self.info_table.setRowHidden(row_nr, False)
continue
except: pass
# else add it to table and show row
self.info_table.setRowCount(self.info_table.rowCount() + 1)
row_nr = self.info_table.rowCount()
item_1 = QTableWidgetItem()
item_1.setData(QtCore.Qt.EditRole, set_key)
item_2 = QTableWidgetItem()
item_2.setText(str(node.settings_dict[set_key]));
General().add_to_three_dict(self._show_dict, comp_id, set_key, row_nr)
self.info_table.setItem(row_nr - 1, 0, item_1)
self.info_table.setItem(row_nr - 1, 1, item_2)
self.info_table.setRowHeight(row_nr - 1, 20)
def _show_node_information(self, node):
# hide all rows
for r in range(self.info_table.rowCount()):
self.info_table.setRowHidden(r, True)
# add new information save dict[ecu_id][settings_id] = row_nr
comp_id = node.settings_dict['comp_id']
self.selection_label.setText("Selected ECU: %s" % comp_id)
for set_key in node.settings_dict.keys():
# if already exists -> show its row and skip
try:
row_nr = self._show_dict[comp_id][set_key]
self.info_table.setRowHidden(row_nr, False)
continue
except:
pass
# else add it to table and show row
self.info_table.setRowCount(self.info_table.rowCount() + 1)
row_nr = self.info_table.rowCount()
item_1 = QTableWidgetItem()
item_1.setData(QtCore.Qt.EditRole, set_key)
item_2 = QTableWidgetItem()
item_2.setText(str(node.settings_dict[set_key]))
General().add_to_three_dict(self._show_dict, comp_id, set_key,
row_nr)
self.info_table.setItem(row_nr - 1, 0, item_1)
self.info_table.setItem(row_nr - 1, 1, item_2)
self.info_table.setRowHeight(row_nr - 1, 20)
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: QVariant
"""
myRow = table.rowCount()
table.insertRow(table.rowCount())
myItem = 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.
myVariant = QVariant((data, ))
# To retrieve it again you would need to do:
#myValue = myVariant.toPyObject()[0]
myItem.setData(Qt.UserRole, myVariant)
table.setItem(myRow, 0, myItem)
table.setItem(myRow, 1, QTableWidgetItem(''))
def refreshPlotTable(self):
'''
Refresh the table of plots
'''
table = self.dlg.plotTable
# empty previous content
for row in range(table.rowCount()):
table.removeRow(row)
table.setRowCount(0)
# Add lines
for pid, p in self.dataPlotTraces.items():
# Set row and column count
twRowCount = table.rowCount()
# add a new line
table.setRowCount(twRowCount + 1)
# Id
newItem = QTableWidgetItem()
newItem.setData(Qt.EditRole, pid)
table.setItem(twRowCount, 0, newItem)
# Type
newItem = QTableWidgetItem()
newItem.setData(Qt.EditRole, p.plot_type)
table.setItem(twRowCount, 1, newItem)
def set_inspection(self, projectId, sectionId, inspectionId):
self.clearContents()
self.projectId = projectId
self.sectionId = sectionId
self.inspectionId = inspectionId
for r in range(self.rowCount() - 1, -1, -1):
self.removeRow(r)
if self.projectId is None or self.sectionId is None or self.inspectionId is None:
return
for o_id, obs in self.data[self.projectId]['Sections'][self.sectionId]['Inspections'][self.inspectionId]['Observations'].iteritems():
r = self.rowCount()
self.insertRow(r)
for c, col in enumerate(ColumnData):
item = QTableWidgetItem(u'{}'.format(obs[col] if c < 6 else ''))
if c in (0,6):
data_column = 'Import' if c == 0 else 'ForceImport'
item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable | Qt.ItemIsUserCheckable)
item.setCheckState(Qt.Checked if obs[data_column] else Qt.Unchecked)
item.setData(Qt.UserRole, o_id)
item.setData(Qt.UserRole+1, data_column)
else:
item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable)
font = item.font()
font.setPointSize(font.pointSize() - 2)
item.setFont(font)
self.setItem(r, c, item)
self.resizeColumnsToContents()
def load_items(self):
"""
Load items from the indexed_items list and add them in the
self.indexedItems QTableWidget.
"""
count = 0
# get the list of already indexed stuff and add them in the qtablewidget
# with a not-editable check box indicating if it has been indexed
# recursively or not
for i in self.indexed_items:
node = VFS.Get().getNodeFromPointer(long(i))
if node == None:
continue
recurse = self.indexed_items[i]
new_item = QTableWidgetItem(QIcon(":/folder.png"), node.name())
self.indexedItems.setRowCount(count + 1)
new_item.setData(Qt.UserRole + 1, QVariant(long(node.this)))
self.indexedItems.setItem(count, 0, new_item)
new_item2 = QTableWidgetItem()
new_item2.setFlags(Qt.ItemIsUserCheckable)
if recurse:
new_item2.setCheckState(Qt.Checked)
else:
new_item2.setCheckState(Qt.Unchecked)
self.indexedItems.setItem(count, 1, new_item2)
count += 1
return count
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: QVariant
"""
myRow = table.rowCount()
table.insertRow(table.rowCount())
myItem = 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.
myVariant = QVariant((data,))
# To retrieve it again you would need to do:
#myValue = myVariant.toPyObject()[0]
myItem.setData(Qt.UserRole, myVariant)
table.setItem(myRow, 0, myItem)
table.setItem(myRow, 1, QTableWidgetItem(''))
def refreshPlotTable(self):
'''
Refresh the table of plots
'''
table = self.dlg.plotTable
# empty previous content
for row in range(table.rowCount()):
table.removeRow(row)
table.setRowCount(0)
# Add lines
for pid, p in self.dataPlotTraces.items():
# Set row and column count
twRowCount = table.rowCount()
# add a new line
table.setRowCount( twRowCount + 1 )
# Id
newItem = QTableWidgetItem()
newItem.setData( Qt.EditRole, pid )
table.setItem(twRowCount, 0, newItem)
# Type
newItem = QTableWidgetItem()
newItem.setData( Qt.EditRole, p.plot_type )
table.setItem(twRowCount, 1, newItem)
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)
# noinspection PyUnresolvedReferences
table.setItem(count, 0, items)
# noinspection PyUnresolvedReferences
table.setItem(count, 1, QTableWidgetItem(''))
def populateVars(self, selectedVar=None):
selected = None
self.ui.varTableWidget.clear()
self.ui.varTableWidget.setSortingEnabled(False)
self.ui.varTableWidget.setRowCount(len(self.__vars))
headers = ["Name", "Value", "Info"]
self.ui.varTableWidget.setColumnCount(len(headers))
self.ui.varTableWidget.setHorizontalHeaderLabels(headers)
for row, name in enumerate(sorted(self.__vars.keys())):
item = QTableWidgetItem(name)
item.setData(Qt.UserRole, QVariant(name))
flags = item.flags()
flags ^= Qt.ItemIsEditable
item.setFlags(flags)
self.ui.varTableWidget.setItem(row, 0, item)
item2 = QTableWidgetItem(self.__vars[name] or "")
self.ui.varTableWidget.setItem(row, 1, item2)
item3 = QTableWidgetItem(self.__pardesc[name]['doc'] or "")
flags = item3.flags()
flags &= ~Qt.ItemIsEnabled
item3.setFlags(flags)
self.ui.varTableWidget.setItem(row, 2, item3)
if selectedVar is not None and selectedVar == name:
selected = item2
self.ui.varTableWidget.setSortingEnabled(True)
self.ui.varTableWidget.resizeColumnsToContents()
self.ui.varTableWidget.horizontalHeader()\
.setStretchLastSection(True)
if selected is not None:
selected.setSelected(True)
self.ui.varTableWidget.setCurrentItem(selected)
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)
# noinspection PyUnresolvedReferences
table.setItem(count, 0, items)
# noinspection PyUnresolvedReferences
table.setItem(count, 1, QTableWidgetItem(''))
def change_all_rows(new_rows):
for i in xrange(table_widget.rowCount(), -1, -1):
table_widget.removeRow(i)
for i, value in enumerate(new_rows):
item = QTableWidgetItem()
item.setData(Qt.EditRole, value)
table_widget.insertRow(i)
table_widget.setItem(i, 0, item)
def onAddVariableClicked(self):
'''
Add a variable to the list from the text input
when the user clicks on the corresponding button
'''
if not self.initDone:
return
# Get table and row count
tw = self.dlg.twVariableList
twRowCount = tw.rowCount()
# Get input data
vname = unicode(self.dlg.inVariableName.text()).strip(' \t')
vvalue = unicode(self.dlg.inVariableValue.text()).strip(' \t')
# Check if the variable if not already in the list
if vname in self.variableList:
self.updateLog( self.tr(u'This variable is already in the list') )
return
# Add constraint of possible input values
p = re.compile('^[a-zA-Z]+$')
if not p.match( vname ):
self.updateLog( self.tr(u'The variable must contain only lower case ascii letters !') )
return
# Set table properties
tw.setRowCount(twRowCount + 1)
tw.setColumnCount( 2 )
# Empty the name text input
self.dlg.inVariableName.setText(u'')
# Add the new "variable" item to the table
# name
newItem = QTableWidgetItem()
newItem.setFlags( Qt.ItemIsSelectable | Qt.ItemIsEnabled )
newItem.setData( Qt.EditRole, vname )
tw.setItem(twRowCount, 0, newItem)
# value
newItem = QTableWidgetItem()
newItem.setFlags( Qt.ItemIsSelectable | Qt.ItemIsEditable | Qt.ItemIsEnabled )
newItem.setData( Qt.EditRole, vvalue )
tw.setItem(twRowCount, 1, newItem)
# Add variable to the list
self.variableList.append( vname )
# Add variable to the project
p = QgsProject.instance()
p.writeEntry( 'PluginDynamicLayers', 'VariableList', self.variableList )
p.setDirty( True )
def __init__(self, parent=None):
QWidget.__init__(self, parent)
self.widget_layout = QVBoxLayout()
self.table_widget = QTableWidget(106, 1)
self.table_widget.setSortingEnabled(True)
self.widget_layout.addWidget(self.table_widget)
self.setLayout(self.widget_layout)
for num in range(101):
item = QTableWidgetItem()
item.setData(Qt.EditRole, num)
self.table_widget.setItem(num, 0, item)
def table_test():
"""
Messing around with QTableWidgets
This successfully creates a table of DateTimes and allows you to edit them.
"""
from PyQt4.QtGui import QTableWidget, QTableWidgetItem, QItemEditorCreatorBase, QDateTimeEdit, QItemEditorFactory, QStyledItemDelegate
from PyQt4.QtCore import QVariant, QDateTime, QObject
class DateTimeEditorCreator(QItemEditorCreatorBase):
"""
See gui/itemviews/qitemeditorfactory.cpp for implementations of
createEditor() and valuePropertyName()
"""
def __init__(self):
QItemEditorCreatorBase.__init__(self)
def createWidget(self, parent):
wid = QDateTimeEdit(parent)
wid.setCalendarPopup(True)
wid.setFrame(False)
return wid
def valuePropertyName(self):
return "dateTime"
def die():
raise MyError("Oops")
class MyError(Exception):
def __init__(self, value):
self.value = value
def __str__(self):
return repr(self.value)
tableWidget = QTableWidget(12, 3)
tableWidget.setItemDelegate(QStyledItemDelegate())
tableWidget.itemDelegate().setItemEditorFactory(QItemEditorFactory())
tableWidget.itemDelegate().itemEditorFactory().registerEditor(QVariant.DateTime, DateTimeEditorCreator())
for row in range(10):
for col in range(3):
date = QDateTime.currentDateTime()
string = str(row) + ',' + str(col)
item = QTableWidgetItem()
item.setData(Qt.DisplayRole, QVariant(date))
tableWidget.setItem(row, col, item)
tableWidget.show()
sys.exit(app.exec_())
def runFinishedFromThread(self, success):
self.testThread.stop()
QApplication.restoreOverrideCursor()
self.buttonOk.setEnabled(True)
if success == "writeShape":
extra = ""
if self.addToCanvasCheck.isChecked():
addCanvasCheck = ftools_utils.addShapeToCanvas(
unicode(self.shapefileName))
if not addCanvasCheck:
QMessageBox.warning(
self, self.tr("Geometry"),
self.tr("Error loading output shapefile:\n%s") %
(unicode(self.shapefileName)))
else:
QMessageBox.information(
self, self.tr("Geometry"),
self.tr("Created output shapefile:\n%s\n%s") %
(unicode(self.shapefileName), extra))
else:
self.tblUnique.setColumnCount(2)
count = 0
for rec in success:
if len(rec[1]) < 1:
continue
for err in rec[1]: # for each error we find
self.tblUnique.insertRow(count)
fidItem = QTableWidgetItem(unicode(rec[0]))
self.tblUnique.setItem(count, 0, fidItem)
message = err.what()
errItem = QTableWidgetItem(message)
if err.hasWhere(
): # if there is a location associated with the error
errItem.setData(Qt.UserRole, err.where())
self.tblUnique.setItem(count, 1, errItem)
count += 1
self.tblUnique.setHorizontalHeaderLabels(
[self.tr("Feature"), self.tr("Error(s)")])
self.tblUnique.horizontalHeader().setResizeMode(
0, QHeaderView.ResizeToContents)
self.tblUnique.horizontalHeader().show()
self.tblUnique.horizontalHeader().setResizeMode(
1, QHeaderView.Stretch)
self.tblUnique.resizeRowsToContents()
self.lstCount.insert(unicode(count))
self.cancel_close.setText("Close")
QObject.disconnect(self.cancel_close, SIGNAL("clicked()"),
self.cancelThread)
return True
def place_entries(self, entries):
table = self.ui.table
j = -1
for h in entries:
j += 1
if not '_details' in h:
h['_details'] = json.loads(h['details']) if h['details'] else {
"short": h['description'],
"plus": "",
"minus": "",
"icon": None
}
# TODO: remove this block
if not ('icon' in h['_details']): #
h['_details']['icon'] = None #
if not ('_icon' in h):
h['_icon'] = ":/op/images/op/" + h['_details'][
'icon'] + ".png" if h['_details']['icon'] else None
description = h["_details"]["short"] or h['description']
table.insertRow(j)
item = QTableWidgetItem(str(h["date"]))
item.setData(99, h)
table.setItem(j, 0, item)
icon = qicon(h["_icon"])
item.setIcon(icon)
set_col(table, j, 1, description)
set_col(table,
j,
2,
h["_details"]["plus"],
color=COLOR_GREEN,
align="right")
set_col(table,
j,
3,
h["_details"]["minus"],
color=COLOR_RED,
align="right")
if h["memo"] > 0:
icon = qicon(":/icons/images/memo.png")
table.item(j, 1).setIcon(icon)
def load_table(table, headers, data, checkFirstColumn=True):
table.setHorizontalHeaderLabels(headers)
table.horizontalHeader().setStretchLastSection(True)
table.setSelectionBehavior(QAbstractItemView.SelectRows)
for i in xrange(table.rowCount()):
table.removeRow(0)
for r, row in enumerate(data):
table.insertRow(r)
for index, colItem in enumerate(row):
item = QTableWidgetItem(colItem)
table.setItem(r, index, item)
if index == 0 and checkFirstColumn:
item.setData(Qt.UserRole, row)
item.setCheckState(Qt.Unchecked)
item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled | Qt.ItemIsUserCheckable)
else:
item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
def load_datatools_csv(table, headers, data):
columns = len(headers)
table.setColumnCount(columns)
remove_rows(table)
for rw in range(len(data[0])):
table.insertRow(rw)
for c in range(len(data)):
item = QTableWidgetItem(str(data[c][rw]))
table.setItem(rw, c, item)
item.setData(Qt.UserRole, rw)
item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
# table options
load_table_options(table, headers)
# auto fit
auto_fit_table(table)
def load_datatools(table, headers, data):
_columns = len(headers)
table.setColumnCount(_columns)
remove_rows(table)
for rw, row in enumerate(data):
table.insertRow(rw)
for index, colItem in enumerate(row):
item = QTableWidgetItem(str(colItem))
table.setItem(rw, index, item)
item.setData(Qt.UserRole, row)
item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
# table options
load_table_options(table, headers)
# auto fit
auto_fit_table(table)
def load_table(table, headers, data, checkFirstColumn=True):
table.setHorizontalHeaderLabels(headers)
table.horizontalHeader().setStretchLastSection(True)
table.setSelectionBehavior(QAbstractItemView.SelectRows)
for i in range(table.rowCount()):
table.removeRow(0)
for r, row in enumerate(data):
table.insertRow(r)
for index, colItem in enumerate(row):
item = QTableWidgetItem(colItem)
table.setItem(r, index, item)
if index == 0 and checkFirstColumn:
item.setData(Qt.UserRole, row)
item.setCheckState(Qt.Unchecked)
item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled
| Qt.ItemIsUserCheckable)
else:
item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
def populateLayersTable(self, foo=None, foo2=None, foo3=None):
""" List vector layers that support changes in attributes and are writable.
Arguments are 3 and optional because this function listens to several
SIGNALs.
"""
# Initialize Layers Table
self.tblLayers.clearContents()
self.tblLayers.setRowCount(0)
vLayers = []
for layer in QgsMapLayerRegistry.instance().mapLayers().values():
if layer.type() == QgsMapLayer.VectorLayer:
if layer.dataProvider().capabilities(
) & QgsVectorDataProvider.ChangeAttributeValues:
if not layer.isReadOnly():
if layer.geometryType(
) < 3: # Avoid UnknownGeometry and NoGeometry
vLayers.append(layer)
self.tblLayers.setRowCount(len(vLayers))
self.tblLayers.setColumnCount(3)
self.tblLayers.setSortingEnabled(False)
for row, lyr in enumerate(vLayers):
item = QTableWidgetItem( QIcon( ":/plugins/AutoFields/icons/" + \
self.geometryDict[lyr.geometryType()] + ".png"),
str( lyr.geometryType() ) )
self.tblLayers.setItem(row, 0, item)
item = QTableWidgetItem(lyr.name())
item.setData(Qt.UserRole, lyr.id())
self.tblLayers.setItem(row, 1, item)
tmpTreeLayer = self.root.findLayer(lyr.id())
if tmpTreeLayer:
group = tmpTreeLayer.parent().name()
self.tblLayers.setItem(
row, 2,
QTableWidgetItem(
group if group else QApplication.
translate("AutoFieldsDockWidgetPy", "< root >")))
self.tblLayers.setSortingEnabled(True)
def addCorrector(self, idx):
if not self._corlst1.selectedItems(): return
#print self._corlst1.itemFromIndex(idx).text(0)
nrow = self.table4.rowCount()
if nrow >= self._nmax:
QtGui.QMessageBox.critical(
self, "Local Orbit Bump",
"ERROR: We need only {0} correctors.".format(self._nmax),
QtGui.QMessageBox.Ok)
#self.progress.setValue(0)
return
self.table4.setRowCount(nrow+1)
it0 = self._corlst1.selectedItems()[-1]
icor, ok = it0.data(0, Qt.UserRole).toInt()
if icor < 0: return
newc = self._cors[icor]
for j in range(self.table4.columnCount()):
it = QTableWidgetItem()
if j > 0: it.setTextAlignment(
Qt.AlignRight | Qt.AlignVCenter)
header = self.table4.horizontalHeaderItem(j)
if header.text() != "dBump":
it.setFlags(it.flags() & (~Qt.ItemIsEditable))
else:
it.setData(Qt.DisplayRole, "0")
it.setData(Qt.UserRole, 0.0)
self.table4.setItem(nrow, j, it)
self.table4.item(nrow,0).setData(Qt.UserRole, icor)
for j,h in [(0, "Element"), (1, "s [m]")]:
self.table4.item(nrow,j).setData(Qt.DisplayRole,
it0.text(self._header[h]))
for j in range(self._corlst1.columnCount()):
it0.setForeground(j, Qt.red)
it0.setDisabled(True)
self.emit(SIGNAL("correctorAdded(PyQt_PyObject)"), newc)
# use initial values
self.updateTwiss()
self.updateCorReadings()
self.table4.resizeColumnsToContents()
if self.table4.rowCount() == self._nmax:
#print "All correctors are ready"
self.emit(SIGNAL("correctorsComplete()"))
def addCorrector(self, idx):
if not self._corlst1.selectedItems(): return
#print self._corlst1.itemFromIndex(idx).text(0)
nrow = self.table4.rowCount()
if nrow >= self._nmax:
QtGui.QMessageBox.critical(
self, "Local Orbit Bump",
"ERROR: We need only {0} correctors.".format(self._nmax),
QtGui.QMessageBox.Ok)
#self.progress.setValue(0)
return
self.table4.setRowCount(nrow+1)
it0 = self._corlst1.selectedItems()[-1]
icor, ok = it0.data(0, Qt.UserRole).toInt()
if icor < 0: return
newc = self._cors[icor]
for j in range(self.table4.columnCount()):
it = QTableWidgetItem()
if j > 0: it.setTextAlignment(
Qt.AlignRight | Qt.AlignVCenter)
header = self.table4.horizontalHeaderItem(j)
if header.text() != "dBump":
it.setFlags(it.flags() & (~Qt.ItemIsEditable))
else:
it.setData(Qt.DisplayRole, "0")
it.setData(Qt.UserRole, 0.0)
self.table4.setItem(nrow, j, it)
self.table4.item(nrow,0).setData(Qt.UserRole, icor)
for j,h in [(0, "Element"), (1, "s [m]")]:
self.table4.item(nrow,j).setData(Qt.DisplayRole,
it0.text(self._header[h]))
for j in range(self._corlst1.columnCount()):
it0.setForeground(j, Qt.red)
it0.setDisabled(True)
self.emit(SIGNAL("correctorAdded(PyQt_PyObject)"), newc)
# use initial values
self.updateTwiss()
self.updateCorReadings()
self.table4.resizeColumnsToContents()
if self.table4.rowCount() == self._nmax:
#print "All correctors are ready"
self.emit(SIGNAL("correctorsComplete()"))
def addAutoFieldToAutoFieldsTable( self, autoFieldId, autoField ):
""" Add a whole row to the AutoFields table """
row = self.tblAutoFields.rowCount()
self.tblAutoFields.insertRow( row )
name = autoField['layer']
if 'layerId' in autoField:
lyr = QgsMapLayerRegistry.instance().mapLayer( autoField['layerId'] )
name = lyr.name()
item = QTableWidgetItem( name )
item.setData( Qt.UserRole, autoFieldId )
item.setData( Qt.ToolTipRole, autoField['layer'] )
self.tblAutoFields.setItem( row, 0, item )
item = QTableWidgetItem( autoField['field'] )
self.tblAutoFields.setItem( row, 1, item )
item = QTableWidgetItem( autoField['expression'] )
self.tblAutoFields.setItem( row, 2, item )
item = QTableWidgetItem( QApplication.translate( "ExportAutoFields",
"Enabled" ) if autoField['enabled'] else QApplication.translate( "ExportAutoFields", "Disabled" ) )
self.tblAutoFields.setItem( row, 3, item )
def set_col(table, row, col, val, fmt=None, color=None, align=None, editable=None, data=None): item = QTableWidgetItem(fmt % val if fmt else str(val)) if color: item.setForeground(QtGui.QColor(color)) if align=="right": item.setTextAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter) if align=="center": item.setTextAlignment(QtCore.Qt.AlignHCenter | QtCore.Qt.AlignVCenter) if not(editable is None): if editable: item.setFlags(QtCore.Qt.ItemIsEnabled | QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEditable) else: item.setFlags(QtCore.Qt.ItemIsEnabled | QtCore.Qt.ItemIsSelectable) if data: item.setData(99, data) table.setItem(row, col, item) return item
def populateCheckboxTable(self):
''' populate QTableWidget manually with log names and checkboxes
simpler than using a QTableView and a dedicated model such as
tableModel = LogLayoutTableModel(self, logList = self._logs, logHeaders = headers)
self.tableView.setModel(tableModel)
'''
logger.debug(">>populateCheckboxTable()")
selected = None
initialTracks = len(self._logs)
if len(self._initialPlotList) > initialTracks:
initialTracks = len(self._initialPlotList)
#add an extra log name column and a blank end column
totalNumColumns = initialTracks + 2
logger.debug("--populateCheckboxTable() totalNumColumns:{0}".format(
totalNumColumns))
if (self._logs != None) and (len(self._logs) > 0):
self.headers = self.getLayoutTableHeaders(initialTracks + 1)
self.chkboxTableWidget.clear()
self.chkboxTableWidget.setSortingEnabled(False)
self.chkboxTableWidget.setRowCount(len(self._logs))
self.chkboxTableWidget.setColumnCount(len(self.headers))
self.chkboxTableWidget.setHorizontalHeaderLabels(self.headers)
for row, log in enumerate(self._logs):
item = QTableWidgetItem(log.name)
#looks like can set an object as data
item.setData(Qt.UserRole, log)
self.chkboxTableWidget.setItem(row, 0, item)
for i in range(1, totalNumColumns):
chkBoxItem = self._layoutHandler.createChkBoxItem(log)
self.chkboxTableWidget.setItem(row, i, chkBoxItem)
self.chkboxTableWidget.resizeColumnsToContents()
self._layoutHandler.tickDisplayedLogs()
self.chkboxTableWidget.itemChanged.connect(self.changeLogTrack)
else:
logger.debug(
"--populateCheckboxTable() _logs==None: {0}, _logs length: {1}"
.format((self._logs == None), (len(self._logs))))
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 populateTableWidget(self, selectedLog=None):
logger.debug(">>populateTableWidget()")
selected = None
self.logsTableWidget.clear()
self.logsTableWidget.setSortingEnabled(False)
self.logsTableWidget.setRowCount(len(self._logTableModel.logs))
self.logsTableWidget.setColumnCount(len(self._logTableModel.HEADERS))
self.logsTableWidget.setHorizontalHeaderLabels(
self._logTableModel.HEADERS)
for row, log in enumerate(self._logTableModel.logs):
item = QTableWidgetItem(log.name)
item.setData(Qt.UserRole, str(id(log)))
localLogType = LogType.findLogTypeFromMnemonic(log.fileMnemonic)
if selectedLog is not None and selectedLog == id(log):
selected = item
chkBoxItem = QtGui.QTableWidgetItem()
chkBoxItem.setFlags(QtCore.Qt.ItemIsUserCheckable
| QtCore.Qt.ItemIsEnabled)
chkBoxItem.setCheckState(QtCore.Qt.Unchecked)
#is this needed?
chkBoxItem.setData(Qt.UserRole, str(id(log)))
self.logsTableWidget.setItem(row, logtablemodel.IMPORT, chkBoxItem)
self.logsTableWidget.setItem(row, logtablemodel.NAME, item)
self.logsTableWidget.setCellWidget(
row, logtablemodel.TYPE,
self.getPreparedTypesCombo(log.fileMnemonic))
self.logsTableWidget.setCellWidget(
row, logtablemodel.UNIT,
self.populateUnitsCombo(localLogType, log.fileUnit))
self.logsTableWidget.setItem(row, logtablemodel.FILE_MNEMONIC,
QTableWidgetItem(log.fileMnemonic))
self.logsTableWidget.setItem(row, logtablemodel.FILE_UNIT,
QTableWidgetItem(log.fileUnit))
self.logsTableWidget.setItem(row, logtablemodel.FILE_DESCRIPTION,
QTableWidgetItem(log.fileDescription))
self.logsTableWidget.setSortingEnabled(True)
self.logsTableWidget.resizeColumnsToContents()
if selected is not None:
selected.setSelected(True)
self.logsTableWidget.setCurrentItem(selected)
def displayColumns(self):
self.clear()
for c in range(self.columnCount() - 1, -1, -1):
self.removeColumn(c)
for r in range(self.rowCount() - 1, -1, -1):
self.removeRow(r)
columns = self.settings.value("columns")
c = 0
for i, col in enumerate(columnVarSetting):
if col in columns:
if columnRowName[i] == "changedGeometryStr" and not self.geomColumn:
continue
self.insertColumn(c)
item = QTableWidgetItem(columnFancyName[i])
item.setData(Qt.UserRole, columnRowName[i])
font = item.font()
font.setPointSize(font.pointSize() - 2)
item.setFont(font)
self.setHorizontalHeaderItem(c, item)
c += 1
self.horizontalHeader().setMinimumSectionSize(15)
def addAutoFieldToAutoFieldsTable(self, autoFieldId, autoField):
""" Add a whole row to the AutoFields table """
row = self.tblAutoFields.rowCount()
self.tblAutoFields.insertRow(row)
name = autoField['layer']
if 'layerId' in autoField:
lyr = QgsMapLayerRegistry.instance().mapLayer(autoField['layerId'])
name = lyr.name()
item = QTableWidgetItem(name)
item.setData(Qt.UserRole, autoFieldId)
item.setData(Qt.ToolTipRole, autoField['layer'])
self.tblAutoFields.setItem(row, 0, item)
item = QTableWidgetItem(autoField['field'])
self.tblAutoFields.setItem(row, 1, item)
item = QTableWidgetItem(autoField['expression'])
self.tblAutoFields.setItem(row, 2, item)
item = QTableWidgetItem(
QApplication.translate("ExportAutoFields", "Enabled"
) if autoField['enabled'] else QApplication.
translate("ExportAutoFields", "Disabled"))
self.tblAutoFields.setItem(row, 3, item)
def _reloadAnnotationTable(self):
self.annotationTableWidget.clear()
self.annotationTableWidget.setRowCount(len(self._annotations))
self._initAnnotationTableHeader()
# Flip the key/value of the annotation list so we can sort them by label
annotations = self._annotations.items()
annotations = map(
lambda (coord3d, (label, comment)): (label, coord3d, comment),
annotations)
annotations = sorted(annotations)
for row, (ravelerLabel, coord3d, comment) in enumerate(annotations):
coordItem = QTableWidgetItem("{}".format(coord3d))
labelItem = QTableWidgetItem("{}".format(ravelerLabel))
commentItem = QTableWidgetItem(comment)
coordItem.setData(Qt.UserRole, (coord3d, ravelerLabel))
labelItem.setData(Qt.UserRole, (coord3d, ravelerLabel))
commentItem.setData(Qt.UserRole, (coord3d, ravelerLabel))
self.annotationTableWidget.setItem(
row, AnnotationTableColumns.Coordinates, coordItem)
self.annotationTableWidget.setItem(row,
AnnotationTableColumns.Body,
labelItem)
self.annotationTableWidget.setItem(row,
AnnotationTableColumns.Comment,
commentItem)
def populateLayersTable( self, foo=None, foo2=None, foo3=None ):
""" List vector layers that support changes in attributes and are writable.
Arguments are 3 and optional because this function listens to several
SIGNALs.
"""
# Initialize Layers Table
self.tblLayers.clearContents()
self.tblLayers.setRowCount( 0 )
vLayers = []
for layer in QgsMapLayerRegistry.instance().mapLayers().values():
if layer.type() == QgsMapLayer.VectorLayer:
if layer.dataProvider().capabilities() & QgsVectorDataProvider.ChangeAttributeValues:
if not layer.isReadOnly():
if layer.geometryType() < 3: # Avoid UnknownGeometry and NoGeometry
vLayers.append( layer )
self.tblLayers.setRowCount( len( vLayers ) )
self.tblLayers.setColumnCount( 3 )
self.tblLayers.setSortingEnabled( False )
for row, lyr in enumerate( vLayers ):
item = QTableWidgetItem( QIcon( ":/plugins/AutoFields/icons/" + \
self.geometryDict[lyr.geometryType()] + ".png"),
str( lyr.geometryType() ) )
self.tblLayers.setItem( row, 0, item )
item = QTableWidgetItem( lyr.name() )
item.setData( Qt.UserRole, lyr.id() )
self.tblLayers.setItem( row, 1, item )
tmpTreeLayer = self.root.findLayer( lyr.id() )
if tmpTreeLayer:
group = tmpTreeLayer.parent().name()
self.tblLayers.setItem(row, 2,
QTableWidgetItem( group if group else QApplication.translate("AutoFieldsDockWidgetPy",
"< root >" ) ) )
self.tblLayers.setSortingEnabled( True )
def appendRow(theTable, theLabel, theData):
""" Append new row to table widget.
:param theTable: a QTable instance
:param theLabel: label for the row
:param theData: custom data associated with theLabel value.
"""
myRow = theTable.rowCount()
theTable.insertRow(theTable.rowCount())
myItem = QTableWidgetItem(theLabel)
# 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.
myVariant = QVariant((theData,))
# To retrieve it again you would need to do:
#myValue = myVariant.toPyObject()[0]
myItem.setData(Qt.UserRole, myVariant)
theTable.setItem(myRow, 0, myItem)
theTable.setItem(myRow, 1, QTableWidgetItem(''))
def addNodeInIndexList(self, index):
"""
Add the node wich pointer is index.data(QT.UserRole + 1) in the
indexedItems list.
"""
# get the node from the index
node_ptr = self.selectIndexItems.model().data(index, Qt.UserRole + 1)
if not node_ptr.isValid():
return
added_node = VFS.Get().getNodeFromPointer(node_ptr.toULongLong()[0])
# add the node.this into the selected items list
new_item = QTableWidgetItem(QIcon(":/folder.png"), added_node.name())
new_item.setData(Qt.UserRole + 1, QVariant(long(added_node.this)))
self.tmp_indexed_items[long(added_node.this)] = False
new_checkbox = QTableWidgetItem(1);
new_checkbox.data(Qt.CheckStateRole);
new_checkbox.setCheckState(Qt.Unchecked);
self.indexedItems.insertRow(0)
self.indexedItems.setItem(0, 0, new_item)
self.indexedItems.setItem(0, 1, new_checkbox)
def populateAttributes(self, selectedAttribute=None):
selected = None
self.ui.attributeTableWidget.clear()
self.ui.attributeTableWidget.setSortingEnabled(False)
self.ui.attributeTableWidget.setRowCount(len(self.__attributes))
headers = ["Name", "Value"]
self.ui.attributeTableWidget.setColumnCount(len(headers))
self.ui.attributeTableWidget.setHorizontalHeaderLabels(headers)
for row, name in enumerate(self.__attributes):
item = QTableWidgetItem(name)
item.setData(Qt.UserRole, QVariant(name))
self.ui.attributeTableWidget.setItem(row, 0, item)
item2 = QTableWidgetItem(self.__attributes[name])
self.ui.attributeTableWidget.setItem(row, 1, item2)
if selectedAttribute is not None and selectedAttribute == name:
selected = item2
self.ui.attributeTableWidget.setSortingEnabled(True)
self.ui.attributeTableWidget.resizeColumnsToContents()
self.ui.attributeTableWidget.horizontalHeader().\
setStretchLastSection(True)
if selected is not None:
selected.setSelected(True)
self.ui.attributeTableWidget.setCurrentItem(selected)
def addAutoFieldToAutoFieldsTable( self, autoField, candidateLayer ):
""" Add a whole row to the AutoFields table """
row = self.tblAutoFields.rowCount()
self.tblAutoFields.insertRow( row )
layerName = self.ogrLayerName( autoField['layer'] )
item = QTableWidgetItem( layerName if layerName else autoField['layer'] )
item.setData( Qt.UserRole, autoField['layer'] )
item.setData( Qt.ToolTipRole, autoField['layer'] )
self.tblAutoFields.setItem( row, 0, item )
item = QTableWidgetItem( autoField['field'] )
self.tblAutoFields.setItem( row, 1, item )
item = QTableWidgetItem( autoField['expression'] )
self.tblAutoFields.setItem( row, 2, item )
layerCombo = QComboBox()
layerCombo.addItem( '[Select a layer]', None )
for layer in self.layers:
layerCombo.addItem( layer.name(), layer.id() )
if candidateLayer:
layerCombo.setCurrentIndex( layerCombo.findData( candidateLayer.id() ) )
layerCombo.currentIndexChanged.connect( partial( self.layerOrFieldCombosChanged, row ) )
self.tblAutoFields.setCellWidget( row, 4, layerCombo )
fieldCombo = QComboBox()
fieldCombo.addItem( '[Select a field]', None )
if layerCombo.currentIndex() != 0:
for field in candidateLayer.fields():
fieldCombo.addItem( field.name() )
fieldIndex = fieldCombo.findText( autoField['field'] )
fieldCombo.setCurrentIndex( fieldIndex if fieldIndex != -1 else 0 )
fieldCombo.currentIndexChanged.connect( partial( self.layerOrFieldCombosChanged, None ) )
self.tblAutoFields.setCellWidget( row, 5, fieldCombo )
label = self.getLabelWithArrow( layerCombo.currentIndex(), fieldCombo.currentIndex(), candidateLayer, autoField['field'] )
self.tblAutoFields.setCellWidget( row, 3, label )
self.layerOrFieldCombosChanged( None, None ) # Validate initial load of AutoFields/Layers
def runFinishedFromThread(self, success):
self.testThread.stop()
QApplication.restoreOverrideCursor()
self.buttonOk.setEnabled(True)
if success == "writeShape":
extra = ""
if self.addToCanvasCheck.isChecked():
addCanvasCheck = ftools_utils.addShapeToCanvas(unicode(self.shapefileName))
if not addCanvasCheck:
QMessageBox.warning(self, self.tr("Geometry"), self.tr("Error loading output shapefile:\n%s") % (unicode(self.shapefileName)))
else:
QMessageBox.information(self, self.tr("Geometry"), self.tr("Created output shapefile:\n%s\n%s") % (unicode(self.shapefileName), extra))
else:
self.tblUnique.setColumnCount(2)
count = 0
for rec in success:
if len(rec[1]) < 1:
continue
for err in rec[1]: # for each error we find
self.tblUnique.insertRow(count)
fidItem = QTableWidgetItem(unicode(rec[0]))
self.tblUnique.setItem(count, 0, fidItem)
message = err.what()
errItem = QTableWidgetItem(message)
if err.hasWhere(): # if there is a location associated with the error
errItem.setData(Qt.UserRole, err.where())
self.tblUnique.setItem(count, 1, errItem)
count += 1
self.tblUnique.setHorizontalHeaderLabels([self.tr("Feature"), self.tr("Error(s)")])
self.tblUnique.horizontalHeader().setResizeMode(0, QHeaderView.ResizeToContents)
self.tblUnique.horizontalHeader().show()
self.tblUnique.horizontalHeader().setResizeMode(1, QHeaderView.Stretch)
self.tblUnique.resizeRowsToContents()
self.lstCount.insert(unicode(count))
self.cancel_close.setText("Close")
QObject.disconnect(self.cancel_close, SIGNAL("clicked()"), self.cancelThread)
return True
def displayRows(self, observations):
self.clearContents()
for r in range(self.rowCount() - 1, -1, -1):
self.removeRow(r)
for r, obs in enumerate(observations):
# obs is a QgsFeature, translate it to a dict
dataDict = {"type": obs["type"], "x": obs["x"], "y": obs["y"],
"observation": obs["observation"], "precision": obs["precision"]}
self.insertRow(r)
# type
item = QTableWidgetItem(obs["type"])
item.setData(Qt.UserRole, dataDict)
item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsUserCheckable)
item.setCheckState(Qt.Checked)
self.setItem(r, 0, item)
# observation
item = QTableWidgetItem("%.4f" % obs["observation"])
item.setFlags(Qt.ItemIsEnabled)
self.setItem(r, 1, item)
# precision
item = QTableWidgetItem("%.4f" % obs["precision"])
item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsEditable)
self.setItem(r, 2, item)
self.adjustSize()
def addPlayer(self, player):
r = self.rowCount()
self.setRowCount(r + 1)
name = player.name
color = player.color
name = QTableWidgetItem(name)
name.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
colorItem = QTableWidgetItem()
colorItem.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
colorItem.setBackground(QColor(*color))
cards = QTableWidgetItem()
cards.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
cards.setTextAlignment(Qt.AlignCenter)
cards.setData(Qt.DisplayRole, 0)
troops = QTableWidgetItem()
troops.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
troops.setTextAlignment(Qt.AlignCenter)
troops.setData(Qt.DisplayRole, 0)
territories = QTableWidgetItem()
territories.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
territories.setTextAlignment(Qt.AlignCenter)
territories.setData(Qt.DisplayRole, 0)
troopsPerTurn = QTableWidgetItem()
troopsPerTurn.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
troopsPerTurn.setTextAlignment(Qt.AlignCenter)
troopsPerTurn.setData(Qt.DisplayRole, 0)
self.setItem(r, self.Name, name)
self.setItem(r, self.Color, colorItem)
self.setItem(r, self.Cards, cards)
self.setItem(r, self.NumberOfTroops, troops)
self.setItem(r, self.NumberOfTerritories, territories)
self.setItem(r, self.TroopsPerTurn, troopsPerTurn)
def addAutoFieldToAutoFieldsTable(self,
autoFieldId,
autoField,
freezeSorting=True):
""" Add a whole row to the AutoFields table """
if self.chkOnlyEnabledAutoFields.isChecked(
) and not autoField['enabled']:
return
if freezeSorting:
self.tblAutoFields.setSortingEnabled(False)
row = self.tblAutoFields.rowCount()
self.tblAutoFields.insertRow(row)
name = autoField['layer']
if 'layerId' in autoField:
lyr = QgsMapLayerRegistry.instance().mapLayer(autoField['layerId'])
name = lyr.name()
item = QTableWidgetItem(name)
item.setData(Qt.UserRole, autoFieldId)
item.setData(Qt.ToolTipRole, autoField['layer'])
if not autoField['enabled']:
item.setForeground(QBrush(Qt.gray))
self.tblAutoFields.setItem(row, 0, item)
item = QTableWidgetItem(autoField['field'])
if not autoField['enabled']:
item.setForeground(QBrush(Qt.gray))
self.tblAutoFields.setItem(row, 1, item)
item = QTableWidgetItem(autoField['expression'])
if not autoField['enabled']:
item.setForeground(QBrush(Qt.gray))
self.tblAutoFields.setItem(row, 2, item)
item = QTableWidgetItem(
QApplication.translate("AutoFieldsDockWidgetPy", "Enabled"
) if autoField['enabled'] else QApplication.
translate("AutoFieldsDockWidgetPy", "Disabled"))
item.setData(Qt.UserRole,
'enabled' if autoField['enabled'] else 'disabled')
if not autoField['enabled']:
item.setForeground(QBrush(Qt.gray))
self.tblAutoFields.setItem(row, 3, item)
if freezeSorting:
self.tblAutoFields.setSortingEnabled(True)
def _reloadAnnotationTable(self):
self.annotationTableWidget.clear()
self.annotationTableWidget.setRowCount( len(self._annotations) )
self._initAnnotationTableHeader()
# Flip the key/value of the annotation list so we can sort them by label
annotations = self._annotations.items()
annotations = map( lambda (coord3d, (label,comment)): (label, coord3d, comment), annotations )
annotations = sorted( annotations )
for row, (ravelerLabel, coord3d, comment) in enumerate( annotations ):
coordItem = QTableWidgetItem( "{}".format( coord3d ) )
labelItem = QTableWidgetItem( "{}".format( ravelerLabel ) )
commentItem = QTableWidgetItem( comment )
coordItem.setData( Qt.UserRole, ( coord3d, ravelerLabel ) )
labelItem.setData( Qt.UserRole, ( coord3d, ravelerLabel ) )
commentItem.setData( Qt.UserRole, ( coord3d, ravelerLabel ) )
self.annotationTableWidget.setItem( row, AnnotationTableColumns.Coordinates, coordItem )
self.annotationTableWidget.setItem( row, AnnotationTableColumns.Body, labelItem )
self.annotationTableWidget.setItem( row, AnnotationTableColumns.Comment, commentItem )
def addAutoFieldToAutoFieldsTable( self, autoFieldId, autoField, freezeSorting=True ):
""" Add a whole row to the AutoFields table """
if self.chkOnlyEnabledAutoFields.isChecked() and not autoField['enabled']:
return
if freezeSorting:
self.tblAutoFields.setSortingEnabled( False )
row = self.tblAutoFields.rowCount()
self.tblAutoFields.insertRow( row )
name = autoField['layer']
if 'layerId' in autoField:
lyr = QgsMapLayerRegistry.instance().mapLayer( autoField['layerId'] )
name = lyr.name()
item = QTableWidgetItem( name )
item.setData( Qt.UserRole, autoFieldId )
item.setData( Qt.ToolTipRole, autoField['layer'] )
if not autoField['enabled']:
item.setForeground( QBrush( Qt.gray ) )
self.tblAutoFields.setItem( row, 0, item )
item = QTableWidgetItem( autoField['field'] )
if not autoField['enabled']:
item.setForeground( QBrush( Qt.gray ) )
self.tblAutoFields.setItem( row, 1, item )
item = QTableWidgetItem( autoField['expression'] )
if not autoField['enabled']:
item.setForeground( QBrush( Qt.gray ) )
self.tblAutoFields.setItem( row, 2, item )
item = QTableWidgetItem( QApplication.translate( "AutoFieldsDockWidgetPy",
"Enabled" ) if autoField['enabled'] else QApplication.translate( "AutoFieldsDockWidgetPy", "Disabled" ) )
item.setData( Qt.UserRole, 'enabled' if autoField['enabled'] else 'disabled' )
if not autoField['enabled']:
item.setForeground( QBrush( Qt.gray ) )
self.tblAutoFields.setItem( row, 3, item )
if freezeSorting:
self.tblAutoFields.setSortingEnabled( True )
def addLayer(self, layer, headers, types, features):
tab = QtGui.QWidget()
tab.layer = layer
p1_vertical = QtGui.QVBoxLayout(tab)
p1_vertical.setContentsMargins(0,0,0,0)
table = QtGui.QTableWidget();
self.connect(table, SIGNAL("itemSelectionChanged()"), self.selectionChanged)
table.title = layer.name()
table.crs = layer.crs()
table.setColumnCount(len(headers))
if len(features) > 0:
table.setRowCount(len(features))
nbrow = len(features)
self.loadingWindow.show()
self.loadingWindow.setLabelText(table.title)
self.loadingWindow.activateWindow();
self.loadingWindow.showNormal();
# Table population
m = 0
for feature in features:
n = 0
for cell in feature.attributes():
item = QTableWidgetItem()
item.setData(Qt.DisplayRole, cell)
item.setFlags(item.flags() ^ Qt.ItemIsEditable)
item.feature = feature
table.setItem(m, n, item)
n += 1
m += 1
self.loadingWindow.setValue(int((float(m)/nbrow)*100))
QApplication.processEvents()
else:
table.setRowCount(0)
table.setHorizontalHeaderLabels(headers)
table.horizontalHeader().setMovable(True)
table.types = types
table.filter_op = []
table.filters = []
for i in range(0, len(headers)):
table.filters.append('')
table.filter_op.append(0)
header = table.horizontalHeader()
header.setContextMenuPolicy(Qt.CustomContextMenu)
header.customContextMenuRequested.connect(partial(self.filterMenu, table))
table.setSortingEnabled(True)
p1_vertical.addWidget(table)
# Status bar to display informations (ie: area)
tab.sb = QtGui.QStatusBar()
p1_vertical.addWidget(tab.sb)
title = table.title
# We reduce the title's length to 20 characters
if len(title)>20:
title = title[:20]+'...'
# We add the number of elements to the tab's title.
title += ' ('+str(len(features))+')'
self.tabWidget.addTab(tab, title) # Add the tab to the conatiner
self.tabWidget.setTabToolTip(self.tabWidget.indexOf(tab), table.title) # Display a tooltip with the layer's full name
def populateLayerTable( self ):
"""
Fill the table for a given layer type
"""
# Get parameters for the widget
lt = self.layersTable
table = lt['tableWidget']
attributes = lt['attributes']
headerData = [ a['key'] for a in attributes ]
# empty previous content
for row in range(table.rowCount()):
table.removeRow(row)
table.setRowCount(0)
# create columns and header row
columns = [ a['key'] for a in attributes ]
colCount = len( columns )
table.setColumnCount( colCount )
table.setHorizontalHeaderLabels( tuple( columns ) )
# load content from project layers
lr = QgsMapLayerRegistry.instance()
for lid in lr.mapLayers():
layer = lr.mapLayer( lid )
lineData = []
# Set row and column count
twRowCount = table.rowCount()
# add a new line
table.setRowCount( twRowCount + 1 )
table.setColumnCount( colCount )
i=0
if layer.customProperty('dynamicDatasourceActive') == 'True':
bg = QColor(175, 208, 126)
else:
bg = Qt.transparent
# get information
for attr in attributes:
newItem = QTableWidgetItem( )
# Is editable or not
if( attr['editable'] ):
newItem.setFlags( Qt.ItemIsSelectable | Qt.ItemIsEditable | Qt.ItemIsEnabled )
else:
newItem.setFlags( Qt.ItemIsSelectable | Qt.ItemIsEnabled )
# background
newItem.setBackground( bg )
# Item value
value = self.getLayerProperty( layer, attr['key'] )
newItem.setData( Qt.EditRole, value )
# Add cell data to lineData
# encode it in the file system encoding, only if needed
if hasattr( value, 'encode' ):
value = value.encode( sys.getfilesystemencoding() )
lineData.append( value )
# Add item
table.setItem(twRowCount, i, newItem)
i+=1
if (__name__ == '__main__'):
app = None
if (QApplication.instance() is None):
app = QApplication([])
widget = QTableWidget()
widget.setWindowFlags(Qt.Dialog)
widget.setSortingEnabled(True)
widget.setRowCount(50)
widget.setColumnCount(3)
for row in range(50):
# create a normal QTableWidgetItem
a = QTableWidgetItem()
a.setText(str(row))
widget.setItem(row, 0, a)
# create a proper sorted item
b = QTableWidgetItem()
b.setData(Qt.EditRole, QVariant(row))
widget.setItem(row, 1, b)
# create a custom sorted item
c = MyTableWidgetItem()
c.setData(Qt.EditRole, QVariant(row))
widget.setItem(row, 2, c)
widget.show()
if (app):
app.exec_()
def setData(self,role,value):
QTableWidgetItem.setData(role,value)
if(role == Qt.EditRole):
self.setDirty()
def addItem(r, c, text, tip = None):
item = QTableWidgetItem(text)
if tip:
item.setToolTip(tip)
item.setData(ACTION_ROLE, QVariant(r))
self._settingsTable.setItem(r, c, item)
def __init__(self, bpms, cors, parent = None):
super(OrbitCorrGeneral, self).__init__(parent)
self.bpms, self.cors = bpms, cors
self.sb = [bpm.sb for bpm in self.bpms]
self.x0, self.y0 = None, None
self._update_current_orbit()
self.table = QTableWidget(len(self.bpms), 9)
self.table.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
hdview = QHeaderView(Qt.Horizontal)
self.table.setHorizontalHeaderLabels(
['BPM Name', 's', "Beta X", "Beta Y",
"Eta X", 'X Bump', 'Y Bump', "Target X", "Target Y"])
self._twiss = getTwiss([b.name for b in self.bpms],
["s", "betax", "betay", "etax"])
for i,bpm in enumerate(self.bpms):
it = QTableWidgetItem(bpm.name)
it.setFlags(it.flags() & (~Qt.ItemIsEditable))
self.table.setItem(i, 0, it)
it = QTableWidgetItem(str(bpm.sb))
it.setFlags(it.flags() & (~Qt.ItemIsEditable))
#it.setMinimumWidth(80)
self.table.setItem(i, 1, it)
self.table.setItem(i, 2,
QTableWidgetItem("%.4f" % self._twiss[i,1]))
self.table.setItem(i, 3,
QTableWidgetItem("%.4f" % self._twiss[i,2]))
self.table.setItem(i, 4,
QTableWidgetItem("%.4f" % self._twiss[i,3]))
for j in range(5, 9):
it = QTableWidgetItem(str(0.0))
it.setData(Qt.DisplayRole, str(0.0))
it.setFlags(it.flags() | Qt.ItemIsEditable)
self.table.setItem(i, j, it)
# use the current orbit
#self.table.item(i,4).setData(Qt.DisplayRole, str(self.x0[i]))
#self.table.item(i,5).setData(Qt.DisplayRole, str(self.y0[i]))
#self.connect(self.table, SIGNAL("cellClicked(int, int)"),
# self._cell_clicked)
self.table.resizeColumnsToContents()
#self.table.horizontalHeader().setStretchLastSection(True)
#for i in range(4):
# print "width", i, self.table.columnWidth(i)
#self.table.setColumnWidth(0, 300)
self.table.setColumnWidth(1, 80)
vbox1 = QtGui.QVBoxLayout()
frmbox = QFormLayout()
self.base_orbit_box = QtGui.QComboBox()
#self.base_orbit_box.addItems([
# "Current Orbit", "All Zeros"])
self.base_orbit_box.addItems(["All Zeros", "Current Orbit"])
frmbox.addRow("Orbit Base", self.base_orbit_box)
grp = QtGui.QGroupBox("Local Bump")
grp.setLayout(frmbox)
vbox1.addWidget(grp)
frmbox = QFormLayout()
hln1 = QtGui.QFrame()
hln1.setLineWidth(3)
hln1.setFrameStyle(QtGui.QFrame.Sunken)
hln1.setFrameShape(QtGui.QFrame.HLine)
frmbox.addRow(hln1)
self.repeatbox = QSpinBox()
self.repeatbox.setRange(1, 20)
self.repeatbox.setValue(3)
# or connect the returnPressed() signal
frmbox.addRow("&Repeat correction", self.repeatbox)
self.rcondbox = QLineEdit()
self.rcondbox.setValidator(QDoubleValidator(0, 1, 0, self))
self.rcondbox.setText("1e-2")
frmbox.addRow("r&cond for SVD", self.rcondbox)
self.scalebox = QDoubleSpinBox()
self.scalebox.setRange(0.01, 5.00)
self.scalebox.setSingleStep(0.01)
self.scalebox.setValue(0.68)
frmbox.addRow("&Scale correctors", self.scalebox)
#hln2 = QtGui.QFrame()
#hln2.setLineWidth(3)
#hln2.setFrameStyle(QtGui.QFrame.Sunken)
#hln2.setFrameShape(QtGui.QFrame.HLine)
#frmbox.addRow(hln2)
self.progress = QProgressBar()
self.progress.setMaximum(self.repeatbox.value())
self.progress.setMaximumHeight(15)
frmbox.addRow("Progress", self.progress)
grp = QtGui.QGroupBox("Correction")
grp.setLayout(frmbox)
vbox1.addWidget(grp)
#vbox.addStretch(1.0)
#self.qdb = QDialogButtonBox(self)
#self.qdb.addButton("APP", QDialogButtonBox.ApplyRole)
#self.qdb.addButton("R", QDialogButtonBox.ResetRole)
#btn.setDefault(True)
#self.qdb.addButton(QDialogButtonBox.Cancel)
#self.qdb.addButton(QDialogButtonBox.Help)
gbox = QtGui.QGridLayout()
btn = QPushButton("Clear")
self.connect(btn, SIGNAL("clicked()"), self.resetBumps)
gbox.addWidget(btn, 0, 1)
self.correctOrbitBtn = QPushButton("Apply")
#self.correctOrbitBtn.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.correctOrbitBtn.setStyleSheet("QPushButton:disabled { color: gray }");
self.connect(self.correctOrbitBtn, SIGNAL("clicked()"), self.call_apply)
self.correctOrbitBtn.setDefault(True)
gbox.addWidget(self.correctOrbitBtn, 1, 1)
gbox.setColumnStretch(0, 1)
vbox1.addStretch()
vbox1.addLayout(gbox)
hbox1 = QtGui.QHBoxLayout()
hbox1.addWidget(self.table, 2)
hbox1.addLayout(vbox1, 0)
self.setLayout(hbox1)
self.connect(self.base_orbit_box,
SIGNAL("currentIndexChanged(QString)"),
self.updateTargetOrbit)
self.connect(self.repeatbox, SIGNAL("valueChanged(int)"),
self.progress.setMaximum)
self.connect(self.table, SIGNAL("cellChanged (int, int)"),
self.updateBump)