def updateFormatsTable(self, mimeData=None):
self.formatsTable.setRowCount(0)
if mimeData is None:
return
for format in mimeData.formats():
formatItem = QTableWidgetItem(format)
formatItem.setFlags(Qt.ItemIsEnabled)
formatItem.setTextAlignment(Qt.AlignTop | Qt.AlignLeft)
if format == 'text/plain':
text = mimeData.text().strip()
elif format == 'text/html':
text = mimeData.html().strip()
elif format == 'text/uri-list':
text = " ".join([url.toString() for url in mimeData.urls()])
else:
text = " ".join(["%02X" % ord(datum) for datum in mimeData.data(format)])
row = self.formatsTable.rowCount()
self.formatsTable.insertRow(row)
self.formatsTable.setItem(row, 0, QTableWidgetItem(format))
self.formatsTable.setItem(row, 1, QTableWidgetItem(text))
self.formatsTable.resizeColumnToContents(0)
def refresh_table(self):
self._manual_change = True
self._custom_fields = list(
self._configuration.scheduler_info.data.keys())
labels = self._header + self._custom_fields
self.setRowCount(len(labels))
self.setVerticalHeaderLabels(labels)
self.horizontalHeader().setStretchLastSection(False)
header = self.horizontalHeader()
header.setSectionResizeMode(0, QHeaderView.Stretch)
header.setSectionResizeMode(1, QHeaderView.Interactive)
#header.setSectionResizeMode(2, QHeaderView.Interactive)
self.horizontalHeader().hide()
combo = QComboBox()
combo.addItems(['Custom scheduler...'] + list(get_schedulers()))
self.setCellWidget(0, 0, combo)
self.setSpan(0, 0, 1, 2)
name = self._configuration.scheduler_info.filename
scheduler_item = QTableWidgetItem(name and os.path.relpath(
name, self._configuration.cur_dir))
scheduler_item.setFlags(scheduler_item.flags() ^ (Qt.ItemIsEditable))
self.setItem(1, 0, scheduler_item)
self._btn_open = QPushButton(self)
self._btn_open.setText('Open')
self._btn_open.clicked.connect(self._open_scheduler)
self.setCellWidget(1, 1, self._btn_open)
combo.currentIndexChanged['QString'].connect(self._select_scheduler)
if self._configuration.scheduler_info.clas:
i = combo.findText(self._configuration.scheduler_info.clas)
if i <= 0:
i = 0
combo.setCurrentIndex(i)
self.setItem(
2, 0, QTableWidgetItem(str(
self._configuration.scheduler_info.overhead))
)
self.setSpan(2, 0, 1, 2)
self.setItem(
3, 0, QTableWidgetItem(str(
self._configuration.scheduler_info.overhead_activate))
)
self.setSpan(3, 0, 1, 2)
self.setItem(
4, 0, QTableWidgetItem(str(
self._configuration.scheduler_info.overhead_terminate))
)
self.setSpan(4, 0, 1, 2)
i = 5
for name, value in self._configuration.scheduler_info.data.items():
self.setItem(i, 0, QTableWidgetItem(str(value)))
self.setSpan(i, 0, 1, 2)
i += 1
def show_musics(self, playmid):
self.clean_table()
r = server.getServer('playlists/'+playmid, {'id':playmid})
#http://nullege.com/codes/show/src@p@y@pyqt5-HEAD@examples@[email protected]/193/PyQt5.QtWidgets.QTableWidget.setSelectionBehavior
if len(r['payload']['musics']) == 0:
self.clean_table()
else:
self.tableWidget.setRowCount(len(r['payload']['musics']))
self.tableWidget.setColumnCount(1)
self.tableWidget.setHorizontalHeaderLabels(['Musica'])
self.tableWidget.setSelectionBehavior(QtWidgets.QAbstractItemView.SelectRows)
self.tableWidget.horizontalHeader().setStretchLastSection(True)
self.tableWidget.cellDoubleClicked.connect(self.select_music)
i = 0
self.musics_in_current_playlist_by_index = {}
for music in r['payload']['musics']:
self.musics_in_current_playlist_by_index[i] = {
'id': music['id'], 'file_name': music['file_name'],
'name': music['name']
}
musica = QTableWidgetItem(music['name'])
file_path = QTableWidgetItem(music['file_name'])
musica.setFlags(musica.flags() & ~Qt.ItemIsEditable)
self.tableWidget.setItem(i, 0, musica)
self.tableWidget.setItem(i, 1, file_path)
i+=1
def insertRound(self, r):
closeType = r.getCloseType()
winner = r.getWinner()
background = self.bgcolors[closeType]
i = r.getNumRound() - 1
self.insertRow(i)
for j, player in enumerate(self.engine.getListPlayers()):
item = QTableWidgetItem()
item.setFlags(item.flags() ^ QtCore.Qt.ItemIsEditable)
item.setTextAlignment(QtCore.Qt.AlignVCenter |
QtCore.Qt.AlignCenter)
item.setBackground(QtGui.QBrush(QtGui.QColor(background)))
if player == winner:
text = i18n(
"RemigioRoundTable", "Winner ({}x)").format(closeType)
font = item.font()
font.setBold(True)
item.setFont(font)
elif self.engine.wasPlayerOff(
player, r.getNumRound()) or r.getPlayerScore(player) < 0:
if r.getPlayerScore(player) < 0:
text = ""
else:
text = str(r.getPlayerScore(player))
item.setBackground(QtGui.QBrush(QtCore.Qt.gray))
else:
text = str(r.getPlayerScore(player))
item.setText(text)
self.setItem(i, j, item)
self.scrollToBottom()
def readPreferences(self):
self.qs.beginGroup("Preferences")
self.honeycomb_rows = self.qs.value("honeycomb_rows", slicestyles.HONEYCOMB_PART_MAXROWS)
self.honeycomb_cols = self.qs.value("honeycomb_cols", slicestyles.HONEYCOMB_PART_MAXCOLS)
self.honeycomb_steps = self.qs.value("honeycomb_steps", slicestyles.HONEYCOMB_PART_MAXSTEPS)
self.square_rows = self.qs.value("square_rows", slicestyles.SQUARE_PART_MAXROWS)
self.square_cols = self.qs.value("square_cols", slicestyles.SQUARE_PART_MAXCOLS)
self.square_steps = self.qs.value("square_steps", slicestyles.SQUARE_PART_MAXSTEPS)
self.auto_scaf_index = self.qs.value("autoScaf", styles.PREF_AUTOSCAF_INDEX)
self.startup_tool_index = self.qs.value("startup_tool", styles.PREF_STARTUP_TOOL_INDEX)
self.zoom_speed = self.qs.value("zoom_speed", styles.PREF_ZOOM_SPEED)
self.zoom_on_helix_add = self.qs.value("zoom_on_helix_add", styles.PREF_ZOOM_AFTER_HELIX_ADD)
self.qs.endGroup()
self.ui_prefs.honeycomb_rows_spin_box.setProperty("value", self.honeycomb_rows)
self.ui_prefs.honeycomb_cols_spin_box.setProperty("value", self.honeycomb_cols)
self.ui_prefs.honeycomb_steps_spin_box.setProperty("value", self.honeycomb_steps)
self.ui_prefs.square_rows_spin_box.setProperty("value", self.square_rows)
self.ui_prefs.square_cols_spin_box.setProperty("value", self.square_cols)
self.ui_prefs.square_steps_spin_box.setProperty("value", self.square_steps)
self.ui_prefs.auto_scaf_combo_box.setCurrentIndex(self.auto_scaf_index)
self.ui_prefs.default_tool_combo_box.setCurrentIndex(self.startup_tool_index)
self.ui_prefs.zoom_speed_slider.setProperty("value", self.zoom_speed)
ptw = self.ui_prefs.plugin_table_widget
loaded_plugin_paths = util.loadedPlugins.keys()
ptw.setRowCount(len(loaded_plugin_paths))
for i in range(len(loaded_plugin_paths)):
row = QTableWidgetItem(loaded_plugin_paths[i])
row.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable)
ptw.setItem(i, 0, row)
def get_library(self):
self.clean_table()
r = server.getServer('musics/', {'token':session_lib.get_token()})
if len(r['payload']['musics']) == 0:
self.clean_table()
else:
self.tableWidget.setRowCount(len(r['payload']['musics']))
self.tableWidget.setColumnCount(1)
self.tableWidget.setHorizontalHeaderLabels(['Musica'])
self.tableWidget.setSelectionBehavior(QtWidgets.QAbstractItemView.SelectRows)
self.tableWidget.horizontalHeader().setStretchLastSection(True)
self.tableWidget.cellDoubleClicked.connect(self.select_music)
i = 0
self.musics_in_current_playlist_by_index = {}
for music in r['payload']['musics']:
self.musics_in_current_playlist_by_index[i] = {
'id': music['id'], 'file_name': music['file_name'],
'name': music['name']
}
musica = QTableWidgetItem(music['name'])
file_path = QTableWidgetItem(music['file_name'])
musica.setFlags(musica.flags() & ~Qt.ItemIsEditable)
self.tableWidget.setItem(i, 0, musica)
self.tableWidget.setItem(i, 1, file_path)
i+=1
def _new_setting(self):
"""
Add a new setting to the config
:return: None
"""
# get the number of rows in the table
_rows = self._table.rowCount()
# create a wizard to get the setting name and setting value from the user
_wizard = OptionWizard(self._tran.get_text('option_wizard_title'), self._tran)
# open the wizard
_wizard.exec_()
# only if the user has entered a setting name
if _wizard.setting_name():
# create a new item holding the entered data
self._table.insertRow(_rows)
_key = QTableWidgetItem(_wizard.setting_name())
# make the new item editable and selectable
_flags = _key.flags()
_flags |= Qt.ItemIsSelectable
_flags &= Qt.ItemIsEditable
_key.setFlags(_flags)
# add the new item to the table
self._table.setItem(_rows, 0, _key)
self._table.setItem(_rows, 1, QTableWidgetItem(_wizard.setting_value()))
# add the new setting to the config
self._config[_wizard.setting_name()] = _wizard.setting_value()
# make the default config visible in the ui, toggle tooltips, ...
self.init()
def append_items(self, item_data_list):
for data in item_data_list:
pathname = data["pathname"]
path,name = os.path.split(pathname)
character = ""
if "character" in data:
character = data["character"]
count = self.table.rowCount()
self.table.insertRow(count)
# thumbnail
img = QImage()
img.load(pathname)
thumbnail_item = QTableWidgetItem()
thumbnail_item.setTextAlignment(Qt.AlignCenter);
thumbnail_item.setData(Qt.DecorationRole, QPixmap.fromImage(img));
self.table.setItem(count, 0, thumbnail_item)
# name
name_item = QTableWidgetItem(name)
name_item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
self.table.setItem(count, 1, name_item)
# character
self.table.setItem(count, 2, QTableWidgetItem(character))
self.image_config.append({
"image":pathname,
"character":character,
})
self.table.resizeColumnToContents(0)
def __init__(self, parent=None):
super(PlayList, self).__init__(parent)
#self.centralwidget = QtWidgets.QWidget(Pytunes)
#self.tableWidget = QtWidgets.QTableWidget()
#self.tableWidget.setObjectName("tableWidget")
self.setupUi(self)
#def playlistNumber(self):
entries = [{'name':'NomeMusica','artist':'artista'}]
#with open('data') as input:
#for d in table_data:
self.tableWidget.setRowCount(len(entries))
self.tableWidget.setColumnCount(2)
#http://nullege.com/codes/show/src@p@y@pyqt5-HEAD@examples@[email protected]/193/PyQt5.QtWidgets.QTableWidget.setSelectionBehavior
self.tableWidget.setSelectionBehavior(QtWidgets.QAbstractItemView.SelectRows)
self.tableWidget.setHorizontalHeaderLabels(['Musica','Artista'])
i = 0
for d in entries:
Musica = QTableWidgetItem(d['name'])
Artista = QTableWidgetItem(d['artist'])
#http://nullege.com/codes/search/PyQt5.QtWidgets.QTableWidgetItem.setFlags
#http://stackoverflow.com/questions/7727863/how-to-make-a-cell-in-a-qtablewidget-read-only
Musica.setFlags(Musica.flags() & ~Qt.ItemIsEditable)
Artista.setFlags(Artista.flags() & ~Qt.ItemIsEditable)
self.tableWidget.setItem(i, 0, Musica)
self.tableWidget.setItem(i, 1, Artista)
#QTableWidgetItem.setFlags(QTableWidgetItem.flags() & ~Qt.ItemIsEditable)
i+=1
def setErrors(self, errors):
self.errors = errors
for idx, err_key in enumerate(sorted(self.errors)):
err = self.errors[err_key]
id_item = QTableWidgetItem(err.id)
id_item.setFlags(Qt.ItemIsEnabled)
desc_item = QTableWidgetItem(err.check)
desc_item.setFlags(Qt.ItemIsEnabled)
penalty_item = QTableWidgetItem(str(err.penalty))
penalty_item.setTextAlignment(Qt.AlignCenter)
cell_widget = QWidget()
chk_box = QCheckBox()
if err.is_enabled:
chk_box.setCheckState(Qt.Checked)
else:
chk_box.setCheckState(Qt.Unchecked)
chk_box.stateChanged.connect(lambda state, err=err: self.chkboxClicked(err, state))
layout = QHBoxLayout(cell_widget)
layout.addWidget(chk_box)
layout.setAlignment(Qt.AlignCenter)
cell_widget.setLayout(layout)
self.table.setItem(idx, 0, id_item)
self.table.setItem(idx, 1, desc_item)
self.table.setItem(idx, 2, penalty_item)
self.table.setCellWidget(idx, 3, cell_widget)
def _markImmCompares(self):
"""
Marks the immediate compares within the current function
"""
self.output_window.append("Marking all immediate compares...")
self.table_label.setText("Immediate compares within current function")
ins_color = 0x2020c0
self.table.setColumnCount(2)
self.table.setHorizontalHeaderLabels(("Address", "Disassembly"))
self.table.clearContents()
self.table.setRowCount(0)
idx = 0
for cmp_ea, dis in self.ba.find_imm_compares():
self.table.insertRow(idx)
addr_item = QTableWidgetItem("%x" % cmp_ea)
addr_item.setFlags(addr_item.flags() ^ QtCore.Qt.ItemIsEditable)
dis_item = cw.NumQTableWidgetItem("%s" % dis)
self.table.setItem(idx, 0, addr_item)
self.table.setItem(idx, 1, dis_item)
misc.set_ins_color(cmp_ea, ins_color)
idx += 1
def addImage(self):
fileNames, _ = QFileDialog.getOpenFileNames(self, "Open Images", '',
"Images (*.png *.xpm *.jpg);;All Files (*)")
for fileName in fileNames:
row = self.imagesTable.rowCount()
self.imagesTable.setRowCount(row + 1)
imageName = QFileInfo(fileName).baseName()
item0 = QTableWidgetItem(imageName)
item0.setData(Qt.UserRole, fileName)
item0.setFlags(item0.flags() & ~Qt.ItemIsEditable)
item1 = QTableWidgetItem("Normal")
item2 = QTableWidgetItem("Off")
if self.guessModeStateAct.isChecked():
if '_act' in fileName:
item1.setText("Active")
elif '_dis' in fileName:
item1.setText("Disabled")
elif '_sel' in fileName:
item1.setText("Selected")
if '_on' in fileName:
item2.setText("On")
self.imagesTable.setItem(row, 0, item0)
self.imagesTable.setItem(row, 1, item1)
self.imagesTable.setItem(row, 2, item2)
self.imagesTable.openPersistentEditor(item1)
self.imagesTable.openPersistentEditor(item2)
item0.setCheckState(Qt.Checked)
def _patchBinary(self):
"""
Exports the current function code, ascii hex encoded
This is useful to import into tools like miasm and alike
"""
self._console_output("Patching the original binary...")
pl = patch_binary()
if not pl:
self._console_output("[!] No bytes to patch", err = True)
return
self.table.setColumnCount(3)
self.table.setHorizontalHeaderLabels(
('File offset', 'Original', 'Patched'))
self.table_label.setText("Patched bytes exported to file")
self.table.clearContents()
self.table.setRowCount(0)
# Fill with contents
for idx, (fpos, o, p) in enumerate(pl):
self.table.insertRow(idx)
fpos_item = QTableWidgetItem("%x" % fpos)
fpos_item.setFlags(fpos_item.flags() ^ QtCore.Qt.ItemIsEditable)
orig_item = QTableWidgetItem("%x" % o)
patch_item = QTableWidgetItem("%x" % p)
self.table.setItem(idx, 0, fpos_item)
self.table.setItem(idx, 1, orig_item)
self.table.setItem(idx, 2, patch_item)
self._console_output("Done patching. Look in the same directory as the original for a .patched file")
def insertRound(self, r):
winner = r.getWinner()
i = r.getNumRound() - 1
self.insertRow(i)
for j, player in enumerate(self.engine.getListPlayers()):
item = QTableWidgetItem()
item.setFlags(item.flags() ^ QtCore.Qt.ItemIsEditable)
item.setTextAlignment(QtCore.Qt.AlignVCenter |
QtCore.Qt.AlignCenter)
if player == winner:
text = i18n(
"Phase10RoundTable", "Winner")
font = item.font()
font.setBold(True)
item.setFont(font)
else:
text = str(r.getPlayerScore(player))
a_phase = r.getPlayerAimedPhase(player)
c_phase = r.getPlayerCompletedPhase(player)
text += i18n(
"Phase10PlayerWidget", " (Phase {})").format(a_phase)
if c_phase != 0:
background = 0xCCFF99 # green
else:
background = 0xFFCC99 # red
item.setBackground(QtGui.QBrush(QtGui.QColor(background)))
item.setText(text)
self.setItem(i, j, item)
self.scrollToBottom()
def insertRound(self, r):
winner = r.getWinner()
i = r.getNumRound() - 1
self.insertRow(i)
hands = self.engine.getHands(r.getNumRound())
direction = self.engine.getDirection(r.getNumRound())
hitem = QTableWidgetItem("{} {}".format(hands,
i18n("PochaWidget", direction)))
self.setVerticalHeaderItem(i, hitem)
for j, player in enumerate(self.engine.getListPlayers()):
item = QTableWidgetItem()
item.setFlags(item.flags() ^ QtCore.Qt.ItemIsEditable)
item.setTextAlignment(QtCore.Qt.AlignVCenter |
QtCore.Qt.AlignCenter)
score = r.getPlayerScore(player)
if score > 0:
background = self.bgcolors[0]
else:
background = self.bgcolors[1]
item.setBackground(QtGui.QBrush(QtGui.QColor(background)))
text = str(score)
if player == winner:
text += i18n("PochaRoundTable", " (Winner)")
item.setText(text)
self.setItem(i, j, item)
self.scrollToBottom()
def drawDataTable(self,tab): # Called when user switches tabWidget to the Table Preview
if tab != 1 or self.needsRedraw == False: return
fields = self.fields
self.dataTable.clear()
self.repaint()
self.dataTable.setColumnCount(len(fields))
self.dataTable.setRowCount(self.provider.featureCount())
header = []
for i in fields.values():
header.append(i.name())
self.dataTable.setHorizontalHeaderLabels(header)
formatting = True
if formatting: # slower procedure, with formatting the table items
for i in range(len(self.data)):
for j in range(len(self.data[i])):
item = QTableWidgetItem(unicode(self.data[i][j] or 'NULL'))
item.setFlags(Qt.ItemIsSelectable)
if fields[i].type() == 6 or fields[i].type() == 2:
item.setTextAlignment(Qt.AlignRight | Qt.AlignVCenter)
self.dataTable.setItem(j,i,item)
else: # about 25% faster procedure, without formatting
for i in range(len(self.data)):
for j in range(len(self.data[i])):
self.dataTable.setItem(j,i,QTableWidgetItem(unicode(self.data[i][j] or 'NULL')))
self.dataTable.resizeColumnsToContents()
self.needsRedraw = False
def updateZoneOccupationTableRow(self, zone, tableItems=None):
if (tableItems == None):
tableItems = []
for i in range(2):
item = QTableWidgetItem()
item.setTextAlignment(ITEM_ALIGN_FLAGS)
item.setFlags(ITEM_INTERACT_FLAGS)
tableItems.append(item)
self.zoTable.insertRow(0)
self.zoTable.setItem(0, 0, tableItems[0])
self.zoTable.setItem(0, 1, tableItems[1])
tableItems[0].setText(zone.name)
tableItems[0].setData(5, zone.xmlId)
wearablesPresent = ""
firstOneFlag = True
signalDataList = zone.wearablesInZone.items()
counter = 0
for wearbleId, signalData in signalDataList:
wearable = self.systemState.getHardwareObjectByHwId(TID_W, wearbleId)
if (not signalData.isInZone):
continue
counter += 1
if (firstOneFlag):
firstOneFlag = False
else:
wearablesPresent = wearablesPresent + ", "
wearablesPresent = wearablesPresent + wearable.name
if (counter == 0):
wearablesPresent = "[none]"
tableItems[1].setText(wearablesPresent)
def _showConnectedIO(self):
"""
Shows a list of functions dealing with IO and
connected to the current function
"""
self._console_output("Calculating file & network IO...")
io_list = self.ba.input_to_function()
if not io_list:
self._console_output("[!] No (obvious) IO connecting to this function",
err = True)
return
self.table.setColumnCount(2)
self.table.setHorizontalHeaderLabels(("Caller", "Name"))
self.table_label.setText("Connected IO")
self.table.clearContents()
self.table.setRowCount(0)
for idx, caller in enumerate(io_list):
self.table.insertRow(idx)
addr_item = QTableWidgetItem("%08x" % caller)
addr_item.setFlags(addr_item.flags() ^ QtCore.Qt.ItemIsEditable)
name_item = QTableWidgetItem("%s" % misc.get_function_name(caller))
self.table.setItem(idx, 0, addr_item)
self.table.setItem(idx, 1, name_item)
def _showMostReferenced(self):
"""
Shows the most referenced functions.
"""
self._console_output("Calculating most referenced functions...")
self.table_label.setText("Most referenced functions")
most_referenced = self.ba.most_referenced_functions()
self.table.setColumnCount(3)
self.table.setHorizontalHeaderLabels(("Address", "References", "Name"))
self.table.clearContents()
self.table.setRowCount(0)
idx = 0
# Fill with contents
for f_ea, (ref_nr, ref_name) in most_referenced:
self.table.insertRow(idx)
addr_item = QTableWidgetItem("%x" % f_ea)
addr_item.setFlags(addr_item.flags() ^ QtCore.Qt.ItemIsEditable)
ref_item = cw.NumQTableWidgetItem("%d" % ref_nr)
name_item = QTableWidgetItem(ref_name)
self.table.setItem(idx, 0, addr_item)
self.table.setItem(idx, 1, ref_item)
self.table.setItem(idx, 2, name_item)
idx += 1
def update(self, checked=False, labels=None, custom_labels=None):
"""Use this function when we make changes to the list of labels or when
we load a new dataset.
Parameters
----------
checked : bool
argument from clicked.connect
labels : list of str
list of labels in the dataset (default)
custom_labels : list of str
list of labels from a file
"""
if labels is not None:
self.setEnabled(True)
self.chan_name = labels
self.table.blockSignals(True)
self.table.clearContents()
self.table.setRowCount(len(self.chan_name))
for i, label in enumerate(self.chan_name):
old_label = QTableWidgetItem(label)
old_label.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
if custom_labels is not None and i < len(custom_labels) and custom_labels[i]: # it's not empty string or None
label_txt = custom_labels[i]
else:
label_txt = label
new_label = QTableWidgetItem(label_txt)
self.table.setItem(i, 0, old_label)
self.table.setItem(i, 1, new_label)
self.table.blockSignals(False)
def setData(self, tableData):
self.setRowCount(len(tableData))
for i, rowData in enumerate(tableData):
for j, columnData in enumerate(rowData):
item = QTableWidgetItem(str(columnData))
item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
self.setItem(i, j, item)
def _showStringXrefs(self):
"""
Displays string references in a table
Optionally Shannon's misc.entropy as well
"""
# Retrieve some config values
show_misc_entropy = self.config.calculate_entropy
show_unique_s = self.config.display_unique_strings
self._console_output("Calculating string references...")
self.ba.calculate_strings_list()
s_ref_list = self.ba.get_string_references()
# Found any references at all?
nr_rows = len(s_ref_list)
if not nr_rows:
self._console_output("[!] No string references found", err = True)
return
if show_misc_entropy:
self.table.setColumnCount(3)
self.table.setHorizontalHeaderLabels(
("Address", "String", "Entropy"))
else:
self.table.setColumnCount(2)
self.table.setHorizontalHeaderLabels(("Address", "String"))
self.table_label.setText("String references in current function")
self.table.clearContents()
self.table.setRowCount(0)
# Fill the table
displayed_strings = []
idx = 0
for (addr, s) in s_ref_list:
if show_unique_s and s in displayed_strings:
continue
displayed_strings.append(s)
self.table.insertRow(idx)
addr_item = QTableWidgetItem("%08x" % addr)
addr_item.setFlags(addr_item.flags() ^ QtCore.Qt.ItemIsEditable)
string_item = QTableWidgetItem(s.decode('utf-8'))
string_item.setFlags(string_item.flags() ^ QtCore.Qt.ItemIsEditable)
self.table.setItem(idx, 0, addr_item)
self.table.setItem(idx, 1, string_item)
if show_misc_entropy:
misc_entropy_item = cw.NumQTableWidgetItem("%.4f" % misc.entropy(s))
self.table.setItem(idx, 2, misc_entropy_item)
idx += 1
def _add_task_to_table(self, row, task):
self._ignore_cell_changed = True
self.setItem(row, self._dict_header['id'],
QTableWidgetItem(str(task.identifier)))
self.item(row, self._dict_header['id']) \
.setTextAlignment(Qt.AlignCenter)
self.setItem(row, self._dict_header['name'],
QTableWidgetItem(str(task.name)))
combo = QComboBox()
items = [task_type for task_type in Task.task_types_names]
combo.addItems(items)
combo.setCurrentIndex(combo.findText(task.task_type))
combo.currentIndexChanged.connect(
lambda x: self._cell_changed(row, self._dict_header['task_type']))
self.setCellWidget(row, self._dict_header['task_type'], combo)
item = QTableWidgetItem(task.abort_on_miss and 'Yes' or 'No')
item.setFlags(
Qt.ItemIsUserCheckable | Qt.ItemIsEnabled | Qt.ItemIsSelectable)
item.setCheckState(task.abort_on_miss and Qt.Checked or Qt.Unchecked)
self.setItem(row, self._dict_header['abort'], item)
self.setItem(row, self._dict_header['list_activation_dates'],
QTableWidgetItem(
', '.join(map(str, task.list_activation_dates))))
self.item(row, self._dict_header['list_activation_dates']) \
.setTextAlignment(Qt.AlignRight | Qt.AlignVCenter)
for i in ['activation_date', 'period',
'deadline', 'wcet', 'base_cpi', 'n_instr', 'mix', 'acet',
'et_stddev', 'preemption_cost']:
self.setItem(row, self._dict_header[i],
QTableWidgetItem(str(task.__dict__[i])))
self.item(row, self._dict_header[i]) \
.setTextAlignment(Qt.AlignRight | Qt.AlignVCenter)
stack_item = QTableWidgetItem(str(task.stack_file))
stack_item.setFlags(stack_item.flags() ^ (Qt.ItemIsEditable))
self.setItem(row, self._dict_header['sdp'], stack_item)
combo = QComboBox()
combo.currentIndexChanged.connect(
lambda x: self._cell_changed(row, self._dict_header['followed']))
self.setCellWidget(row, self._dict_header['followed'], combo)
for col in range(len(self._custom_fields)):
key = self._custom_fields[col]
if key in task.data and task.data[key] is not None:
item = QTableWidgetItem(str(task.data[key]))
else:
item = QTableWidgetItem('')
item.setBackgroundColor(QColor.fromRgb(200, 255, 200))
self.setItem(row, col + len(self._header), item)
self._ignore_cell_changed = False
self._show_period(task, row)
def set_package(self, pac, i): # Add to Qt table item = QTableWidgetItem(pac['type']) item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled) self.wnd.packages.setItem(i, 0, item) self.wnd.packages.setItem(i, 1, QTableWidgetItem(pac['manufacturer'])) self.wnd.packages.setItem(i, 2, QTableWidgetItem(pac['datasheet']))
def setupItemsTable(self):
self.itemsTable = QTableWidget(len(self.items), 2)
for row, item in enumerate(self.items):
name = QTableWidgetItem(item)
name.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable)
self.itemsTable.setItem(row, 0, name)
quantity = QTableWidgetItem('1')
self.itemsTable.setItem(row, 1, quantity)
def tableWidgetMakeItem(self, text="", icon="", checkable=False, checked=False):
"""Creates a QTableWidgetItem with the given attributes."""
item = QTableWidgetItem(QIcon.fromTheme(icon), text)
if checkable:
item.setFlags(item.flags() | Qt.ItemIsUserCheckable)
item.setCheckState(Qt.Checked if checked else Qt.Unchecked)
else:
item.setFlags(item.flags() & ~Qt.ItemIsUserCheckable)
return item
def _showImportTrace(self):
"""
This is the GUI part of the PIN trace import functionality
"""
self._console_output("Importing PIN trace information from file...")
# Color for the basic blocks hit during the trace
col = QColorDialog.getColor()
if col.isValid():
# IDA works with BGR (annoying)
ida_color = misc.pyside_to_ida_color(col.name())
else:
# Probably closed the QColorDialog
self._console_output("[!] Problem getting color for trace. Aborting.")
return
try:
imported_info_dict = self.ie.ti.import_data(ida_color)
except Exception as e:
self._console_output("[!] Problem importing from file", err = True)
self._console_output(traceback.format_exc(), err = True)
return
self.table.setColumnCount(5)
self.table.setHorizontalHeaderLabels(
('Thread ID', 'From', 'To', 'From (name)', 'To (name)'))
self.table_label.setText("Imported information from PIN trace")
self.table.clearContents()
self.table.setRowCount(0)
# Fill with contents
# TODO: This could be better in a QTree or maybe adding
# a drop down menu to select the thread id...
idx = 0
for tid, call_list in imported_info_dict.iteritems():
self._console_output("Processing Thread ID %d" % tid)
for u_ea, v_ea in call_list:
self.table.insertRow(idx)
tid_item = QTableWidgetItem("%d" % tid)
u_item = QTableWidgetItem("%x" % u_ea)
u_item.setFlags(u_item.flags() ^ QtCore.Qt.ItemIsEditable)
v_item = QTableWidgetItem("%x" % v_ea)
v_item.setFlags(v_item.flags() ^ QtCore.Qt.ItemIsEditable)
from_item = QTableWidgetItem(misc.get_function_name(u_ea))
to_item = QTableWidgetItem(misc.get_function_name(v_ea))
self.table.setItem(idx, 0, tid_item)
self.table.setItem(idx, 1, u_item)
self.table.setItem(idx, 2, v_item)
self.table.setItem(idx, 3, from_item)
self.table.setItem(idx, 4, to_item)
idx += 1
def set_device(self, dev, i):
packages = self.devices[i]['dev_packages']
package_names = [x['name'] for x in packages]
item = QTableWidgetItem(', '.join(package_names))
item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
self.wnd.devices.setItem(i, 0, item)
self.wnd.devices.setItem(i, 1, QTableWidgetItem(dev['manufacturer']))
self.wnd.devices.setItem(i, 2, QTableWidgetItem(dev['description']))
self.wnd.devices.setItem(i, 3, QTableWidgetItem(dev['datasheet']))
def updateLocationsTable(self):
self.locationsTable.setUpdatesEnabled(False)
self.locationsTable.setRowCount(0)
for i in range(2):
if i == 0:
if self.scope() == QSettings.SystemScope:
continue
actualScope = QSettings.UserScope
else:
actualScope = QSettings.SystemScope
for j in range(2):
if j == 0:
if not self.application():
continue
actualApplication = self.application()
else:
actualApplication = ''
settings = QSettings(self.format(), actualScope,
self.organization(), actualApplication)
row = self.locationsTable.rowCount()
self.locationsTable.setRowCount(row + 1)
item0 = QTableWidgetItem()
item0.setText(settings.fileName())
item1 = QTableWidgetItem()
disable = not (settings.childKeys() or settings.childGroups())
if row == 0:
if settings.isWritable():
item1.setText("Read-write")
disable = False
else:
item1.setText("Read-only")
self.buttonBox.button(QDialogButtonBox.Ok).setDisabled(disable)
else:
item1.setText("Read-only fallback")
if disable:
item0.setFlags(item0.flags() & ~Qt.ItemIsEnabled)
item1.setFlags(item1.flags() & ~Qt.ItemIsEnabled)
self.locationsTable.setItem(row, 0, item0)
self.locationsTable.setItem(row, 1, item1)
self.locationsTable.setUpdatesEnabled(True)
def resetTotals(self):
self.totals.setHorizontalHeaderLabels(self.engine.getListPlayers())
self.totals.clearContents()
for row in range(len(self.engine.getEntryKinds())):
background = self.bgcolors[row]
for col in range(len(self.engine.getListPlayers())):
item = QTableWidgetItem()
item.setFlags(item.flags() ^ QtCore.Qt.ItemIsEditable)
item.setTextAlignment(
QtCore.Qt.AlignVCenter | QtCore.Qt.AlignCenter)
item.setBackground(QtGui.QBrush(QtGui.QColor(background)))
item.setText("0")
self.totals.setItem(row, col, item)
def update_table(self):
self.attribute_list()
self.ui.tableWidget.setRowCount(len(self.table))
self.ui.tableWidget.setColumnCount(len(self.table_header))
self.ui.tableWidget.setHorizontalHeaderLabels(self.table_header)
row = 0
for tup in self.table:
col = 0
for item in tup:
cellinfo = QTableWidgetItem(str(item))
cellinfo.setFlags(QtCore.Qt.ItemIsSelectable
| QtCore.Qt.ItemIsEnabled)
self.ui.tableWidget.setItem(row, col, cellinfo)
col += 1
row += 1
def fillTabWidget(self):
for i in range(self.tableWidget_selectedFiles.rowCount()):
self.tableWidget_selectedFiles.removeRow(0)
i = -1
for fileName in self.files:
itemFileName = QTableWidgetItem(fileName)
itemFileName.setTextAlignment(Qt.AlignHCenter)
itemFileName.setFlags(Qt.ItemIsSelectable)
itemFileName.setBackground(
QBrush(QColor(Qt.white), Qt.SolidPattern))
itemFileName.setForeground(
QBrush(QColor(Qt.black), Qt.SolidPattern))
i = i + 1
self.tableWidget_selectedFiles.insertRow(i)
self.tableWidget_selectedFiles.setItem(i, 0, itemFileName)
self.tableWidget_selectedFiles.resizeColumnToContents(0)
def get_table(self, list_name, table_name):
"""
Returns a QTableWidget showing an interaction parameter matrix for a given composition
:param list_name: str, name of component list of the corresponding table
:param table_name: str, name of table (could be K, alpha, A, B, C. epsilon, sigma, gamma dep on mixing rule)
:return: QTableWidget, table containing the correct parameters
"""
composition = self.component_lists[list_name]["Names"]
matrix_data = self.settings["Parameters"][list_name]["Coefficient matrices"][table_name]
size = len(composition)
table = QTableWidget(size, size)
# Insert coefficients into table
for row in range(size):
table.setVerticalHeaderItem(row, QTableWidgetItem(composition[row]))
for col in range(size):
table.setHorizontalHeaderItem(col, QTableWidgetItem(composition[col]))
for i in range(size):
for j in range(size):
if i == j:
item = QTableWidgetItem("-")
# Not editable
item.setFlags(QtCore.Qt.NoItemFlags)
else:
item = QTableWidgetItem(str(matrix_data[i][j]))
item.setTextAlignment(QtCore.Qt.AlignCenter)
table.blockSignals(True)
table.setItem(i, j, item)
table.blockSignals(False)
if table_name in ["VDW K", "CPA K", "CPA Epsilon", "SAFT-VR Mie Epsilon",
"SAFT-VR Mie Sigma", "SAFT-VR Mie Gamma"]:
# Matrix is symmetric, so these items can't be edited
if i >= j:
item.setFlags(QtCore.Qt.NoItemFlags)
header = table.horizontalHeader()
header.setSectionResizeMode(QHeaderView.ResizeToContents)
return table
def redraw_output_tw(self):
# If the frequencies haven't been set yet just don't try to do anything
if not self.frequencies_cm1:
return
self.output_tw.blockSignals(True)
for i, (f, sigma, intensity) in enumerate(
zip(self.frequencies_cm1, self.sigmas_cm1, self.intensities)):
# Sigma and check / unchecked column
items = []
itemFlags = []
item = QTableWidgetItem('{0:.1f}'.format(sigma))
if self.modes_selected[i]:
item.setCheckState(Qt.Checked)
itemFlags.append(item.flags() & Qt.NoItemFlags
| Qt.ItemIsUserCheckable | Qt.ItemIsEnabled
| Qt.ItemIsSelectable | Qt.ItemIsEditable)
otherFlags = item.flags() & Qt.NoItemFlags | Qt.ItemIsEnabled
else:
#itemFlags.append( item.flags() | Qt.ItemIsUserCheckable | Qt.ItemIsEnabled & ~Qt.ItemIsSelectable & ~Qt.ItemIsEditable )
itemFlags.append(item.flags() & Qt.NoItemFlags
| Qt.ItemIsUserCheckable | Qt.ItemIsEnabled)
item.setCheckState(Qt.Unchecked)
otherFlags = item.flags() & Qt.NoItemFlags
items.append(item)
# Frequency column cm-1
items.append(QTableWidgetItem('{0:.4f}'.format(f)))
itemFlags.append(otherFlags)
# Intensity column Debye2/Angs2/amu
items.append(QTableWidgetItem('{0:.4f}'.format(intensity)))
itemFlags.append(otherFlags)
# Integrated molar absorption L/mole/cm/cm
items.append(QTableWidgetItem('{0:.2f}'.format(intensity *
4225.6)))
itemFlags.append(otherFlags)
# Maximum extinction L/mole/cm
items.append(
QTableWidgetItem('{0:.2f}'.format(2 * intensity * 4225.6 /
self.sigmas_cm1[i] / PI)))
itemFlags.append(otherFlags)
for j, (item, flag) in enumerate(zip(items, itemFlags)):
item.setFlags(flag)
item.setTextAlignment(Qt.AlignHCenter | Qt.AlignVCenter)
self.output_tw.setItem(i, j, item)
# Release the block on signals for the frequency output table
self.output_tw.resizeColumnsToContents()
self.output_tw.blockSignals(False)
QCoreApplication.processEvents()
def __setFilter__(self):
self.insertRow(0)
for idx, header in enumerate(self.columns):
if header in ['번호', '설정']:
item = QTableWidgetItem('')
item.setFlags(Qt.ItemIsEditable)
self.setItem(0, idx, item)
elif header == '개월수':
items = self.dataFrame[header].drop_duplicates().tolist()
i = 0
p = []
for item in items:
try:
items[i] = int(item)
except:
p.append(i)
i += 1
p.reverse()
for i in p:
items.pop(i)
items.sort()
items = ['전체'] + [str(item) for item in items]
CbxFilterInTable(idx, items, self)
elif header == '사업비':
items = self.dataFrame[header].drop_duplicates().tolist()
i = 0
p = []
for item in items:
item = item.replace(',', '')
try:
items[i] = int(item)
except:
p.append(i)
i += 1
p.reverse()
for i in p:
items.pop(i)
items.sort()
items = ['전체'] + [format(item, ',') for item in items]
CbxFilterInTable(idx, items, self)
else:
items = self.dataFrame[header].drop_duplicates().tolist()
if '' in items:
items.remove('')
items.sort()
items = ['전체'] + items
CbxFilterInTable(idx, items, self)
def addRequestedCycleToTable(self, requestedCycle):
rowPos = self.tblAddCycle.rowCount()
self.tblAddCycle.insertRow(rowPos)
button = QPushButton(self.tblAddCycle)
button.setGeometry(QtCore.QRect(60, 10, 75, 23))
button.setObjectName("button")
button.setText("Remove ")
button.clicked.connect(self.removeCurrentRow)
checkbox = QCheckBox(self.tblAddCycle)
checkbox.setGeometry(QtCore.QRect(60, 10, 75, 23))
checkbox.setObjectName("checkbox")
if requestedCycle.isOptimized == 1:
checkbox.setChecked(True)
checkbox.clicked.connect(self.optimizationChanged)
itemId = QTableWidgetItem(str(requestedCycle.id))
itemId.setFlags(itemId.flags() & ~QtCore.Qt.ItemIsEditable)
self.tblAddCycle.setItem(rowPos,
Ui_MainWindowSub.TBL_ADDCYCLE_COL_IDX_ID,
itemId)
itemComponent = QTableWidgetItem(requestedCycle.componentName)
itemComponent.setFlags(itemComponent.flags()
& ~QtCore.Qt.ItemIsEditable)
self.tblAddCycle.setItem(
rowPos, Ui_MainWindowSub.TBL_ADDCYCLE_COL_IDX_COMPONENT,
itemComponent)
itemCycle = QTableWidgetItem(requestedCycle.cycleName)
itemCycle.setFlags(itemCycle.flags() & ~QtCore.Qt.ItemIsEditable)
self.tblAddCycle.setItem(rowPos,
Ui_MainWindowSub.TBL_ADDCYCLE_COL_IDX_CYCLE,
itemCycle)
itemPhase = QTableWidgetItem(requestedCycle.name)
itemPhase.setFlags(itemPhase.flags() & ~QtCore.Qt.ItemIsEditable)
self.tblAddCycle.setItem(
rowPos, Ui_MainWindowSub.TBL_ADDCYCLE_COL_IDX_CYCLEPHASE,
itemPhase)
itemStart = QTableWidgetItem(requestedCycle.getStartDateStr())
self.tblAddCycle.setItem(rowPos,
Ui_MainWindowSub.TBL_ADDCYCLE_COL_IDX_STARTDT,
itemStart)
itemEnd = QTableWidgetItem(requestedCycle.getEndDateStr())
self.tblAddCycle.setItem(rowPos,
Ui_MainWindowSub.TBL_ADDCYCLE_COL_IDX_ENDDT,
itemEnd)
self.tblAddCycle.setCellWidget(
rowPos, Ui_MainWindowSub.TBL_ADDCYCLE_COL_IDX_ISOPTIMIZED,
checkbox)
self.tblAddCycle.setCellWidget(
rowPos, Ui_MainWindowSub.TBL_ADDCYCLE_COL_IDX_REMOVE, button)
def show_best_algorithm(self):
self.best_algo_name = None
self.best_param_names = None
self.best_params = None
self.best_score = -float('Inf')
self.best_is_fs = False
for name, results in self.params.results['algorithms'].items():
grid_scores = results['grid_scores']
for params, score, std in grid_scores:
if score > self.best_score:
self.best_algo_name = name
self.best_param_names = list(params.keys())
self.best_params = list(params.values())
self.best_score = score
if self.params.results_fs is not None:
for name, results in self.params.results_fs['algorithms'].items():
grid_scores = results['grid_scores']
for params, score, std in grid_scores:
if score > self.best_score:
self.best_algo_name = name
self.best_param_names = list(params.keys())
self.best_params = list(params.values())
self.best_score = score
self.best_is_fs = True
table1 = NonScrollTable(self.inner)
table1.setRowCount(1)
table1.setColumnCount(len(self.best_params) + 3)
table1.setHorizontalHeaderLabels([
' ' + c + ' ' for c in ['Algorithm', ' Feature selection '] +
self.best_param_names + ['Score']
])
item = QTableWidgetItem(self.best_algo_name)
item.setFlags(Qt.ItemIsEnabled)
table1.setItem(0, 0, item)
if self.best_is_fs:
item = QTableWidgetItem('Yes')
else:
item = QTableWidgetItem('No')
item.setFlags(Qt.ItemIsEnabled)
table1.setItem(0, 1, item)
for c, v in enumerate(self.best_params):
item = QTableWidgetItem(str(round(v, 4)))
item.setFlags(Qt.ItemIsEnabled)
table1.setItem(0, c + 2, item)
item = QTableWidgetItem(str(round(self.best_score, 4)))
item.setFlags(Qt.ItemIsEnabled)
table1.setItem(0, len(self.best_params) + 2, item)
table1.setNonScroll()
self.vbox.addWidget(table1)
def activateParamCell(self, row, paramNum, text, value=None):
col_index = self.col_index
if paramNum == 1:
col = col_index['p1']
else: # assume param 2
col = col_index['p2']
self.activateCell(row, col)
# clear and activate
nameMask = ~Qt.ItemIsEnabled
pname = QTableWidgetItem(text)
pname.setBackground(Qt.white)
pname.setForeground(Qt.black)
flags = pname.flags()
pname.setFlags(flags & nameMask)
# add 2-cell table
cellTable = self.cellWidget(row, col)
if isinstance(cellTable, QComboBox): # combo from file selection
self.removeCellWidget(row, col)
cellTable = None
if cellTable is None:
cellTable = QTableWidget(self)
self.setCellWidget(row, col, cellTable)
cellTable.clear()
cellTable.setRowCount(1)
cellTable.setColumnCount(2)
cellTable.horizontalHeader().setVisible(False)
cellTable.verticalHeader().setVisible(False)
cellTable.setProperty('row', row)
cellTable.setProperty('col', col)
cellTable.setItem(0, 0, pname)
if value is not None:
pval = QTableWidgetItem(str(value))
cellTable.setItem(0, 1, pval)
if self.viewOnly:
flags = pval.flags()
pval.setFlags(flags & ~Qt.ItemIsEnabled)
pval.setForeground(Qt.black)
cellTable.setColumnWidth(0, self.labelWidth)
cellTable.setColumnWidth(1, self.paramWidth)
cellTable.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
cellTable.cellChanged.connect(self.paramChange)
cellTable.setEditTriggers(QAbstractItemView.AllEditTriggers) # Allow single click to edit
return cellTable
def setInfluencesTable(self):
influences = list(self.session.query(DetectorInfluence))
if self.tblInfluences:
self.tblInfluences.clear()
self.tblInfluences.setColumnCount(NUM_COL)
self.tblInfluences.setRowCount(len(influences))
self.tblInfluences.setHorizontalHeaderLabels([
'Name', 'Infl_0\n(offset)', 'Drift\n(Infl_0)', 'Infl_1\n(linear)',
'Drift\n(Infl_1)', 'Infl_2\n(quadratic)', 'Drift\n(Infl_2)',
'Fixed Smear\n(Eres, keV)', 'Drift\n(Fixed Smear)',
'Linear Smear\n(Eres, %)', 'Drift\n(Linear Smear)'
])
self.tblInfluences.setSelectionBehavior(QAbstractItemView.SelectRows)
self.tblInfluences.horizontalHeader().setSectionResizeMode(
0, QHeaderView.Stretch)
row = 0
if self.modify_flag:
union = Qt.ItemIsSelectable | Qt.ItemIsEditable | Qt.ItemIsEnabled
else:
union = Qt.ItemIsSelectable | Qt.ItemIsEnabled
for influence in influences:
item = QTableWidgetItem(QTableWidgetItem(influence.influence_name))
item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
self.tblInfluences.setItem(row, NAME, item)
for (col, infl) in zip(COLUMNS[1:], [
str(influence.infl_0),
str(influence.degrade_infl0),
str(influence.infl_1),
str(influence.degrade_infl1),
str(influence.infl_2),
str(influence.degrade_infl2),
str(influence.fixed_smear),
str(influence.degrade_f_smear),
str(influence.linear_smear),
str(influence.degrade_l_smear)
]):
item = QTableWidgetItem(infl)
item.setFlags(union)
self.tblInfluences.setItem(row, col, item)
row += 1
self.tblInfluences.setColumnWidth(INFL_2, 80)
self.tblInfluences.setColumnWidth(FIX_SMEAR, 90)
self.tblInfluences.setColumnWidth(DEGRADE_FIX_SMEAR, 90)
self.tblInfluences.setColumnWidth(LIN_SMEAR, 90)
self.tblInfluences.setColumnWidth(DEGRADE_LIN_SMEAR, 90)
class PlotLabelsTable(TableWidget):
def __init__(self):
super().__init__()
self.horizontalHeader().setResizeMode(QHeaderView.ResizeToContents)
self.setSizeAdjustPolicy(self.AdjustToContents)
self.setColumnCount(2)
self.setRowCount(2)
self.setHorizontalHeaderLabels(['X label', 'Y label'])
self.setVerticalHeaderLabels(['Source', 'Parameter'])
self.sourceX = QTableWidgetItem('Energy (eV)')
self.sourceY = QTableWidgetItem('Intensity (a.u.)')
self.paramX = QTableWidgetItem('Pressure (GPa)')
self.paramY = QTableWidgetItem('')
self.setItem(0, 0, self.sourceX)
self.setItem(0, 1, self.sourceY)
self.setItem(1, 0, self.paramX)
self.setItem(1, 1, self.paramY)
self.setParams([])
self.itemChanged.connect(self.edited)
def setParams(self, params):
self.params = params
self.edited.block()
flags = self.paramY.flags()
if len(params) == 0:
flags &= ~Qt.ItemIsEnabled
self.paramY.setText('')
else:
flags |= Qt.ItemIsEnabled
labels = list(set([p.plotLabel for p in self.params]))
label = labels[0] if len(labels) == 1 else None
self.paramY.setText(label or '')
self.paramY.setFlags(flags)
self.edited.unblock()
@blockable
def edited(self, item):
if item == self.paramY and len(self.params) > 0:
for p in self.params:
p.plotLabel = self.paramY.text()
def _dialog_accepted(self, dialog):
"""
Called when the add server dialog is accepted by the user.
:param dialog: the add server dialog
"""
host, port = dialog.get_result()
Server = namedtuple('Server', ['host', 'port'])
server = Server(host, port)
self._plugin.core.servers.append(server)
rowCount = self._serversTable.rowCount()
self._serversTable.insertRow(rowCount)
newServer = QTableWidgetItem('%s:%d' % (server.host, server.port))
newServer.setData(Qt.UserRole, server)
newServer.setFlags(newServer.flags() & ~Qt.ItemIsEditable)
self._serversTable.setItem(rowCount, 0, newServer)
self.update()
def search(self):
all_competitors = db.get_all_competitors_experts(db.user_data[9], 0, 2)
competitor = all_competitors[self.CompetitorComboBox.currentIndex()][0]
marks = db.show_marks(competitor)
self.ResultsWidget.setRowCount(len(marks))
self.ResultsWidget.setColumnCount(2)
self.ResultsWidget.setHorizontalHeaderLabels(head_module)
for i in range(len(marks)):
for j in range(2):
if j == 0:
info = QTableWidgetItem('Модуль ' + str(marks[i][j]))
else:
info = QTableWidgetItem(str(marks[i][j]))
info.setFlags(QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled)
self.ResultsWidget.setItem(i, j, info)
header = self.ResultsWidget.horizontalHeader()
header.setSectionResizeMode(QtWidgets.QHeaderView.ResizeToContents)
def updateVersions(self):
if len(self.env.installedVersion) == 0:
self.uninstallVersion.setEnabled(False)
else:
self.uninstallVersion.setEnabled(True)
while (self.rowCount() > 0):
self.removeRow(0)
count = 0
for i in self.env.installedVersion:
idItem = QTableWidgetItem(i["id"])
idItem.setFlags(idItem.flags() ^ Qt.ItemIsEditable)
typeItem = QTableWidgetItem(i["type"])
typeItem.setFlags(typeItem.flags() ^ Qt.ItemIsEditable)
self.insertRow(count)
self.setItem(count, 0, idItem)
self.setItem(count, 1, typeItem)
count += 1
def table_init(self):
header = self.tableWidget.horizontalHeader()
header.setSectionResizeMode(0, QtWidgets.QHeaderView.Stretch)
header.setSectionResizeMode(1, QtWidgets.QHeaderView.Stretch)
header.setSectionResizeMode(2, QtWidgets.QHeaderView.Stretch)
header.setSectionResizeMode(3, QtWidgets.QHeaderView.Stretch)
wishes = get_all()
self.tableWidget.setRowCount(len(wishes))
self.tableWidget.setHorizontalHeaderLabels(
["name", "price", "link", "comment"])
for row, wish in enumerate(wishes):
for col in range(len(wish)):
item = QTableWidgetItem()
item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
item.setText(wish[col])
self.tableWidget.setItem(row, col, item)
def setdetail(self, hlist, list):
self.cur.execute("begin transaction;")
self.detail.setColumnCount(len(hlist))
self.detail.setHorizontalHeaderLabels(hlist)
self.detail.setRowCount(len(list))
self.tablelist = []
for i, item in enumerate(list):
line = []
for j, jtem in enumerate(item):
if jtem == None:
break
line.append(str(jtem))
newitem = QTableWidgetItem(str(jtem))
if ((j == 0) and (self.type != 2)):
newitem.setFlags(QtCore.Qt.ItemIsEnabled)
self.detail.setItem(i, j, newitem)
self.tablelist.append(line)
def __setData__(self):
for row, lst in enumerate(self.dataFrame.values):
self.insertRow(row + 1)
self.setRowHeight(row + 1, 40)
for col, data in enumerate(lst):
item = QTableWidgetItem(str(data))
item.setFlags(Qt.ItemIsEditable)
self.setItem(row + 1, col, item)
if col != 1:
item.setTextAlignment(Qt.AlignCenter)
if col == self.columnCount() - 1:
BtnTableDBBusiness(data, self, row + 1, col, self.year)
self.resizeColumnsToContents()
self.hideColumn(0)
self.setColumnWidth(2, 65)
self.setColumnWidth(4, 120)
self.setColumnWidth(5, 120)
def setup_table(self, show_all=False):
"""Setup table parameters
Keyword arguments:
show_all (bool): Filters all or only running containers."""
self._get_data(show_all)
self.setColumnCount(self.columns.__len__())
self.setRowCount(self.table_data.__len__())
self.setHorizontalHeaderLabels(self.columns)
for row in range(0, self.table_data.__len__()):
for i in range(0, self.table_data[row].__len__()):
item = QTableWidgetItem(self.table_data[row][i])
item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable)
self.setItem(row, i, item)
self.setSelectionBehavior(QAbstractItemView.SelectRows)
def addRow(self, name, amp):
self.table.insertRow(self.n)
self.table.setItem(self.n, 0, QTableWidgetItem(name))
self.table.setItem(self.n, 1, QTableWidgetItem(amp.stype))
self.table.setItem(
self.n, 2,
QTableWidgetItem(str(amp.actor.GetProperty().GetColor())))
self.table.setItem(
self.n, 3,
QTableWidgetItem(str(amp.actor.GetProperty().GetOpacity())))
chkBoxItem = QTableWidgetItem()
chkBoxItem.setTextAlignment(Qt.AlignCenter)
chkBoxItem.setFlags(Qt.ItemIsUserCheckable | Qt.ItemIsEnabled)
chkBoxItem.setCheckState(Qt.Checked)
self.table.setItem(self.n, 4, chkBoxItem)
self.n = self.table.rowCount()
def load_table(self):
self.coffee_table.setRowCount(0)
create_database_if_need()
con = sqlite3.connect(DATABASE_PATH)
cur = con.cursor()
data = cur.execute('SELECT * FROM coffee').fetchall()
self.coffee_table.setRowCount(len(data))
for i, row in enumerate(data):
for j in range(len(row)):
if j == GROUND_OR_GRAINS_NUMBER:
value = GROUND_OR_GRAINS[row[j]]
else:
value = str(row[j])
item = QTableWidgetItem(value)
item.setFlags(Qt.ItemIsEnabled)
self.coffee_table.setItem(i, j, item)
con.close()
def __init__(self, layer, parent=None):
super(LayerColortableDialog, self).__init__(parent=parent)
h = QHBoxLayout(self)
t = QTableWidget(self)
t.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
t.setRowCount(len(layer._colorTable))
t.setColumnCount(1)
t.setVerticalHeaderLabels(["%d" % i for i in range(len(layer._colorTable))])
for i in range(len(layer._colorTable)):
item = QTableWidgetItem(" ")
t.setItem(i, 0, item)
item.setBackgroundColor(QColor.fromRgba(layer._colorTable[i]))
item.setFlags(Qt.ItemIsSelectable)
h.addWidget(t)
def search_click(self):
all_competence = db.get_all_competences()
competence = all_competence[self.CompetenceComboBox.currentIndex()].split('. ')
data = db.get_volunteers(competence[0])
size_str = 0
if len(data) != 0:
size_str = len(data[0])
self.VolunteersTable.setRowCount(len(data))
self.VolunteersTable.setColumnCount(size_str)
self.VolunteersTable.setHorizontalHeaderLabels(head_vol)
for i in range(len(data)):
for j in range(size_str):
info = QTableWidgetItem(str(data[i][j]))
info.setFlags(QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled)
self.VolunteersTable.setItem(i, j, info)
header = self.VolunteersTable.horizontalHeader()
header.setSectionResizeMode(QtWidgets.QHeaderView.ResizeToContents)
def Insert(self):
row = self.table.rowCount()
if row == 0:
number = 1
elif row != 0:
number = int(self.table.item(row - 1, 1).text()) + 1
item = QTableWidgetItem(str(number))
item.setFlags(Qt.ItemIsEditable)
item.setTextAlignment(Qt.AlignCenter)
self.table.insertRow(row)
self.table.setRowHeight(row, 50)
self.__checkbox__(self.table, row, 0)
self.table.setItem(row, 1, item)
item = QTableWidgetItem('')
item.setTextAlignment(Qt.AlignCenter)
self.table.setItem(row, 2, item)
self.__connector_mso__.Insert(number)
def row_add(self):
i = self.tableWidget.rowCount()
self.tableWidget.insertRow(i)
vheader = self.tableWidget.verticalHeader()
vheader.setSectionResizeMode(i, QHeaderView.ResizeToContents)
combobox = QComboBox()
combobox.addItem("Any")
combobox.addItem("Source")
combobox.addItem("Destination")
self.tableWidget.setCellWidget(i, 2, combobox)
item = QTableWidgetItem()
brush = QBrush(QColor(0, 0, 0))
brush.setStyle(Qt.Dense4Pattern)
self.tableWidget.setItem(i, 3, item)
item.setFlags(Qt.ItemIsEnabled)
item.setBackground(brush)
def setData(self, rawData: DataFrame ):
table = self.ui.columnsTable
headerValues = rawData.columns.values
rowsNum = rawData.shape[0]
colsNum = rawData.shape[1]
table.setRowCount( colsNum )
for i in range(0, colsNum):
headerVal = headerValues[i]
headerText = ""
if isinstance(headerVal, tuple):
headerText = headerVal[0]
else:
headerText = headerVal
dataExample = None
if rowsNum > 0:
dataExample = rawData.iloc[0, i]
## display header
dataItem = QTableWidgetItem()
checkedState = QtChecked
colVisible = self.isColumnVisible( i )
if colVisible is not None and colVisible is False:
checkedState = QtUnchecked
dataItem.setCheckState( checkedState )
userText = self.getHeaderText( i )
if userText is None:
userText = headerText
dataItem.setData( QtDisplayRole, userText )
table.setItem( i, 0, dataItem )
## data header
dataItem = QTableWidgetItem()
dataItem.setFlags( dataItem.flags() ^ QtItemIsEditable )
dataItem.setData( QtDisplayRole, headerText )
table.setItem( i, 1, dataItem )
## data preview
dataItem = QTableWidgetItem()
dataItem.setFlags( dataItem.flags() ^ QtItemIsEditable )
dataItem.setData( QtDisplayRole, dataExample )
table.setItem( i, 2, dataItem )
table.resizeColumnsToContents()
table.update()
def showFiles(self, files):
for fn in files:
file = QFile(self.currentDir.absoluteFilePath(fn))
size = QFileInfo(file).size()
fileNameItem = QTableWidgetItem(fn)
fileNameItem.setFlags(fileNameItem.flags() ^ Qt.ItemIsEditable)
sizeItem = QTableWidgetItem("%d KB" % (int((size + 1023) / 1024)))
sizeItem.setTextAlignment(Qt.AlignVCenter | Qt.AlignRight)
sizeItem.setFlags(sizeItem.flags() ^ Qt.ItemIsEditable)
row = self.filesTable.rowCount()
self.filesTable.insertRow(row)
self.filesTable.setItem(row, 0, fileNameItem)
self.filesTable.setItem(row, 1, sizeItem)
self.filesFoundLabel.setText("%d file(s) found (Double click on a file to open it)" % len(files))
def fill_table_widget(self, response):
try:
connected_worlds_ids = [world["id"] for world in response["login_connected_worlds"]]
worlds = [world for world in response["all_available_worlds"] if world["id"] in connected_worlds_ids]
except:
worlds = []
self.servers_table.setRowCount(len(worlds))
for index in range(len(worlds)):
select = QTableWidgetItem()
select.setFlags(
QtCore.Qt.ItemIsEditable | QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled | QtCore.Qt.ItemIsUserCheckable)
select.setCheckState(QtCore.Qt.Unchecked)
# select.server_name = account_thread
self.servers_table.setItem(index, 0, select)
self.servers_table.setItem(index, 1, text_to_widget(worlds[index]["name"], center=True))
self.servers_table.setItem(index, 2, text_to_widget(worlds[index]["id"], center=True))
def updateProfiles(self):
while (self.rowCount() > 0):
self.removeRow(0)
count = 0
for i in self.env.profiles:
nameItem = QTableWidgetItem(i.name)
nameItem.setFlags(nameItem.flags() ^ Qt.ItemIsEditable)
if i.useLatestVersion:
versionItem = QTableWidgetItem(
self.env.translate("profiletab.latestVersion"))
else:
versionItem = QTableWidgetItem(i.version)
versionItem.setFlags(versionItem.flags() ^ Qt.ItemIsEditable)
self.insertRow(count)
self.setItem(count, 0, nameItem)
self.setItem(count, 1, versionItem)
count += 1
def update_sqlite(db_table, items):
"""Updates the supplied QTableWidget - db_table - with items."""
db_table.setRowCount(len(items))
for i in range(0, len(items)):
chkBoxItem = QTableWidgetItem()
chkBoxItem.setFlags(QtCore.Qt.ItemIsUserCheckable
| QtCore.Qt.ItemIsEnabled)
chkBoxItem.setCheckState(QtCore.Qt.Checked)
db_table.setItem(i, 0, chkBoxItem)
db_table.setItem(i, 1, QTableWidgetItem(str(items[i]['PMC'])))
db_table.setItem(i, 2, QTableWidgetItem(items[i]['TITLE']))
db_table.setItem(i, 3, QTableWidgetItem(items[i]['DATE']))
db_table.setItem(i, 4, QTableWidgetItem(items[i]['AUTHORS']))
db_table.setItem(i, 5, QTableWidgetItem(items[i]['JOURNAL']))
db_table.setItem(i, 6, QTableWidgetItem(items[i]['DOI']))
db_table.sortItems(5, QtCore.Qt.DescendingOrder)
return db_table
def widgetInsideTable(self):
# ===== Button view pass inside table =====
# viewPassbtn=QPushButton()
# viewPassbtn.setFixedHeight(self.size_of_btn)
# viewPassbtn.setFixedWidth(self.size_of_btn)
# viewPassbtn.setIcon(QIcon(self._dirIcon+'icons8-eye-1.png'))
# ====== CheckBox ======
checkBox = QTableWidgetItem()
checkBox.setIcon(QIcon(self._dirIcon + 'icons8-checkbox-0.png'))
checkBox.setFlags(Qt.ItemIsEnabled)
ItemViewPass = QTableWidgetItem()
ItemViewPass.setIcon(QIcon(self._dirIcon + 'icons8-eye-1.png'))
ItemViewPass.setFlags(Qt.ItemIsEnabled)
self.table.setIconSize(QSize(self.size, self.size))
return checkBox, ItemViewPass
def managing_chempionships_click(self):
self.ManageChempionshipsFrame.setHidden(False)
self.MainFrame.setHidden(True)
chempionships = db.get_all_championship()
num_column = 0
if (chempionships[0] != 0):
num_column = len(chempionships[0])
self.ChempionshipsTable.setRowCount(len(chempionships))
self.ChempionshipsTable.setColumnCount(num_column)
self.ChempionshipsTable.setHorizontalHeaderLabels(head_chemp)
for i in range(len(chempionships)):
for j in range(num_column):
info = QTableWidgetItem(str(chempionships[i][j]))
info.setFlags(QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled)
self.ChempionshipsTable.setItem(i, j, info)
header = self.ChempionshipsTable.horizontalHeader()
header.setSectionResizeMode(QtWidgets.QHeaderView.ResizeToContents)
