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 _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 load_rows(self, *args):
"""
:param args:item code
:return:Loads the rows from the database
"""
table = self.dialogue.menudialogue_menuIngredients_table
if args:
table.clearContents()
table.setRowCount(0)
if args[0] != 0:
table.setRowCount(len(args))
for i, j in enumerate(args):
item = QTableWidgetItem(j['code'])
table.setItem(i, 0, item)
item = QTableWidgetItem(j['item'])
table.setItem(i, 1, item)
item = QTableWidgetItem(j['category'])
table.setItem(i, 2, item)
combo = QComboBox()
self.fillunits(combo)
index = combo.findText(j['units'])
combo.setCurrentIndex(index)
table.setCellWidget(i, 3, combo)
quantity = QLineEdit(j['quantity'])
table.setCellWidget(i, 4, quantity)
else:
###arranges the width each time we call this method
table.setColumnWidth(1, table.width() / 5)
table.setColumnWidth(2, table.width() / 5)
table.setColumnWidth(3, table.width() / 5)
def set_abbreviations(self, empire):
""" Clears the abbreviations table, then adds the abbreviations for the current
empire to it.
Arguments:
empire (lacuna.empire.MyEmpire): The empire whose abbreviations we'll show.
"""
self.init_for_data()
self.widget.setSortingEnabled(False)
row = 0
for n in sorted(empire.planet_names):
itm_name = QTableWidgetItem(n)
try:
itm_abbrv = QTableWidgetItem(
self.parent.app.abbrv.get_abbrv(n))
except KeyError as e:
itm_abbrv = QTableWidgetItem("<None>")
fl = itm_name.flags()
fl &= ~Qt.ItemIsEditable
itm_name.setFlags(fl)
self.widget.insertRow(row)
self.widget.setItem(row, 0, itm_name)
self.widget.setItem(row, 1, itm_abbrv)
row += 1
self.widget.setSortingEnabled(True)
self.widget.itemChanged.connect(self.update)
self.resize()
def insertRow(self):
nRows = self.tableWidget.rowCount()
self.tableWidget.insertRow(nRows) # inset one row at the end
kitem = QTableWidgetItem("") # also set flags and state, type
vitem = QTableWidgetItem("")
self.tableWidget.setItem(nRows, 0, kitem)
self.tableWidget.setItem(nRows, 1, vitem)
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 subscriberChanged(self):
subPaths = self.subscriber.subPaths()
if self.listWidget:
self.listWidget.clear()
elif self.tableWidget:
self.tableWidget.clearContents()
self.tableWidget.setRowCount(len(subPaths))
for i in xrange(len(subPaths)):
v = self.subscriber.value(subPaths[i])
if self.listWidget:
item = QListWidgetItem('%s (%s)\n%s' %
(subPaths[i], str(type(v)), str(v)))
item.setFlags(item.flags() & ~Qt.ItemIsEditable)
self.listWidget.addItem(item)
elif self.tableWidget:
pathItem = QTableWidgetItem(subPaths[i])
pathItem.setFlags(pathItem.flags() & ~Qt.ItemIsEditable)
valueItem = QTableWidgetItem(str(v))
valueItem.setFlags(pathItem.flags() & ~Qt.ItemIsEditable)
typeItem = QTableWidgetItem(str(type(v)))
typeItem.setFlags(pathItem.flags() & ~Qt.ItemIsEditable)
self.tableWidget.setItem(i, 0, pathItem)
self.tableWidget.setItem(i, 1, valueItem)
self.tableWidget.setItem(i, 2, typeItem)
def __init__(self, updates, streetdb):
QDialog.__init__(self)
self.setupUi(self)
table = self.tableWidget
table.setRowCount(len(updates)+1)
table.setColumnCount(len(common.ATT))
self.setWindowTitle("Overview")
for i in range(len(common.ATT)):
item = QTableWidgetItem(common.ATT_HR[common.ATT[i]])
table.setItem(0, i, item)
for i, street in enumerate(updates):
changes = updates[street]
row = []
for z in range(len(common.ATT)):
found = False
att = common.ATT[z]
print(att)
for change in changes:
split = change.split(":")
if split[0] == att:
row.append(split[1])
found = True
if not found:
try:
row.append(streetdb[street][att])
except KeyError:
"""print("Error building diagram in Street:", street, " Attribute: ", att) ## Missing field"""
for x, update in enumerate(row):
item = QTableWidgetItem(update)
if "->" in update:
item.setForeground(Qt.red)
print(i+1, x, update)
table.setItem(i+1, x, item)
self.load_settings()
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?
nrows = len(s_ref_list)
if not nrows:
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_link(self, url):
"""
Adds a link to the link widget.
Only adds if its not already present.
"""
if url not in self.links:
self.links.add(url)
rowCounts = self.links_ui.rowCount()
nextRow = rowCounts + 1
nextPosition = rowCounts # row count is the length, but position is zero-based
self.links_ui.setRowCount(nextRow)
urlEntry = QTableWidgetItem(url)
statusEntry = QTableWidgetItem('')
statusEntry.setTextAlignment(Qt.AlignCenter)
urlEntry.setFlags(urlEntry.flags()
& ~Qt.ItemIsEditable) # not editable
statusEntry.setFlags(statusEntry.flags()
& ~Qt.ItemIsEditable) # not editable
self.links_ui.setItem(nextPosition, 0, urlEntry)
self.links_ui.setItem(nextPosition, 1, statusEntry)
# check if online
stream = Stream(url.split())
stream.is_online(statusEntry)
def createCustomEntry(self, model):
"""
:type model: FileEntry
:rtype: QTableWidgetItem
"""
nameItem = QTableWidgetItem(model.name)
dateItem = QTableWidgetItem(str(model.lastUpdate.date()))
iconItem = QTableWidgetItem()
if model.status in [
Status.Seen_user.value, Status.Download_seen_user.value
]:
iconItem.setIcon(QIcon(resource_filepath("viewed.svg")))
elif model.status in [
Status.Update_server.value,
Status.Download_updated_server.value
]:
iconItem.setIcon(QIcon(resource_filepath("updated.svg")))
elif model.status == Status.Download_same.value:
iconItem.setIcon(QIcon(resource_filepath("downloaded.svg")))
if model.status == 1:
nameItem.setBackground(RGBColors.Emerald.value)
dateItem.setBackground(RGBColors.Emerald.value)
iconItem.setBackground(RGBColors.Emerald.value)
return [iconItem, nameItem, dateItem]
def add_chunk_trace_table(self, table, trace, k, index):
i = index
while trace.instrs.has_key(k):
inst = trace.instrs[k]
if trace.metas.has_key(k):
for name, arg1, arg2 in trace.metas[k]:
if name == "wave":
infos = ["=", "========",
"> Wave:" + str(arg1)] #,"=","========"
elif name == "exception":
infos = [
"", "", "Exception type:" + str(arg1) +
" @handler:" + str(arg2)
] #,"",""
elif name == "module":
infos = ["", "Module", arg1] #,"",""
else:
infos = ["", "", "Invalid"] #,"",""
for col_id, cell in enumerate(infos):
newitem = QTableWidgetItem(cell)
newitem.setFlags(newitem.flags() ^ Qt.ItemIsEditable)
table.setItem(i, col_id, newitem)
i += 1
info = [str(k), hex(inst.address)[:-1], inst.opcode
] #str(inst.thread), idc.GetFunctionName(inst.address)
for col_id, cell in enumerate(info):
newitem = QTableWidgetItem(cell)
newitem.setFlags(newitem.flags() ^ Qt.ItemIsEditable)
table.setItem(i, col_id, newitem)
i += 1
k += 1
def readTableFromList(self, mytable, mylist):
"""
mylist contains triples of (name, value, modifyable)
"""
mytable.clear()
mytable.setRowCount(0)
for (ind, (name, string_value, modifyable,
var_type)) in enumerate(sorted(mylist, key=lambda x: x[0])):
# sort list to get a reproducible table
mytable.insertRow(ind)
mytable.setItem(ind, 0, QTableWidgetItem(name))
value_item = QTableWidgetItem(string_value)
if not modifyable:
value_item.setFlags(value_item.flags() & Qt.ItemIsEditable)
mytable.setItem(ind, 1, value_item)
type_item = QTableWidgetItem(str(var_type))
type_item.setFlags(type_item.flags() & Qt.ItemIsEditable)
mytable.setItem(ind, 2, type_item)
header = mytable.horizontalHeader()
try:
# this is Qt4
header.setResizeMode(0, QHeaderView.ResizeToContents)
header.setResizeMode(1, QHeaderView.Stretch)
except AttributeError:
# this is Qt5
header.setSectionResizeMode(0, QHeaderView.ResizeToContents)
header.setSectionResizeMode(1, QHeaderView.Stretch)
def add_row(self, *args):
"""adds a new row entry"""
table = self.addeachweek.add_eachweek_table
table.setSelectionBehavior(QAbstractItemView.SelectRows)
table.setEditTriggers(QAbstractItemView.NoEditTriggers)
table.setShowGrid(False)
table.setAlternatingRowColors(True)
table.setStyleSheet("color:#000000;")
if args:
table.setRowCount(len(args))
for i, j in enumerate(args):
checkbox = QCheckBox()
table.setCellWidget(i, 0, checkbox)
item = QTableWidgetItem(j['item_no'])
table.setItem(i, 1, item)
item = QTableWidgetItem(j['item'])
table.setItem(i, 2, item)
item = QTableWidgetItem(j['category'])
table.setItem(i, 3, item)
item = QTableWidgetItem(j['rate'])
table.setItem(i, 4, item)
quantity = QLineEdit()
quantity.setValidator(QIntValidator(0, 99999))
table.setCellWidget(i, 5, quantity)
table.setColumnWidth(0, table.width() / 9)
table.setColumnWidth(1, table.width() / 5)
table.setColumnWidth(2, table.width() / 5)
table.setColumnWidth(3, table.width() / 5)
table.setColumnWidth(4, table.width() / 5)
def populateClipsList(self, clipsList):
self.selected_clip = None
self.btnSelect.setEnabled(False)
self.clipTable.clearContents()
self.clipTable.setRowCount(len(clipsList))
for idx, (clip_id, val) in enumerate(clipsList.iteritems()):
self.clipTable.setItem(idx, 0, QTableWidgetItem(str(clip_id)))
self.clipTable.setItem(idx, 1, QTableWidgetItem(val['name']))
def _showImportTrace(self, restrict=True):
"""
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 = QtGui.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:
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 dropdown 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 showData(self):
self.tableView.setRowCount(len(self.root))
for ix, child in enumerate(self.root):
s = u""+child.attrib["priceForFull"]+u"Kè/"+child.attrib["mainUnitDescription"]
self.tableView.setItem(ix, 0, QTableWidgetItem(s))
s = u""+child.attrib["priceForUnit"]+u"Kè"
self.tableView.setItem(ix, 1, QTableWidgetItem(s))
self.tableView.setItem(ix, 2, QTableWidgetItem(child.attrib["weight"]+child.attrib["unitDescription"]))
self.tableView.setItem(ix, 3, QTableWidgetItem(unicode(u""+child.attrib["description"])))
def create_rows(self, users):
self.users_table.setRowCount(len(users))
for i in range(len(users)):
name = QTableWidgetItem(users[i].name)
surname = QTableWidgetItem(users[i].surname)
job = QTableWidgetItem(users[i].job)
self.users_table.setItem(i, 0, name)
self.users_table.setItem(i, 1, surname)
self.users_table.setItem(i, 2, job)
def __init__(self):
####
logger.info('Inside MenuDetails')
self.menudetail_tab_1 = QWidget()
self.menudetail_tab_1.setObjectName("menudetail_tab_1")
self.gridLayout_20 = QGridLayout(self.menudetail_tab_1)
self.gridLayout_20.setObjectName("gridLayout_20")
self.menu_table = QTableWidget(self.menudetail_tab_1)
self.menu_table.setSortingEnabled(True)
self.menu_table.setObjectName("menu_table")
self.menu_table.setColumnCount(4)
self.menu_table.setRowCount(0)
item = QTableWidgetItem()
self.menu_table.setHorizontalHeaderItem(0, item)
item = QTableWidgetItem()
self.menu_table.setHorizontalHeaderItem(1, item)
item = QTableWidgetItem()
self.menu_table.setHorizontalHeaderItem(2, item)
item = QTableWidgetItem()
self.menu_table.setHorizontalHeaderItem(3, item)
self.menu_table.horizontalHeader().setCascadingSectionResizes(False)
self.menu_table.horizontalHeader().setStretchLastSection(True)
self.menu_table.verticalHeader().setVisible(True)
self.menu_table.verticalHeader().setCascadingSectionResizes(True)
self.gridLayout_20.addWidget(self.menu_table, 0, 0, 1, 2)
spacerItem22 = QSpacerItem(612, 20, QSizePolicy.Expanding, QSizePolicy.Minimum)
self.gridLayout_20.addItem(spacerItem22, 1, 0, 1, 1)
self.menu_table_add_button = QPushButton(self.menudetail_tab_1)
self.menu_table_add_button.setObjectName("menu_table_add_button")
self.gridLayout_20.addWidget(self.menu_table_add_button, 1, 1, 1, 1)
####retranslate
self.menu_table.horizontalHeaderItem(0).setText(
QApplication.translate("MainWindow", "Code", None, QApplication.UnicodeUTF8))
self.menu_table.horizontalHeaderItem(1).setText(
QApplication.translate("MainWindow", "Item", None, QApplication.UnicodeUTF8))
self.menu_table.horizontalHeaderItem(2).setText(
QApplication.translate("MainWindow", "Category", None, QApplication.UnicodeUTF8))
self.menu_table.horizontalHeaderItem(3).setText(
QApplication.translate("MainWindow", "Rate", None, QApplication.UnicodeUTF8))
self.menu_table_add_button.setText(
QApplication.translate("MainWindow", "Add New Dish", None, QApplication.UnicodeUTF8))
# self.menu_table_add_button.setShortcut(
# QApplication.translate("MainWindow", "Ctrl+E", None, QApplication.UnicodeUTF8))
###signals and slots && other stuffs
# self.mainwindow = Ui_MainWindow # just for the ease of finding the attributes in pycharm
self.menu = MenuProduct()
self.menu_table_add_button.clicked.connect(self.add_menu)
self.menu_table.itemDoubleClicked.connect(self.popup_edit)
self.menu_table.setSelectionBehavior(QAbstractItemView.SelectRows)
self.menu_table.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.menu_table.setShowGrid(False)
self.menu_table.setAlternatingRowColors(True)
self.update_menu()
self.popup = object
self.menudetail_tab_1.setFocusPolicy(Qt.StrongFocus)
self.menudetail_tab_1.focusInEvent = self.load_rows
self.assign_shortcuts()
def createCustomEntry(self, model):
"""
:type model: TypeEntry
:rtype: QTableWidgetItem
"""
return [
QTableWidgetItem(model.name),
QTableWidgetItem(str(model.news))
]
def _addObjectToTable(self, row, name, obj):
typeName = obj.typeName
print(typeName)
print(name)
tableItem = QTableWidgetItem(name)
tableItem.setCheckState(Qt.Checked)
self._ui.tableWidget.setItem(row,
self.objectTableHeaderColumns['visible'],
tableItem)
self._ui.tableWidget.setItem(row,
self.objectTableHeaderColumns['type'],
QTableWidgetItem(typeName))
def _refresh_table(self):
self._keylist = Key.list()
self.ui.table1.setRowCount(len(self._keylist))
for row, key in enumerate(self._keylist):
self.ui.table1.setItem(row, 0, QTableWidgetItem(str(key.id)))
self.ui.table1.setItem(row, 1, QTableWidgetItem(key.name))
self.ui.table1.setItem(row, 2, QTableWidgetItem(key.data_hex))
self.ui.table1.resizeColumnsToContents()
self.ui.table1.clearSelection()
def updateDictView(self, varible_settings):
i = 0
self.clearDict() # will clear contents, but leave row text empty
N = self.tableWidget.rowCount()
for k,v in varible_settings.items():
# translate seq into unicode
if i>=N:
self.tableWidget.insertRow(i)
kitem = QTableWidgetItem(k) # also set flags and state, type
vitem = QTableWidgetItem(v) # automaticall convert str to unicode to feed QWidget?
self.tableWidget.setItem(i, 0, kitem)
self.tableWidget.setItem(i, 1, vitem) # currently only works for string value !
i += 1
def del_device(self):
"""
delete all devices
"""
global deviceList
deviceList = []
common.Log.info("delete all devices")
deviceObj = device.Device()
deviceObj.del_device()
for i in range(2):
self.device.setItem(i, 0, QTableWidgetItem(""))
for j in range(2):
self.device.setItem(i, j, QTableWidgetItem(""))
self.statusEdit.setText("")
def updateDictView(self, varible_settings):
i = 0
self.clearDict() # will clear contents, but leave row text empty
N = self.tableWidget.rowCount()
for k, v in varible_settings.items():
# translate seq into unicode
if i >= N:
self.tableWidget.insertRow(i)
kitem = QTableWidgetItem(
unicode(k)) # also set flags and state, type
vitem = QTableWidgetItem(unicode(v))
#print(i, self.tableWidget.item(i, 0)) # debug: None
self.tableWidget.setItem(i, 0, kitem)
self.tableWidget.setItem(i, 1, vitem)
i += 1
def widgets(self):
access_type_str = self._variable_access.access_type
ident_str = self._variable_access.variable.ident
widgets = [
QTableWidgetItem(access_type_str),
QTableWidgetItem(ident_str),
QTableWidgetItem(AddressTableWidgetItem(self._variable_access.location.ins_addr)),
QTableWidgetItem("TODO"),
]
for w in widgets:
w.setFlags(w.flags() & ~Qt.ItemIsEditable)
return widgets
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 _configureTable(self, item):
# setup the various columns
self.setColumnCount(
len(item)
) # TODO: this might be buggy to set the columns only from the first item, which might be incomplete
images_in_item = "images" in item.keys(
) #the item may not have images_in_item
ordered_item = collections.OrderedDict()
keys = item.keys()
if images_in_item:
keys.remove("images")
self._images_in_items = True
keys.sort(key=lambda key: key.lower())
# bring the images key to be the first
if images_in_item: keys = ["images"] + keys
for key in keys:
ordered_item[key] = item[key]
headers = []
self._orig_headers = keys[
1:] if self._images_in_items else keys # those are the headers before using capital first and so on
for key in keys:
first, rest = key[0], key[1:]
header = first.upper() + rest.lower()
headers.append(header)
self._headers = headers
for (i, header) in enumerate(headers):
self.setHorizontalHeaderItem(i, QTableWidgetItem(header))
self.horizontalHeader().setMovable(True)
def _addObjectToTable(self, row, name, obj, checked=True):
typeName = obj.typeName
# print(typeName)
# print(name)
tableItem = QTableWidgetItem(name)
if checked:
tableItem.setCheckState(Qt.Checked)
else:
tableItem.setCheckState(Qt.Unchecked)
self._ui.tableWidget.setItem(row,
self.objectTableHeaderColumns['visible'],
tableItem)
self._ui.tableWidget.setItem(row,
self.objectTableHeaderColumns['type'],
QTableWidgetItem(typeName))
def _addTableItem(self, row, col, text=None):
tableItem = QTableWidgetItem()
if text is not None:
tableItem.setText(text)
self.table.setItem(row, col, tableItem)
return tableItem
