def __init__(self, input_list, parent=None):
super(InputTable, self).__init__(parent)
self.setColumnCount(7)
header = ("Tag", "Id", "Name", "Class", "innerHTML", "Original Value", "Value")
self.setHorizontalHeaderLabels(header)
self.setRowCount(len(input_list))
self.horizontalHeader().setSectionResizeMode(1)
self.rowcount = 0
# self.setStyleSheet("font-size:30px;")
for inp in input_list:
itemtype = QTableWidgetItem(inp["tag"])
itemid = QTableWidgetItem(inp["id"])
itemname = QTableWidgetItem(inp["name"])
itemhtml = QTableWidgetItem(inp["innerHTML"])
item_class = QTableWidgetItem(normalize_string(inp["class"]))
item_original_value = QTableWidgetItem(inp["original_value"])
itemtype.setFlags(itemtype.flags() & ~PyQt5.QtCore.Qt.ItemIsEditable & ~PyQt5.QtCore.Qt.TextEditable)
itemid.setFlags(itemtype.flags() & ~PyQt5.QtCore.Qt.ItemIsEditable & ~PyQt5.QtCore.Qt.TextEditable)
itemname.setFlags(itemtype.flags() & ~PyQt5.QtCore.Qt.ItemIsEditable & ~PyQt5.QtCore.Qt.TextEditable)
self.setItem(self.rowcount, 0, itemtype)
self.setItem(self.rowcount, 1, itemid)
self.setItem(self.rowcount, 2, itemname)
self.setItem(self.rowcount, 3, item_class)
self.setItem(self.rowcount, 4, itemhtml)
self.setItem(self.rowcount, 5, item_original_value)
self.setItem(self.rowcount, 6, QTableWidgetItem(inp["value"]))
self.rowcount += 1
def init_table(self):
# Load tables list
self.table.setColumnCount(3)
self.table.setRowCount(0)
self.table.setHorizontalHeaderLabels(
["Field name", "Field type", "Value"])
self.column_names = PQLE.execute(
f"PRAGMA table_info({self.table_name})")
self.table.setAttribute(QtCore.Qt.WA_MacShowFocusRect, False)
self.header = self.table.horizontalHeader()
for i in range(len(self.header)):
self.header.setSectionResizeMode(i, QtWidgets.QHeaderView.Stretch)
for i, row in enumerate(self.column_names):
self.table.setRowCount(self.table.rowCount() + 1)
item_table = QTableWidgetItem(self.column_names[i][1])
item_table.setFlags(item_table.flags() ^ QtCore.Qt.ItemIsEditable)
self.table.setItem(i, 0, item_table)
item_table = QTableWidgetItem(self.column_names[i][2])
item_table.setFlags(item_table.flags() ^ QtCore.Qt.ItemIsEditable)
self.table.setItem(i, 1, item_table)
def add_to_param_list(self):
"""Adds the selected columns to the list of fields that should be
treated as "special" in the database both to work as a parameter that
could be evaluated and as a layer that is added to the canvas"""
row_count = self.nbr_selected_attr
self.CGF.TWSelected.setColumnCount(2)
self.CGF.TWSelected.setColumnWidth(0, 75)
self.CGF.TWSelected.setColumnWidth(1, 25)
items_to_add = []
existing_values = []
if row_count != 0:
for i in range(row_count):
existing_values.append(self.CGF.TWSelected.item(i, 0).text())
for i, item in enumerate(self.CGF.TWColumnNames.selectedItems()):
if item.column() == 0 and item.text() not in existing_values:
items_to_add.append(item.text())
for i, item in enumerate(items_to_add, self.nbr_selected_attr):
row_count += 1
self.CGF.TWSelected.setRowCount(row_count)
item1 = QTableWidgetItem(item)
item1.setFlags(xor(item1.flags(), QtCore.Qt.ItemIsEditable))
item2 = QTableWidgetItem('[{i}]'.format(i=i))
item2.setFlags(xor(item2.flags(), QtCore.Qt.ItemIsEditable))
self.CGF.TWSelected.setItem(i, 0, item1)
self.CGF.TWSelected.setItem(i, 1, item2)
self.nbr_selected_attr = row_count
def renderDataset(self):
"""
Open a json formatted dataset specification from a file and display
the contained information.
"""
self.setRowCount(self.__dataset.getClassesCount())
i = 0
unknownClassBackground = QColor(250, 120, 100)
for c in self.__dataset.getClasses():
classId = QTableWidgetItem(str(c.id))
# disable editing of the class id
# this is done for all cells within this row (and for every row)
classId.setFlags(classId.flags() ^ Qt.ItemIsEditable)
preview = QTableWidgetItem()
# c.thumbnailPath contains a filename, passing this value to the
# constructor of QPixmap automatically loads an image
preview.setData(Qt.DecorationRole, QPixmap(c.thumbnailPath))
preview.setFlags(preview.flags() ^ Qt.ItemIsEditable)
name = QTableWidgetItem(c.name)
name.setFlags(name.flags() ^ Qt.ItemIsEditable)
if not c.known:
classId.setBackground(unknownClassBackground)
preview.setBackground(unknownClassBackground)
name.setBackground(unknownClassBackground)
self.setItem(i, 0, classId)
self.setItem(i, 1, preview)
self.setItem(i, 2, name)
# make sure the row is as large as the image within
# (we just assume a height of 64 pixels)
self.setRowHeight(i, 64)
i += 1
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 initializePage(self): #pylint: disable=invalid-name
"""Initialize page fields."""
self.race_table_widget.clearContents()
self.race_table_widget.setRowCount(len(self.wizard().race_list))
# Qt warns us that inserting items while sorting is enabled will mess with the insertion
# order, so disable sorting before populating the list, and then re-enable sorting
# afterwards.
self.race_table_widget.setSortingEnabled(False)
for row, race in enumerate(self.wizard().race_list):
# Make our name item (non-editable).
name_item = QTableWidgetItem(race['name'])
name_item.setFlags(name_item.flags() ^ Qt.ItemIsEditable)
name_item.setData(Qt.UserRole, race)
self.race_table_widget.setItem(row, self.NAME_COLUMN, name_item)
# Make our date item (non-editable).
date_item = QTableWidgetItem(race['date'])
date_item.setFlags(date_item.flags() ^ Qt.ItemIsEditable)
date_item.setData(Qt.UserRole, race)
self.race_table_widget.setItem(row, self.DATE_COLUMN, date_item)
self.race_table_widget.setSortingEnabled(True)
self.race_table_widget.sortByColumn(self.DATE_COLUMN,
Qt.DescendingOrder)
self.race_table_widget.horizontalHeader().resizeSections(
QHeaderView.ResizeToContents)
def searchPushButtonClickedSlot(self):
"""槽函数：业务表管理>点击搜索"""
for i in reversed(range(self.listTableWidget.rowCount())): # 清空表格
self.listTableWidget.removeRow(i)
info_list = self.__dm.get_my_tables_info(
self.selectListWidget.currentItem().text())
for table_info in info_list:
table_name, table_type, create_time = table_info # 每个元素为一个元组(表名,类型,秒级时间戳)
if self.searchLineEdit.text() in table_name: # 将符合条件的表格显示出来
rowNumber = self.listTableWidget.rowCount()
self.listTableWidget.insertRow(rowNumber)
nameItem = TableNamePushButton(table_name)
nameItem.doubleClickSignal.connect(
self.tableNameDoubleClickedSlot)
self.listTableWidget.setCellWidget(rowNumber, 0, nameItem)
typeItem = QTableWidgetItem(table_type)
typeItem.setTextAlignment(Qt.AlignCenter | Qt.AlignVCenter)
typeItem.setFlags(typeItem.flags()
& ~Qt.ItemIsEditable) # 设置不可修改
self.listTableWidget.setItem(rowNumber, 1, typeItem)
timeItem = QTableWidgetItem(
time.strftime('%Y-%m-%d %H:%M:%S',
time.localtime(create_time)))
timeItem.setTextAlignment(Qt.AlignCenter | Qt.AlignVCenter)
timeItem.setFlags(timeItem.flags()
& ~Qt.ItemIsEditable) # 设置不可修改
self.listTableWidget.setItem(rowNumber, 2, timeItem)
def createTableBody(self, plist, correctCount=False):
rowNumber = 0
paramCount = len(plist)
self.setRowCount(paramCount)
for param in plist:
self.paramNameIndexCache[param.param_id] = rowNumber
if correctCount:
param.param_count = paramCount
name = QTableWidgetItem(param.param_id)
name.setFlags(name.flags() ^ Qt.ItemIsEditable)
vstr = None
if self._isIntegerType(param.param_type):
vstr = str(int(param.param_value))
elif self._isFloatType(param.param_type):
vstr = str(float(param.param_value))
else:
vstr = str(param.param_value)
value = QTableWidgetItem(vstr)
pstr = None
if param.param_type in PARAM_VALUE_TYPE_NAMES:
pstr = PARAM_VALUE_TYPE_NAMES[param.param_type]
else:
pstr = 'UNKNOWN TYPE: {}'.format(param.param_type)
ptype = QTableWidgetItem(pstr)
ptype.setData(PARAM_TYPE_RAW_ROLE, int(param.param_type))
ptype.setFlags(ptype.flags() ^ Qt.ItemIsEditable)
self.setItem(rowNumber, 0, name)
self.setItem(rowNumber, 1, value)
self.setItem(rowNumber, 2, ptype)
rowNumber += 1
self.resizeRowsToContents()
self.resizeColumnsToContents()
def add_row(self, row_index, row_data):
object_id, order = row_data
id_item = QTableWidgetItem(str(object_id))
order_item = QTableWidgetItem(str(order))
id_item.setFlags(id_item.flags() & ~Qt.ItemIsEditable)
order_item.setFlags(order_item.flags() & ~Qt.ItemIsEditable)
self.setItem(row_index, 0, id_item)
self.setItem(row_index, 1, order_item)
padding = 32
width = self.verticalHeader().width(
) + self.columnCount() * self.columnWidth(0) + 8
height = self.horizontalHeader().height(
) + self.rowCount() * self.rowHeight(0) + 8
display = QApplication.desktop()
cursor_x = display.cursor().pos().x()
cursor_y = display.cursor().pos().y()
current_screen = display.screenNumber(self.view)
geom = display.screenGeometry(current_screen)
screen_height = geom.height()
height = min(screen_height - 2 * padding, height)
self.setGeometry(cursor_x - padding, cursor_y, width, height)
def createItem(text, branch):
item = QTableWidgetItem(text)
item.setData(Qt.UserRole, branch)
item.setFlags(item.flags() & ~Qt.ItemIsEditable)
if branch.tick == -1:
item.setFlags(item.flags() & ~Qt.ItemIsEnabled)
return item
def populate_model(self):
self.ui.tbl_hosts.setRowCount(len(self._hosts))
for i, k in enumerate(self._hosts):
item = QTableWidgetItem(k)
item.setFlags(item.flags() & ~Qt.ItemIsEditable)
self.ui.tbl_hosts.setItem(i, R_IP, item)
item = QTableWidgetItem(self._hosts[k][0])
item.setFlags(item.flags() & ~Qt.ItemIsEditable)
self.ui.tbl_hosts.setItem(i, R_MAC, item)
item = QTableWidgetItem(self._hosts[k][1])
item.setFlags(item.flags() & ~Qt.ItemIsEditable)
self.ui.tbl_hosts.setItem(i, R_MAC_MAN, item)
self.ui.tbl_hosts.setItem(
i, R_NAME,
QTableWidgetItem(
self._hosts_names.get(self._hosts[k][0], "Not Set")))
self.btn_cut = QPushButton("")
self.btn_cut.setCheckable(True)
if k in self._cut_hosts:
self.btn_cut.setText("Uncut")
self.btn_cut.setIcon(QIcon("img/lan-disconnect.png"))
self.btn_cut.setChecked(True)
else:
self.btn_cut.setText("Cut")
self.btn_cut.setChecked(False)
self.btn_cut.setIcon(QIcon("img/lan-connect.png"))
self.btn_cut.clicked.connect(self.btn_cut_clicked)
self.ui.tbl_hosts.setCellWidget(i, R_STATUS, self.btn_cut)
def render_generic_file_metadata(self):
source_item = self.SourcesList.currentItem()
if source_item:
source = source_item.data(Qt.UserRole)
self.GenericFileMetadataTable.clear()
data = {
'file_name': source.file_name,
'size': source.size,
'url': source.url
}
self.GenericFileMetadataTable.setColumnCount(2)
self.GenericFileMetadataTable.setRowCount(len(data))
for i, (key, value) in enumerate(data.items()):
key_item = QTableWidgetItem()
key_item.setText(key)
key_item.setFlags(key_item.flags() ^ Qt.ItemIsEditable)
value_item = QTableWidgetItem()
value_item.setText(f'{value}')
if key != 'url':
key_item.setBackground(QColor(50, 50, 50))
value_item.setBackground(QColor(50, 50, 50))
value_item.setFlags(value_item.flags() ^ Qt.ItemIsEditable)
entry_data = {
'key': key,
'value': value,
'source': source,
'key_item': key_item,
'value_item': value_item
}
value_item.setData(Qt.UserRole, entry_data)
self.GenericFileMetadataTable.setItem(i, 0, key_item)
self.GenericFileMetadataTable.setItem(i, 1, value_item)
self.GenericFileMetadataTable.resizeColumnsToContents()
def create_item(text, database):
item = QTableWidgetItem(text)
item.setData(Qt.UserRole, database)
item.setFlags(item.flags() & ~Qt.ItemIsEditable)
if database.tick == -1:
item.setFlags(item.flags() & ~Qt.ItemIsEnabled)
return item
def _repo_clicked(self, item):
"""
Called when a repository item is clicked, will update the display.
:param item: the item clicked
"""
repo = item.data(Qt.UserRole)
repo = repo if repo else Repository('', '', '', '')
self._saveButton.setEnabled(True)
self._fileLabel.setText('<b>File:</b> %s' % str(repo.file))
self._hashLabel.setText('<b>Hash:</b> %s' % str(repo.hash))
self._typeLabel.setText('<b>Type:</b> %s' % str(repo.type))
self._dateLabel.setText('<b>Date:</b> %s' % str(repo.date))
# Display the list of branches for the selected repository
branches = [br for br in self._branches if br.hash == repo.hash]
self._branchesTable.setRowCount(len(branches) + 1)
for i, br in enumerate(branches):
item = QTableWidgetItem(str(br.uuid))
item.setData(Qt.UserRole, br)
item.setFlags(item.flags() & ~Qt.ItemIsEditable)
self._branchesTable.setItem(i, 0, item)
item = QTableWidgetItem(str(br.date))
item.setData(Qt.UserRole, br)
item.setFlags(item.flags() & ~Qt.ItemIsEditable)
self._branchesTable.setItem(i, 1, item)
newItem = QTableWidgetItem("<new branch>")
item.setData(Qt.UserRole, None)
newItem.setFlags(newItem.flags() & ~Qt.ItemIsEditable)
self._branchesTable.setItem(len(branches), 0, newItem)
newItem = QTableWidgetItem()
item.setData(Qt.UserRole, None)
newItem.setFlags(newItem.flags() & ~Qt.ItemIsEditable)
self._branchesTable.setItem(len(branches), 1, newItem)
def loadFeeders(self,tableView,rootNodes):
tableView.clear()
tableView.setRowCount(0)
if not rootNodes:
return
for e in rootNodes.iter():
path = rootNodes.getpath(e)
if re.fullmatch("\/openpnp-machine\/machine\/feeders\/feeder\[[0-9]+\]",path):
txtId = e.get("id","Id?")
txtName = e.get("name", "Name?")
txtPartId = e.get("part-id", "PartId?")
txtAttr = str(e.attrib)
rowPosition = tableView.rowCount()
tableView.insertRow(rowPosition)
widget1 = QTableWidgetItem(txtId)
widget1.setData(Qt.UserRole, path)
widget1.setFlags(widget1.flags() ^ Qt.ItemIsEditable)
tableView.setItem(rowPosition, 0, widget1)
widget2 = QTableWidgetItem(txtName)
widget2.setFlags(widget2.flags() ^ Qt.ItemIsEditable)
tableView.setItem(rowPosition, 1, widget2)
widget3 = QTableWidgetItem(txtPartId)
widget3.setFlags(widget3.flags() ^ Qt.ItemIsEditable)
tableView.setItem(rowPosition, 2, widget3)
widget4 = QTableWidgetItem(txtAttr)
widget4.setFlags(widget4.flags() ^ Qt.ItemIsEditable)
tableView.setItem(rowPosition, 3, widget4)
tableView.setHorizontalHeaderLabels(self.hlabels)
def filltabledata(self):
# get ini file data
config = configparser.ConfigParser()
config.read_file(open(self.filename))
sec = config.sections()
lop = []
for i in range(len(sec)):
lop.append(config.options(sec[i]))
# fill data to the table widget
i = 0
for n in range(len(sec)):
self.tableWidget.setRowCount(i + 1)
self.tableWidget.setSpan(i, 0, 1, 3)
secitem = QTableWidgetItem(sec[n])
secitem.setForeground(QColor(Qt.red))
self.tableWidget.setItem(i, 0, secitem)
secitem.setFlags(secitem.flags() & (~Qt.ItemIsEditable))
for j in range(len(lop[n])):
i = i + 1
self.tableWidget.setRowCount(i + 1)
item0 = QTableWidgetItem(lop[n][j])
item0.setFlags(item0.flags() & (~Qt.ItemIsEditable)) # Item name can't edit
s = config.get(sec[n], lop[n][j])
s1, s2 = s.split("#")
item1 = QTableWidgetItem(s1)
item2 = QTableWidgetItem(s2)
self.tableWidget.setItem(i, 0, item0)
self.tableWidget.setItem(i, 1, item1)
self.tableWidget.setItem(i, 2, item2)
# print(n, j, lop[n][j], i)
i = i + 1
self.tableWidget.resizeColumnsToContents()
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 redraw_table(self, length=None):
with DisableUpdates(self.datatable):
oldsig = self.datatable.blockSignals(True)
self.row_size = length or self.row_size
self.datatable.setColumnCount(self.row_size + 1)
self.datatable.setRowCount(0)
self.str_col = self.row_size
self.datatable.horizontalHeader().hide()
self.datatable.verticalHeader().hide()
rows = int(len(self.data) / self.row_size)
if len(self.data) % self.row_size > 0:
rows += 1
self.datatable.setRowCount(rows)
for i in range(rows * self.row_size):
row = i / self.row_size
col = i % self.row_size
if i < len(self.data):
dataval = "%02x" % self.data[i]
item = QTableWidgetItem(dataval)
if self.read_only:
item.setFlags(item.flags() ^ Qt.ItemIsEditable)
else:
item = QTableWidgetItem("")
item.setFlags(item.flags() ^ Qt.ItemIsEditable)
self.datatable.setItem(row, col, item)
for row in range(rows):
self._redraw_strcol(row)
self.datatable.blockSignals(oldsig)
self.datatable.resizeColumnsToContents()
self.datatable.resizeRowsToContents()
def createGUI(self):
length = len(self.labelHist)
tableData = pandas.read_csv('configGUI/predefined_label.csv')
self.table = QTableWidget(length, 2)
self.table.setHorizontalHeaderLabels(["Label Name", "Label Color"])
self.table.verticalHeader().setVisible(True)
self.table.setSizeAdjustPolicy(
QtWidgets.QAbstractScrollArea.AdjustToContents)
self.table.cellDoubleClicked.connect(self.editCell)
self.table.cellChanged.connect(self.cellChanged)
for i in range(length):
name = tableData.at[i, 'label name']
nameItem = QTableWidgetItem(name)
nameItem.setFlags(nameItem.flags() | Qt.ItemIsEditable)
color = QColor(tableData.at[i, 'label color'])
colorItem = QTableWidgetItem()
colorItem.setData(Qt.DisplayRole, color)
colorItem.setFlags(colorItem.flags() | Qt.ItemIsEditable)
self.table.setItem(i, 0, nameItem)
self.table.setItem(i, 1, colorItem)
self.table.resizeColumnToContents(0)
self.layout = QGridLayout()
self.layout.addWidget(self.table, 0, 0)
self.setLayout(self.layout)
self.setWindowTitle("Predefined Label Editor")
def addListItem(self, content):
rows = self.list.rowCount()
self.list.setRowCount(rows + 1)
tcb = TableCellButtons()
tcb.setItem(content)
tcb.deleteItem.connect(self.deleteContent)
tcb.editItem.connect(self.edit)
self.list.setCellWidget(rows, 0, tcb)
self.list.setRowHeight(rows, tcb.sizeHint().height())
titleItem = QTableWidgetItem(content.title)
titleItem.setFlags(titleItem.flags() ^ Qt.ItemIsEditable)
titleItem.setData(Qt.UserRole, content)
self.list.setItem(rows, 1, titleItem)
sourceItem = QTableWidgetItem(content.source)
sourceItem.setFlags(titleItem.flags() ^ Qt.ItemIsEditable)
self.list.setItem(rows, 2, sourceItem)
layoutItem = QTableWidgetItem(content.layout)
layoutItem.setFlags(layoutItem.flags() ^ Qt.ItemIsEditable)
self.list.setItem(rows, 3, layoutItem)
authorItem = QTableWidgetItem(content.author)
authorItem.setFlags(authorItem.flags() ^ Qt.ItemIsEditable)
self.list.setItem(rows, 4, authorItem)
dateItem = QTableWidgetItem(content.date.toString("dd.MM.yyyy"))
dateItem.setFlags(dateItem.flags() ^ Qt.ItemIsEditable)
self.list.setItem(rows, 5, dateItem)
def setValue(self, value):
self._updating = True
self.resizeColumnsToContents()
self.setMinimumSize(self.viewportSizeHint())
self.setRowCount(0)
if value is None:
value = set()
else:
# Don't mutate the original value.
value = set(value)
self._value = value
row = -1
for choice in sorted(self._reversed_choices):
row += 1
self.insertRow(row)
item = QTableWidgetItem(self._choices[choice])
item.setFlags(item.flags() & ~Qt.ItemIsEditable)
self.setItem(row, 0, item)
item = QTableWidgetItem()
item.setFlags((item.flags() & ~Qt.ItemIsEditable)
| Qt.ItemIsUserCheckable)
item.setCheckState(Qt.Checked if choice in value else Qt.Unchecked)
self.setItem(row, 1, item)
self.resizeColumnsToContents()
self.setMinimumSize(self.viewportSizeHint())
self._updating = False
def __init__(self, processes, initial_process, title, headers, has_tid):
super(ProcessSelectDialog, self).__init__()
self.setWindowTitle(title)
self.seq_chkbx = QCheckBox("Sequence Labels")
self.seq_chkbx.setChecked(True)
# so can more easily prevent errors when omit this checkbox from GUI
# create it whether or not we need it
self.tid_chkbx = QCheckBox("Thread ID Labels")
if (has_tid):
self.tid_chkbx.setChecked(True)
else:
self.tid_chkbx.setChecked(False)
btn_ok = QPushButton("OK")
btn_ok.clicked.connect(self.accept)
btn_cancel = QPushButton("Cancel")
btn_cancel.clicked.connect(self.reject)
self.process_table = QTableWidget()
self.process_table.setColumnCount(2)
self.process_table.setHorizontalHeaderLabels(headers)
self.process_table.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch)
self.process_table.setRowCount(len(processes))
self.process_table.verticalHeader().setVisible(False)
self.process_table.setSelectionBehavior(QAbstractItemView.SelectRows)
self.process_table.setSelectionMode(QAbstractItemView.SingleSelection)
i = 0
for p in processes:
process_name_item = QTableWidgetItem(p[0])
process_name_item.setFlags(process_name_item.flags() & ~(Qt.ItemIsEditable))
self.process_table.setItem(i, 0, process_name_item)
process_id_item = QTableWidgetItem(str(p[1]))
process_id_item.setFlags(process_id_item.flags() & ~(Qt.ItemIsEditable))
self.process_table.setItem(i, 1, process_id_item)
i += 1
self.process_table.sortItems(0)
if (initial_process is not None):
matches = self.process_table.findItems(initial_process, Qt.MatchExactly)
if (len(matches) > 0):
self.process_table.setCurrentItem(matches[0])
chkboxes = QVBoxLayout()
chkboxes.addWidget(self.seq_chkbx)
if (has_tid):
chkboxes.addWidget(self.tid_chkbx)
hbox = QHBoxLayout()
hbox.addStretch(1)
hbox.addWidget(btn_ok)
hbox.addWidget(btn_cancel)
vbox = QVBoxLayout()
vbox.addWidget(self.process_table)
vbox.addLayout(chkboxes)
vbox.addLayout(hbox)
self.setLayout(vbox)
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 scrollDeleteTable(self, first):
if first >= self.inputData.shape[0]: return
self.isDrawingDeleteTable = True
if first == 0:
first = 1
if first > 1:
first -= 1
self.deleteScrollRow = first
inputColor = QtGui.QColor(255, 0, 0, 50) # translucent red
inputRefinedColor = QtGui.QColor(255, 0, 0, 100)
outputColor = QtGui.QColor(255, 255, 0, 50) # translucent yellow
outputRefinedColor = QtGui.QColor(255, 255, 0,
100) # translucent yellow
mask = ~(Qt.ItemIsEditable)
checkboxMask = ~(Qt.ItemIsSelectable | Qt.ItemIsEditable)
numRows = self.deleteTable.rowCount()
end = first + 15
if end > numRows:
end = numRows
for r in range(first, end):
item = self.deleteTable.item(r, 0)
if item is None:
item = QTableWidgetItem()
flags = item.flags()
item.setFlags(flags & checkboxMask)
item.setCheckState(Qt.Unchecked)
self.deleteTable.setItem(r, 0, item)
for c in range(self.nInputs): # populate input values
item = self.deleteTable.item(r, c + 1)
if item is None:
item = QTableWidgetItem(self.format %
self.inputData[r - 1][c])
flags = item.flags()
item.setFlags(flags & mask)
if r - 1 < self.nSamples - self.nSamplesAdded:
color = inputColor
else:
color = inputRefinedColor
item.setBackground(color)
self.deleteTable.setItem(r, c + 1, item)
if isinstance(self.outputData, numpy.ndarray):
for c in range(self.nOutputs): # populate output values
item = self.deleteTable.item(r, self.nInputs + c + 1)
if item is None:
if math.isnan(self.outputData[r - 1][c]):
item = QTableWidgetItem()
else:
item = QTableWidgetItem(self.format %
self.outputData[r - 1][c])
if r - 1 < self.nSamples - self.nSamplesAdded:
color = outputColor
else:
color = outputRefinedColor
item.setBackground(color)
self.deleteTable.setItem(r, self.nInputs + c + 1, item)
self.isDrawingDeleteTable = False
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 _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 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 setRevision(self, pos, type, rev, date):
typeItem = QTableWidgetItem(type)
typeItem.setFlags(typeItem.flags() & ~Qt.ItemIsEditable)
dateItem = QTableWidgetItem(date)
dateItem.setFlags(dateItem.flags() | Qt.ItemIsEditable)
revItem = QTableWidgetItem(rev)
self.m_tableWidget.setItem(pos, 0, typeItem)
self.m_tableWidget.setItem(pos, 1, revItem)
self.m_tableWidget.setItem(pos, 2, dateItem)
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 populate(self):
"""Populates the table with trace data"""
try:
self.itemChanged.disconnect()
except Exception:
pass
trace = self.trace
if trace is None or not trace:
self.setRowCount(0)
return
if self.pagination is not None:
self.update_pagination()
page = self.pagination.current_page
per_page = self.pagination.rows_per_page
trace = trace[(page - 1) * per_page:page * per_page]
row_count = len(trace)
self.setRowCount(row_count)
if row_count == 0:
return
for i in range(0, row_count):
row_id_item = QTableWidgetItem(str(trace[i]["id"]))
row_id_item.setFlags(row_id_item.flags() & ~Qt.ItemIsEditable)
address_item = QTableWidgetItem(hex(trace[i].get("ip")))
address_item.setFlags(address_item.flags() & ~Qt.ItemIsEditable)
opcodes_item = QTableWidgetItem(trace[i]["opcodes"])
opcodes_item.setFlags(opcodes_item.flags() & ~Qt.ItemIsEditable)
disasm_item = QTableWidgetItem(trace[i]["disasm"])
disasm_item.setFlags(disasm_item.flags() & ~Qt.ItemIsEditable)
regchanges_item = QTableWidgetItem(trace[i].get("regchanges", ""))
regchanges_item.setFlags(regchanges_item.flags()
& ~Qt.ItemIsEditable)
regchanges_item.setWhatsThis("regchanges")
comment_item = QTableWidgetItem(trace[i].get("comment", ""))
comment_item.setWhatsThis("comment")
self.setItem(i, 0, row_id_item)
self.setItem(i, 1, address_item)
self.setItem(i, 2, opcodes_item)
self.setItem(i, 3, disasm_item)
self.setItem(i, 4, regchanges_item)
self.setItem(i, 5, comment_item)
self.setRowHeight(i, self.row_height)
self.itemChanged.connect(self.item_changed)
def setTrue(self):
if self.col == 7:
# We enforce the condition that only one aperture
# can have True for this property
for row in range(self.tableWidget.rowCount()):
item = QTableWidgetItem('False')
item.setFlags(item.flags() ^ QtCore.Qt.ItemIsEditable)
self.tableWidget.setItem(row, self.col, item)
item = QTableWidgetItem('True')
item.setFlags(item.flags() ^ QtCore.Qt.ItemIsEditable)
self.tableWidget.setItem(self.row, self.col, item)
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 __col_item(self, col: EnumColsHelper):
r, c, vtype, editable, selectable = self.row_num, col.value.index, col.value.value_type, col.value.editable, col.value.selectable
if self.table.item(r, c) is None:
item = QTableWidgetItem()
if not editable:
item.setFlags(item.flags() & ~Qt.ItemIsEditable)
if vtype is bool:
item.setFlags(item.flags() & ~Qt.ItemIsUserCheckable)
if not selectable:
item.setFlags(item.flags() & ~Qt.ItemIsSelectable)
self.table.setItem(r, c, item)
return self.table.item(r, c)
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 add_row(self, student=None):
if not student:
self.write_lock = True
idx = self.table_widget.rowCount()
self.table_widget.setRowCount(idx + 1)
if student:
name_item = QTableWidgetItem(student.name)
name_item.setFlags(name_item.flags() & ~QtCore.Qt.ItemIsEditable)
else:
name_item = QTableWidgetItem()
self.table_widget.setItem(idx, 0, name_item)
if student:
matrikelnr_item = QTableWidgetItem(student.matrikelnr)
matrikelnr_item.setFlags(matrikelnr_item.flags() & ~QtCore.Qt.ItemIsEditable)
else:
matrikelnr_item = QTableWidgetItem()
matrikelnr_item.setTextAlignment(QtCore.Qt.AlignCenter)
self.table_widget.setItem(idx, 1, matrikelnr_item)
if student:
group_item = QTableWidgetItem(self.files_combobox.currentText())
group_item.setFlags(matrikelnr_item.flags() & ~QtCore.Qt.ItemIsEditable)
else:
group_item = QTableWidgetItem()
group_item.setTextAlignment(QtCore.Qt.AlignCenter)
self.table_widget.setItem(idx, 2, group_item)
check_item = QWidget()
chk_bx = QCheckBox()
chk_bx.setCheckState(QtCore.Qt.Unchecked)
chk_bx.stateChanged.connect(self.attendance_changed)
lay_out = QHBoxLayout(check_item)
lay_out.addWidget(chk_bx)
lay_out.setAlignment(QtCore.Qt.AlignCenter)
lay_out.setContentsMargins(0,0,0,0)
check_item.setLayout(lay_out)
self.checked_list.append(chk_bx)
self.table_widget.setCellWidget(idx, 3, check_item)
adhoc_item = QTableWidgetItem()
adhoc_item.setTextAlignment(QtCore.Qt.AlignCenter)
self.table_widget.setItem(idx, 4, adhoc_item)
self.table_widget.setItem(idx, 5, QTableWidgetItem())
if not student:
self.write_lock = False
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 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 _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 _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 _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 _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 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 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 _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 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 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 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 update(self): self.player_list.clearContents() players = [to.players[player] for player in to.sorted_players(self.sort_order)] index = 0 for player in players: if index == self.player_list.rowCount(): self.player_list.insertRow(index) name_item = QTableWidgetItem(player.name) name_item.setFlags(name_item.flags() & ~Qt.ItemIsEditable) self.player_list.setItem(index, 0, name_item) record_item = QTableWidgetItem(player.record_str()) record_item.setFlags(record_item.flags() & ~Qt.ItemIsEditable) self.player_list.setItem(index, 1, record_item) index += 1 self.player_list.show()
def on_coords_recieved(self, df):
"""
Modify the TableWidget when the data is recieved in the `coords` terminal
"""
if df is None:
# if DataFrame withh coords is emty
self.clear()
else:
#if everything is Ok, create rows and populate them
for i, wellName in enumerate(df.index.values):
# first check if a row with this name already exists
if wellName in self._tableWidget_wellNames():
continue
# no dupticated entry > continue adding the row
self.tableWidget_menu.insertRow(i) #create row
# now create 4 items for this row
# - well Name [Checkbox]
# - X coord [label]
# - Y coord [label]
# - Head [combobox]
wellNameItem = QTableWidgetItem(wellName)
wellNameItem.setFlags(wellNameItem.flags() ^ Qt.ItemIsEditable)
wellNameItem.setCheckState(Qt.Checked)
#wellNameItem.currentIndexChanged.connect(self._parent.on_calcSingle_requested)
xCoordItem = QTableWidgetItem('{0:.2f}'.format( float(df.iloc[[i]]['x']) ) )
xCoordItem.setFlags(xCoordItem.flags() ^ Qt.ItemIsEditable)
yCoordItem = QTableWidgetItem('{0:.2f}'.format( float(df.iloc[[i]]['y']) ) )
yCoordItem.setFlags(yCoordItem.flags() ^ Qt.ItemIsEditable)
headItem = QtWidgets.QComboBox()
headItem.currentIndexChanged.connect(self._parent.on_calcSingle_requested)
# finally add items to the table (populate the row)
self.tableWidget_menu.setItem(i, 0, wellNameItem)
self.tableWidget_menu.setItem(i, 1, xCoordItem)
self.tableWidget_menu.setItem(i, 2, yCoordItem)
self.tableWidget_menu.setCellWidget(i, 3, headItem)
self.updateUI()
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 update(self): self.pairings_list.clearContents() index = 0 for p1, p2 in to.pairings.items(): if index == self.pairings_list.rowCount(): self.pairings_list.insertRow(index) p1_item = QTableWidgetItem(p1) p1_item.setFlags(p1_item.flags() & ~Qt.ItemIsEditable) self.pairings_list.setItem(index, 0, p1_item) if p2 == None: p2_str = '--BYE--' else: p2_str = p2 p2_item = QTableWidgetItem(p2_str) p2_item.setFlags(p2_item.flags() & ~Qt.ItemIsEditable) self.pairings_list.setItem(index, 1, p2_item) index += 1 self.pairings_list.show()
def update_ui(self):
"""Update the UI with all entries contained in self.results"""
if self.results:
self.table.setRowCount(len(self.results))
for idx, item in enumerate(self.results):
char, latex, description, user_description = item
char_item = QTableWidgetItem(char)
char_item.setFlags(char_item.flags() & ~Qt.ItemIsEditable)
latex_item = QTableWidgetItem(latex)
latex_item.setFlags(latex_item.flags() & ~Qt.ItemIsEditable)
user_desc = " [{}]".format(user_description) if user_description else ""
description_item = QTableWidgetItem("{}{}".format(description, user_desc))
description_item.setFlags(description_item.flags() & ~Qt.ItemIsEditable)
self.table.setItem(idx, 0, char_item)
self.table.setItem(idx, 1, latex_item)
self.table.setItem(idx, 2, description_item)
self.table.setCurrentCell(0, 0)
else:
self.table.setRowCount(0)
def _callsInThisFunction(self):
"""
Shows all calls within the current function
"""
msg = "Calls within function '" + misc.get_function_name()
self._console_output(msg)
show_unique_calls = self.config.display_unique_calls
callee_list = self.ba.calls_in_function()
nr_rows = len(callee_list)
if not nr_rows:
self._console_output("[!] No calls found", err = True)
return
self.table_label.setText("Calls within current function")
self.table.setColumnCount(2)
self.table.setHorizontalHeaderLabels(("Address", "Callee"))
self.table.clearContents()
self.table.setRowCount(0)
# Fill with contents
shown_calls = []
idx = 0
for (addr, callee) in callee_list:
if show_unique_calls and callee in shown_calls:
continue
shown_calls.append(callee)
self.table.insertRow(idx)
addr_item = QTableWidgetItem("%08x" % addr)
addr_item.setFlags(addr_item.flags() ^ QtCore.Qt.ItemIsEditable)
callee_item = QTableWidgetItem(callee)
callee_item.setFlags(addr_item.flags() ^ QtCore.Qt.ItemIsEditable)
self.table.setItem(idx, 0, addr_item)
self.table.setItem(idx, 1, callee_item)
idx += 1
def update(self): self.user_list.clearContents() # TODO: get the most recent user list users = um.users() index = 0 for user in users: if index == self.user_list.rowCount(): self.user_list.insertRow(index) name_item = QTableWidgetItem(user.name) name_item.setFlags(name_item.flags() & ~Qt.ItemIsEditable) self.user_list.setItem(index, 0, name_item) id_item = QTableWidgetItem(str(user.id)) id_item.setFlags(id_item.flags() & ~Qt.ItemIsEditable) self.user_list.setItem(index, 1, id_item) record_item = QTableWidgetItem(user.record_str()) record_item.setFlags(record_item.flags() & ~Qt.ItemIsEditable) self.user_list.setItem(index, 2, record_item) index += 1 self.user_list.show()
def _showDangerousConnections(self):
"""
Shows connections graphs between functions calling IO
and the ones calling dangerous APIs
"""
self._console_output("Calculating dangerous connections...")
try:
conn_graphs = self.ba.get_all_dangerous_connections()
except Exception as e:
print "[!] Error in get_all_dangerous_connections()", e
return
if not conn_graphs:
self._console_output("[!] No (obvious) dangerous connections", err = True)
return
self.table.setColumnCount(5)
self.table.setHorizontalHeaderLabels(
("IO Caller", "Dangerous Functions", "Shortest Path Length", "u", "v"))
self.table_label.setText("Dangerous Connections")
self.table.clearContents()
self.table.setRowCount(0)
for idx, c in enumerate(conn_graphs):
self.table.insertRow(idx)
u, v, sp_len = c # tuple unpacking
io_item = QTableWidgetItem("%s" % misc.get_function_name(u))
df_item = QTableWidgetItem("%s" % misc.get_function_name(v))
sp_item = QTableWidgetItem("%d" % sp_len)
ioa_item = QTableWidgetItem("%x" % u)
ioa_item.setFlags(ioa_item.flags() ^ QtCore.Qt.ItemIsEditable)
dfa_item = QTableWidgetItem("%x" % v)
dfa_item.setFlags(dfa_item.flags() ^ QtCore.Qt.ItemIsEditable)
self.table.setItem(idx, 0, io_item)
self.table.setItem(idx, 1, df_item)
self.table.setItem(idx, 2, sp_item)
self.table.setItem(idx, 3, ioa_item)
self.table.setItem(idx, 4, dfa_item)
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 setValue(self, value):
self._updating = True
self.resizeColumnsToContents()
self.setMinimumSize(self.viewportSizeHint())
self.setRowCount(0)
if value is None:
value = set()
self._value = value
row = -1
for choice in sorted(self._reversed_choices):
row += 1
self.insertRow(row)
item = QTableWidgetItem(self._choices[choice])
item.setFlags(item.flags() & ~Qt.ItemIsEditable)
self.setItem(row, 0, item)
item = QTableWidgetItem()
item.setFlags((item.flags() & ~Qt.ItemIsEditable) | Qt.ItemIsUserCheckable)
item.setCheckState(Qt.Checked if choice in value else Qt.Unchecked)
self.setItem(row, 1, item)
self.resizeColumnsToContents()
self.setMinimumSize(self.viewportSizeHint())
self._updating = False
def _add_cache_to_table(self, row, cache):
self._ignore_cell_changed = True
self.setItem(row, 0, QTableWidgetItem(str(cache.identifier)))
self.item(row, 0).setTextAlignment(Qt.AlignCenter)
self.setItem(row, 1, QTableWidgetItem(str(cache.name)))
self.setItem(row, 2, QTableWidgetItem(str(cache.size)))
self.item(row, 2).setTextAlignment(Qt.AlignRight | Qt.AlignVCenter)
self.setItem(row, 3, QTableWidgetItem(str(cache.access_time)))
self.item(row, 3).setTextAlignment(Qt.AlignRight | Qt.AlignVCenter)
penalty_item = QTableWidgetItem(str(cache.penalty))
penalty_item.setFlags(penalty_item.flags() ^ (Qt.ItemIsEditable | Qt.ItemIsEnabled))
self.setItem(row, 4, penalty_item)
self.item(row, 4).setTextAlignment(Qt.AlignRight | Qt.AlignVCenter)
self._ignore_cell_changed = False
