def create_table_widget(table, parent):
formats = table.getColFormats()
names = table.getColNames()
indices_of_visible_columns = [
j for (j, f) in enumerate(formats) if f is not None
]
headers = ["ok"] + [names[j] for j in indices_of_visible_columns]
n_rows = len(table)
widget = QTableWidget(n_rows,
1 + len(indices_of_visible_columns),
parent=parent)
widget.setHorizontalHeaderLabels(headers)
widget.setMinimumSize(200, 200)
widget.horizontalHeader().setResizeMode(QHeaderView.Interactive)
for i, row in enumerate(table.rows):
item = QTableWidgetItem()
item.setCheckState(Qt.Unchecked)
item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable
| Qt.ItemIsUserCheckable)
widget.setItem(i, 0, item)
for j0, j in enumerate(indices_of_visible_columns):
value = row[j]
formatter = table.colFormatters[j]
item = QTableWidgetItem(formatter(value))
item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable)
widget.setItem(i, j0 + 1, item)
return widget
def readingJOB_log_file(self, jobFilePath):
print ('updating job colums')
notesFile = jobFilePath
notesFileChk = os.path.exists(notesFile)
TagsForList = []
if notesFileChk == True:
with open(notesFile, 'r') as file:
jsondata = json.load(file)
self.ui.assetsList_job_tableWidget.clearContents()
self.ui.assetsList_job_tableWidget.setRowCount(len(jsondata['JOB_details']))
for i, a in enumerate(jsondata['JOB_details'], 0):
logEntry = map(str, a)
jobID = logEntry[0]
jobStart = logEntry[1]
jobEnd = logEntry[2]
jobMem = logEntry[3]
jobDuration = logEntry[3]
self.ui.assetsList_tableWidget.setRowHeight (i, 40)
self.ui.assetsList_job_tableWidget.setItem(i, 0, QTableWidgetItem(jobID))
self.ui.assetsList_job_tableWidget.setItem(i, 1, QTableWidgetItem(jobStart))
self.ui.assetsList_job_tableWidget.setItem(i, 2, QTableWidgetItem(jobEnd))
self.ui.assetsList_job_tableWidget.setItem(i, 3, QTableWidgetItem(jobMem))
self.ui.assetsList_job_tableWidget.setItem(i, 4, QTableWidgetItem(jobDuration))
else:
print ('')
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 _gotRevision(self, backend, revision):
""" Callback for loadHistory's QtDo """
if not backend:
# The last revision has been processed
self.process = None
self.ui.loadHistoryButton.setEnabled(True)
self.ui.loadHistoryButton.setText("Reload")
return
# we set the flags to Qt.ItemIsEnabled so that the items
# are not modifiable (they are modifiable by default)
item_revision = QTableWidgetItem(revision.id)
item_revision.setFlags(Qt.ItemIsEnabled)
item_time = QTableWidgetItem(
revision.timestamp.strftime('%Y-%m-%d %H:%M:%S'))
item_time.setFlags(Qt.ItemIsEnabled)
item_author = QTableWidgetItem(revision.author)
item_author.setFlags(Qt.ItemIsEnabled)
item_summary = QTableWidgetItem(revision.comment)
item_summary.setFlags(Qt.ItemIsEnabled)
row = self.ui.historyTable.currentRow() + 1
self.ui.historyTable.insertRow(row)
self.ui.historyTable.setItem(row, 0, item_revision)
self.ui.historyTable.setItem(row, 1, item_time)
self.ui.historyTable.setItem(row, 2, item_author)
self.ui.historyTable.setItem(row, 3, item_summary)
self.ui.historyTable.setCurrentCell(row, 0)
def populateMetadataTable(self):
self.clearMetadataTable()
list_metadata_selected = self.list_metadata_selected
if list_metadata_selected is None:
self.ui.saveMetadataAsAsciiButton.setEnabled(False)
return
else:
list_keys = self.list_keys
search_string = str(self.ui.searchLineEdit.text())
_index = 0
for _key in list_keys:
if _key in list_metadata_selected:
_name = _key
if (search_string != '') and \
(not(search_string.lower() in _name.lower())):
continue
self.ui.metadataTable.insertRow(_index)
_nameItem = QTableWidgetItem(_name)
self.ui.metadataTable.setItem(_index, 0, _nameItem)
[value, units] = self.retrieveValueUnits(_name)
_valueItem = QTableWidgetItem(value)
self.ui.metadataTable.setItem(_index, 1, _valueItem)
_unitsItem = QTableWidgetItem(units)
self.ui.metadataTable.setItem(_index, 2, _unitsItem)
_index += 1
self.ui.saveMetadataAsAsciiButton.setEnabled(True)
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 runFinishedFromThread(self, output):
self.testThread.stop()
QApplication.restoreOverrideCursor()
self.buttonOk.setEnabled(True)
result = output[0]
numRows = len(result)
self.tblUnique.setRowCount(numRows)
if self.myFunction in (1, 2):
self.tblUnique.setColumnCount(1)
for rec in range(numRows):
item = QTableWidgetItem(result[rec])
self.tblUnique.setItem(rec, 0, item)
else:
self.tblUnique.setColumnCount(2)
for rec in range(numRows):
if ":" not in result[rec]:
tmp = result[rec].split(u"\uff1a")
else:
tmp = result[rec].split(":")
item = QTableWidgetItem(tmp[0])
self.tblUnique.setItem(rec, 0, item)
item = QTableWidgetItem(tmp[1])
self.tblUnique.setItem(rec, 1, item)
self.tblUnique.setHorizontalHeaderLabels([self.tr("Parameter"), self.tr("Value")])
self.tblUnique.horizontalHeader().setResizeMode(1, QHeaderView.ResizeToContents)
self.tblUnique.horizontalHeader().show()
self.tblUnique.horizontalHeader().setResizeMode(0, QHeaderView.Stretch)
self.tblUnique.resizeRowsToContents()
self.lstCount.insert(unicode(output[1]))
self.cancel_close.setText("Close")
QObject.disconnect(self.cancel_close, SIGNAL("clicked()"), self.cancelThread)
return True
def loadCodeList(self):
"""
Loads the current code lists viewer for the active layer
"""
self.tableWidget.clear()
self.tableWidget.setColumnCount(2)
self.tableWidget.setHorizontalHeaderLabels(
[self.tr('Value'), self.tr('Code')])
field = self.comboBox.currentText()
valueDict, keys = self.getCodeListDict(field)
if 'FilterExpression' in keys:
valueDict = self.makeValueRelationDict(valueDict)
keys = valueDict.keys()
elif 'Relation' in keys:
return
self.tableWidget.setRowCount(len(keys))
for row, value in enumerate(keys):
code = valueDict[value]
valueItem = QTableWidgetItem(value)
codeItem = QTableWidgetItem(code)
self.tableWidget.setItem(row, 0, valueItem)
self.tableWidget.setItem(row, 1, codeItem)
self.tableWidget.sortItems(1)
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 on_create_super_group(self):
inames = [
iname for iname, check in enumerate(self.checks)
if bool(check.checkState())
]
if not len(inames):
# TODO: add logging
print('nothing is checked...')
return
if inames[0] == 0:
# TODO: add logging
print("cannot include 'ALL' in supergroup...")
return
name = 'SuperGroup'
# popup gui and get a name
irow = self.table.rowCount()
self.table.insertRow(irow)
check = QTableWidgetItem()
check.setCheckState(False)
name_text = QTableWidgetItem(str(name))
self.names.extend(name)
self.names_text.append(name_text)
self.checks.append(check)
self.table.setItem(irow, 0, check)
self.table.setItem(irow, 1, name_text)
def updateHistoryResultData(self, data_list):
logging.info(u"【主窗口-历史数据展板-大更新】################START HistoryResultData################")
# 先清空...
self.viewEntry.clearContents()
self.viewEntry.setRowCount(0)
for period in data_list:
# 添加一行
row = self.viewEntry.rowCount()
self.viewEntry.insertRow(row)
# 期数
newItem = QTableWidgetItem(period[0])
self.viewEntry.setItem(row, 0, newItem)
# 时间
newItem = QTableWidgetItem(str(period[1]))
self.viewEntry.setItem(row, 1, newItem)
if self.console.play_mode in [common.PLAYMODE_PK10, common.PLAYMODE_XYFT]:
for i in range(10):
newItem = QTableWidgetItem(str(period[2 + i]))
self.viewEntry.setItem(row, 2 + i, newItem)
else:
for i in range(5):
newItem = QTableWidgetItem(str(period[2 + i]))
self.viewEntry.setItem(row, 2 + i, newItem)
logging.info(u"【主窗口-历史数据展板-大更新】################END HistoryResultData################")
def add_new_row(self):
"""
Add a new row to the table
"""
row_count = self.gui.rawTable.rowCount()
frequency = self.gui.comboFreqRaw.itemData(
self.gui.comboFreqRaw.currentIndex())
if frequency == '':
self.gui.rawTable.insertRow(row_count)
self.gui.rawTable.setItem(row_count, 0, QTableWidgetItem(''))
return
if row_count != 0:
# read last date from table
last_pos = self.gui.rawTable.item(row_count - 1, 0)
last_date = QDateTime.fromString(last_pos.text(),
"yyyy-MM-dd hh:mm:ss")
seconds = isodate.parse_duration(frequency).total_seconds()
begin_pos = last_date.addSecs(seconds)
else:
last_date = self.gui.rawBeginPos.dateTime()
begin_pos = last_date
if begin_pos > self.gui.rawEndPos.dateTime():
return
self.gui.rawTable.insertRow(row_count)
begin_str = begin_pos.toString("yyyy-MM-dd hh:mm:ss")
self.gui.rawTable.setItem(row_count, 0, QTableWidgetItem(begin_str))
self.gui.rawTable.setItem(row_count, 1, QTableWidgetItem('0'))
self.gui.rawTable.setItem(row_count, 2, QTableWidgetItem('100'))
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 load_config_value(self):
# checks
self.check_answer_timeout.setChecked(
UserConfig.SHOW_ANSWER_ON_CARD_TIMEOUT)
self.check_overall.setChecked(UserConfig.SHOW_OVERALL_STATISTICS)
self.check_deck.setChecked(UserConfig.SHOW_DECK_STATISTICS)
self.check_start.setChecked(UserConfig.PLAY_SOUNDS['start'])
self.check_break.setChecked(UserConfig.PLAY_SOUNDS['break'])
self.check_almost_timeout.setChecked(
UserConfig.PLAY_SOUNDS['half_way_limit'])
self.check_timeout.setChecked(UserConfig.PLAY_SOUNDS['timeout'])
self.check_abort.setChecked(UserConfig.PLAY_SOUNDS['abort'])
# value
self.spin_card_secs.setValue(UserConfig.ANSWER_TIMEOUT_SECONDS)
# minutes
break_min_dicts = UserConfig.BREAK_MINUTES
sorted_keys = sorted(break_min_dicts.keys())[:7]
minites_ints = [int(re.findall("\d+", s)[0]) for s in sorted_keys]
for c in range(UserConfig.BREAK_MINUTES.items()[0].__len__()):
for r in range(sorted_keys.__len__()):
if c:
item = QTableWidgetItem(
str(break_min_dicts[sorted_keys[r]]))
else:
item = QTableWidgetItem(str(minites_ints[r]))
item.setTextAlignment(Qt.AlignCenter)
self.tableWidget.setItem(r, c, item)
def environment_selection_changed(self):
#1. get currently selected item
selection = self.ui.EnvironmentList.currentItem()
#2. clear shape table
while self.ui.ShapeTable.rowCount() > 0:
self.ui.ShapeTable.removeRow(0)
#3. clear shapes
self.ui.Canvas.scene().removeAllShapes()
if selection is None:
self.ui.ShapeFrame.setEnabled(False)
return
self._model.currentEnvironment = str(selection.text())
#4. add shapes to table
for shape in self._model.shapes():
row = self.ui.ShapeTable.rowCount()
self.ui.ShapeTable.insertRow(row)
#populate cells in row
self.ui.ShapeTable.setItem(row, 0, QTableWidgetItem(shape.name))
self.ui.ShapeTable.setItem(row, 1,
QTableWidgetItem(', '.join(shape.tags)))
shape.ID = self.ui.Canvas.scene().addShape(shape.shape)
self.ui.ShapeFrame.setEnabled(True)
def __init__(self, parent=None, admin=False):
QtGui.QMainWindow.__init__(self, parent)
self.setupUi(self)
header_labels = ('Pseudo', 'Score')
self.tblScores.setColumnCount(2)
self.tblScores.setHorizontalHeaderLabels(header_labels)
self.tblScores.horizontalHeader().setResizeMode(QHeaderView.Stretch)
# Bind buttons
self.btnLeave.clicked.connect(self.btnLeave_clicked)
if not admin:
self.btnEdit.hide()
self.btnDelete.hide()
# Get score list
utils.send_data(utils.Global.sock_server, commands.CMD_GET_SCORES)
scores = utils.recv_data(utils.Global.sock_server)
self.tblScores.setRowCount(len(scores))
row = 0
for (login, score) in scores:
self.tblScores.setItem(row, 0, QTableWidgetItem(login))
self.tblScores.setItem(row, 1, QTableWidgetItem(str(score)))
row = row + 1
def create_new_shape(self, kind, tags=[], **kwargs):
self.ui.Canvas.setFocus(0)
shape = self.ui.Canvas.scene().createShape(kind, **kwargs)
if not shape is None:
name, tags, comments = self.edit_shape_data(name='',
tags=tags,
comments='')
if name != '':
self._model.create_shape(name=name,
tags=tags,
comments=comments,
shape=shape)
row = self.ui.ShapeTable.rowCount()
self.ui.ShapeTable.insertRow(row)
#populate cells in row
self.ui.ShapeTable.setItem(row, 0, QTableWidgetItem(name))
self.ui.ShapeTable.setItem(row, 1,
QTableWidgetItem(', '.join(tags)))
self._model.shape(name).ID = self.ui.Canvas.scene().addShape(
shape)
def __init__(self, parent, caller):
super(aggregate, self).__init__(parent)
self.parent = parent
self.iface = caller.iface
self.resize(QSize(310, 260))
self.setColumnCount(2)
self.setColumnWidth(0, 152)
self.setColumnWidth(1, 152)
self.setRowCount(len(self.parameters) - 1)
self.verticalHeader().hide()
self.horizontalHeader().hide()
S = QSettings()
for row, parameter in enumerate(self.parameters):
if row == 0:
self.service_id = parameter[1]
continue
row = row - 1
pKey = QTableWidgetItem(parameter[0])
pKey.setFlags(pKey.flags() ^ Qt.ItemIsEditable)
pValue = QTableWidgetItem(parameter[1])
self.setItem(row, 0, pKey)
valueFromSettings = S.value(
"QRealTime/%s/%s/" %
(self.service_id, self.item(row, 0).text()),
defaultValue="undef")
if not valueFromSettings or valueFromSettings == "undef":
self.setItem(row, 1, pValue)
S.setValue(
"QRealTime/%s/%s/" %
(self.service_id, self.item(row, 0).text()), parameter[1])
else:
self.setItem(row, 1, QTableWidgetItem(valueFromSettings))
def AddVersion(self):
self.ui.versions.insertRow(0)
item = QTableWidgetItem(str(self.ui.versions.rowCount()))
item.setFlags(QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled
| QtCore.Qt.ItemIsUserCheckable)
self.ui.versions.setItem(0, 0, item)
self.ui.versions.setItem(0, 1, QTableWidgetItem(str(1.0)))
def setupUi(self):
self.resize(568, 411)
self.setWindowIcon(QIcon(':/icon/layer_icon'))
self.setWindowTitle("Edit Markers")
self.gridLayout = QGridLayout(self)
# table widget
self.tableWidget = QTableWidget(self)
self.tableWidget.setColumnCount(4)
self.tableWidget.setRowCount(0)
self.tableWidget.setHorizontalHeaderItem(0, QTableWidgetItem("Name"))
self.tableWidget.setHorizontalHeaderItem(1,
QTableWidgetItem("TVD (m)"))
self.tableWidget.setHorizontalHeaderItem(2,
QTableWidgetItem("TVDSS (m)"))
self.tableWidget.setHorizontalHeaderItem(3, QTableWidgetItem("Color"))
self.gridLayout.addWidget(self.tableWidget, 0, 0, 1, 1)
# button box
self.button_box = QDialogButtonBox(self)
self.export_Button = self.button_box.addButton(
"Export", QDialogButtonBox.ResetRole)
self.import_Button = self.button_box.addButton(
"Import", QDialogButtonBox.ResetRole)
self.add_Button = self.button_box.addButton("Add",
QDialogButtonBox.ResetRole)
self.del_Button = self.button_box.addButton("Del",
QDialogButtonBox.ResetRole)
self.button_box.setStandardButtons(QDialogButtonBox.Save
| QDialogButtonBox.Cancel)
self.gridLayout.addWidget(self.button_box, 1, 0, 1, 1)
def display(self, logRow):
self.clearRows()
layerFeature = logRow.getLayerFeature()
# if a feature exists (it has been modified but not deleted), display difference
if layerFeature is None:
nc = 2
else:
nc = 3
self.columns(nc, logRow.dateStr())
items = [0, 0, 0]
items = items[:nc]
currentValue = None
for r, field in enumerate(logRow.fields):
self.insertRow(r)
logValue = logRow.getFieldValue(logRow.logData, field.name())
items[0] = QTableWidgetItem(field.name())
if layerFeature is not None:
currentValue = layerFeature[field.name()]
if currentValue is None:
currentValue = "NULL"
items[1] = QTableWidgetItem(currentValue)
items[nc - 1] = QTableWidgetItem(logValue)
for c, item in enumerate(items):
self.reduceFontSize(item)
item.setFlags(Qt.ItemIsEnabled)
if layerFeature is not None and currentValue != logValue:
item.setBackground(QBrush(QColor(250, 250, 210)))
self.setItem(r, c, item)
self.resizeColumnsToContents()
self.adjustSize()
def setTableContent(self):
params = self._alg.parameters
outputs = self._alg.outputs
visibleParams = [p for p in params if not p.hidden]
visibleOutputs = [p for o in outputs if not o.hidden]
self.tableWidget.setRowCount(len(visibleParams) + len(visibleOutputs))
for i, param in visibleParams:
item = QTableWidgetItem(param.description)
item.setFlags(Qt.ItemIsEnabled)
self.tableWidget.setItem(i, 0, item)
item = self.getWidgetFromParameter(param)
self.valueItems[param.name] = item
self.tableWidget.setCellWidget(i, 1, item)
self.tableWidget.setRowHeight(i, 22)
for i, output in visibleOutputs:
item = QTableWidgetItem(output.description + '<'
+ output.__module__.split('.')[-1] + '>')
item.setFlags(Qt.ItemIsEnabled)
self.tableWidget.setItem(i, 0, item)
item = QLineEdit()
if hasattr(item, 'setPlaceholderText'):
item.setPlaceholderText(ModelerParametersDialog.ENTER_NAME)
self.valueItems[output.name] = item
self.tableWidget.setCellWidget(i, 1, item)
self.tableWidget.setRowHeight(i, 22)
def populateConfigTable(self):
self.clearConfigTable()
list_keys = self.list_keys
list_values = self.list_values
search_string = str(self.ui.searchLineEdit.text()).lower()
_metadata_table = self.list_metadata_selected
_index = 0
for _key in list_keys:
_name = _key
if (search_string.strip() != '') and \
(not(search_string in _name.lower())):
continue
self.ui.configureTable.insertRow(_index)
_nameItem = QTableWidgetItem(_name)
self.ui.configureTable.setItem(_index, 1, _nameItem)
_yesNo = QCheckBox()
_id = list_keys.index(_name)
_value = list_values[_id]
_yesNo.setChecked(_value)
_yesNo.setText('')
_yesNo.stateChanged.connect(self.configTableEdited)
self.ui.configureTable.setCellWidget(_index, 0, _yesNo)
[value, units] = self.retrieveValueUnits(_name)
_valueItem = QTableWidgetItem(value)
self.ui.configureTable.setItem(_index, 2, _valueItem)
_unitsItem = QTableWidgetItem(units)
self.ui.configureTable.setItem(_index, 3, _unitsItem)
_index += 1
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 extend_rows(self):
pw = (self.parentWidget().width()) / (len(self.hheaders) + 2)
# if pw == 14:
# pw = 125
self.setColumnWidth(0, pw * 3)
self.setColumnWidth(1, pw)
self.setColumnWidth(2, pw)
self.setColumnWidth(3, pw)
self.setColumnWidth(4, pw)
nb_rows = self.rowCount()
self.setRowCount(nb_rows + 2)
self.setSpan(nb_rows, 0, 2, 2)
mtt_ttc = QTableWidgetItem(u"TOTAUX: ")
mtt_ttc.setTextAlignment(Qt.AlignRight)
self.setItem(nb_rows + 1, 2, mtt_ttc)
self.montant_ht = 0
self.montant_b = 0
for row_num in xrange(0, self.data.__len__()):
mtt = is_int(self.item(row_num, 3).text())
mttb = is_int(self.item(row_num, 4).text())
self.montant_ht += mtt
self.montant_b += mttb
# Montant TTC
montant_t = QTableWidgetItem(formatted_number(self.montant_ht))
montant_t.setTextAlignment(Qt.AlignRight)
montant_tb = QTableWidgetItem(formatted_number(self.montant_b))
montant_tb.setTextAlignment(Qt.AlignRight)
self.setItem(row_num + 2, 3, montant_t)
self.setItem(row_num + 2, 4, montant_tb)
def __init__(self, emails, types, parent):
self.emails, self.types = emails, types
QDialog.__init__(self, parent)
self.resize(560, 350)
self.gridLayout = QGridLayout(self)
self.tableWidget = QTableWidget(0, 2, self)
self.tableWidget.setAlternatingRowColors(True)
self.tableWidget.setSelectionBehavior(1) # Rows
self.tableWidget.setSelectionMode(1) # Single
self.tableWidget.horizontalHeader().setResizeMode(0, 1) # 1 = Stretch
self.tableWidget.setHorizontalHeaderLabels(['Email', 'Type'])
self.addBtn = QPushButton('+', self)
self.removeBtn = QPushButton('-', self)
self.closeBtn = QPushButton('Close', self)
self.spacer = QWidget(self)
self.spacer.setSizePolicy(1 | 2 | 4, 1 | 4)
self.gridLayout.addWidget(self.tableWidget, 0, 0, 1, 4)
self.gridLayout.addWidget(self.addBtn, 1, 0, 1, 1)
self.gridLayout.addWidget(self.removeBtn, 1, 1, 1, 1)
self.gridLayout.addWidget(self.spacer, 1, 2, 1, 1)
self.gridLayout.addWidget(self.closeBtn, 1, 3, 1, 1)
self.addBtn.clicked.connect(self.addAccount)
self.removeBtn.clicked.connect(self.removeAccount)
self.closeBtn.clicked.connect(self.accept)
for i in range(len(self.emails)):
self.tableWidget.insertRow(i)
self.tableWidget.setItem(i, 0, QTableWidgetItem(emails[i]))
self.tableWidget.setItem(i, 1, QTableWidgetItem(types[i]))
def fill_table(self,datasetsList):
# first delete all elements of table
self.dlg.tableWidget.setRowCount(0)
self.dlg.tableWidget.setColumnCount(3)
#FILL THE TABLE WIDGET
# get a sorted version of lirt with WebServiceObjects
WebServiceObjects = self.sort(datasetsList)
for dataset in WebServiceObjects:
index = WebServiceObjects.index(dataset)
self.dlg.tableWidget.insertRow(index)
# fill layer name
self.dlg.tableWidget.setItem(index , 0, QTableWidgetItem(dataset.getName(self.language))) #dataset name
self.dlg.tableWidget.setItem(index , 1, QTableWidgetItem(dataset.serviceType)) # webservice type
self.dlg.tableWidget.setItem(index , 2, QTableWidgetItem(dataset.getSource(self.language))) # source organization
#name of columns
if self.language == "EN":
self.dlg.tableWidget.setHorizontalHeaderLabels(["Name","Type","Organization"])
elif self.language == "GR":
namegr = unicode("Όνομα", 'utf-8')
typegr = unicode("Τύπος", 'utf-8')
orggr = unicode("Οργανισμός", 'utf-8')
self.dlg.tableWidget.setHorizontalHeaderLabels([namegr,typegr,orggr])
self.setTableWidgetBehavour()
def clear_table(self):
self.need_to_update_graph = False
for r in range(self.table.rowCount()):
self.table.setItem(r, 0, QTableWidgetItem(None))
self.table.setItem(r, 1, QTableWidgetItem(None))
for row in range(self.rows_nr):
for col in range(self.cols_nr):
if self.edit_type == self.edit_patterns:
if col == 0:
item = QTableWidgetItem(str(row))
self.table.setItem(row, col, item)
item.setFlags(QtCore.Qt.ItemIsSelectable)
# elif col == 1 and row == 0:
# item = QTableWidgetItem(str(1))
# self.table.setItem(row, col, item)
# item.setFlags(QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled)
# elif self.edit_type == self.edit_curves:
# if row == 0:
# item = QTableWidgetItem(str(0))
# self.table.setItem(row, 0, item)
# item = QTableWidgetItem(str(1))
# self.table.setItem(row, 1, item)
# item.setFlags(QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled)
self.need_to_update_graph = True
def setAttachments(self, xml_doc): # bodystructure dom
msg_id = self.mailInfoFrame.msg_id[:].replace('/', '_')
# save bodystructure
msg_struct = ACNT_DIR + self.email_id + '/mails/' + msg_id + '.xml'
if not os.path.exists(msg_struct):
with open(msg_struct, 'w') as fd:
fd.write(unicode(xml_doc))
# get attachments
text_part_num, txt_enc, attachments = getAttachments(xml_doc)
for [part_num, enc, filename, file_size] in attachments:
ro = self.tableWidget.rowCount()
self.tableWidget.insertRow(ro)
item = QTableWidgetItem(QIcon(':/download.png'), filename)
item.part_num = part_num
item.encoding = enc
self.tableWidget.setItem(ro, 0, item)
self.tableWidget.setItem(ro, 1, QTableWidgetItem(file_size))
if self.tableWidget.rowCount() > 0:
self.tableWidget.show()
# load html body
msg_file = ACNT_DIR + self.email_id + '/mails/' + msg_id + '.txt'
if os.path.exists(msg_file):
with open(msg_file, 'rb') as fd:
html = fd.read()
self.setMailText(unicode(html, 'utf8')) # convert byte string to unicode
else:
row = self.mailsTable.selectionModel().selectedRows()[0].row()
self.mailTextRequested.emit(self.total_mails-row, text_part_num, txt_enc)
self.mailsTable.cellWidget(row, 0).cached = True
def populateMetadataTable(self):
list_metadata_selected = self.list_metadata_selected
_index = 0
for i in range(len(self.list_nxs)):
self.ui.metadataTable.insertRow(_index)
_nxs = self.list_nxs[i]
mt_run = _nxs.getRun()
_runs = self.list_runs[i]
_runItem = QTableWidgetItem(str(_runs))
self.ui.metadataTable.setItem(_index, 0, _runItem)
_filename = self.list_filename[i]
_ipts = self.getIPTS(_filename)
_iptsItem = QTableWidgetItem(_ipts)
self.ui.metadataTable.setItem(_index, 1, _iptsItem)
column_index = 0
for name in list_metadata_selected:
[value,units] = self.retrieveValueUnits(mt_run,
name)
_str = str(value) + ' ' + str(units)
_item = QTableWidgetItem(_str)
self.ui.metadataTable.setItem(_index,
2 + column_index,
_item)
column_index += 1
_index += 1
