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 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):
self.num_planets += 1
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(True)
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):
self.setWindowTitle(time.ctime(time.time()))
row = 0
for (user, _, _, _) in VIDEO:
# index=0
for index, info in enumerate(result):
if user == info[0]:
self.insertRow(row)
for column in range(4):
item = QTableWidgetItem(info[column])
if info[4]:
item.setForeground(QBrush(QColor(255, 0, 0)))
self.setItem(row, column, item)
result.pop(index)
break
# index+=1
row += 1
# for info in result:
# self.insertRow(row)
# for column in range(4):
# item = QTableWidgetItem(info[column])
# if info[4]:
# item.setForeground(QBrush(QColor(255,0,0)))
# self.setItem(row, column, item)
# row +=1
self.resizeColumnsToContents()
self.setFixedSize(self.horizontalHeader().length() + 30,
self.verticalHeader().length() + 30)
self.show()
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 _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 _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 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 _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 _addTableItem(self, row, col, text=None):
tableItem = QTableWidgetItem()
if text is not None:
tableItem.setText(text)
self.table.setItem(row, col, tableItem)
return tableItem
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 append(self, l):
r = self.rowCount()
self.insertRow(r)
for i, x in enumerate(l):
item = QTableWidgetItem("%s" % x)
item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable)
self.setItem(r, i, item)
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 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 _addTableItem(self, row, col, text=None):
tableItem = QTableWidgetItem()
if text is not None:
tableItem.setText(text)
self.table.setItem(row, col, tableItem)
return tableItem
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 _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 _addObjectToTable(self, row, name, checked=True):
tableItem = QTableWidgetItem(name)
if checked:
tableItem.setCheckState(Qt.Checked)
else:
tableItem.setCheckState(Qt.Unchecked)
self._ui.tableWidget.setItem(row, self.objectTableHeaderColumns['visible'], tableItem)
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 __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 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 append_row(self, cols, element_id=None):
rowCount = self.list.rowCount()
self.list.insertRow(rowCount)
for index, value in enumerate(cols):
col = QTableWidgetItem(value)
col.element_id = element_id
col.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
self.list.setItem(rowCount, index, col)
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 createCustomEntry(self, model):
"""
:type model: TypeEntry
:rtype: QTableWidgetItem
"""
return [
QTableWidgetItem(model.name),
QTableWidgetItem(str(model.news))
]
def _addObjectToTable(self, row, name, obj, checked=True):
typeName = obj.typeName
print 'adding to table: %s (%s)'%(name, typeName)
tableItem = QTableWidgetItem(name)
if checked:
tableItem.setCheckState(Qt.Checked)
else:
tableItem.setCheckState(Qt.Unchecked)
self._ui.tableWidget.setItem(row, self.objectTableHeaderColumns['landmarks'], tableItem)
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 _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 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 _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 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 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 _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 weekly_cell_clicked(self, row, col):
'''
weekly play cell clicked
:param row:
:param col:
:return:
'''
item = self.weekly_tw.item(row, col)
if item is None or item.text() == '':
day = self.weekly_vert_header_labels[self.lang_tag][row]
title = {'en': 'Enter new Meal', 'de': 'Neue Mahlzeit hinzufügen'}
message = {
'en':
'Please enter the meal and link for %s' % day,
'de':
'Bitte geben sie ein Gericht und entsprechenden Link für den %s ein'
% day
}
buttons = {
'en': ('Cancel', 'Accept'),
'de': ('Abbrechen', 'Annehmen')
}
# TODO: handle links
self.mid.change_settings(
title[self.lang_tag], message[self.lang_tag], "Name", "Links",
(buttons[self.lang_tag][0], buttons[self.lang_tag][1]),
lambda x, y: self.weekly_tw.setItem(row, col,
QTableWidgetItem(x)))
self.mid.show()
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 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 _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 = 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 add_row(self, *args):
"""add new row entries"""
table = self.menu_table
if args:
table.setRowCount(len(args))
for i, j in enumerate(args):
item = QTableWidgetItem(j['item_no'])
table.setItem(i, 0, item)
item = QTableWidgetItem(j['item'])
table.setItem(i, 1, item)
item = QTableWidgetItem(j['category'])
table.setItem(i, 2, item)
item = QTableWidgetItem(j['rate'])
table.setItem(i, 3, item)
table.setColumnWidth(0, table.width() / 4)
table.setColumnWidth(1, table.width() / 4)
table.setColumnWidth(2, table.width() / 4)
def bacode_scanned(self):
code_text = self.code_ed.text()
if len(code_text.strip()) == 0:
return
self.code_ed.clear()
row_count = self.code_tbl.rowCount()
self.code_tbl.insertRow(row_count)
self.code_tbl.setItem(row_count, 3, QTableWidgetItem(code_text))
def displayLog(self):
entries = self.controller.getLog()
self.table.clearContents()
self.table.setRowCount(len(entries))
self.table.setColumnCount(3)
self.table.setHorizontalHeaderLabels(["Time", "Severity", "Message"])
i = 0
for entry in entries:
self.table.setItem(i, 0, QTableWidgetItem(entry.asctime))
self.table.setItem(i, 1, QTableWidgetItem(entry.levelname))
self.table.setItem(i, 2, QTableWidgetItem(entry.message))
i = i + 1
self.table.resizeColumnsToContents()
self.table.horizontalHeader().setStretchLastSection(True)
self.table.scrollToBottom()
def add_messages(self, *args):
"""
Populates the Schedules when we load the tab
"""
table = self.notification_schedule_table
if args:
if args[0] != 'new':
table.clearContents()
table.setRowCount(0)
table.setRowCount(len(args))
for i, j in enumerate(args):
item = QTableWidgetItem(j['msg_id'])
table.setItem(i, 0, item)
item = QTableWidgetItem(j['date'])
table.setItem(i, 1, item)
item = QTableWidgetItem(
'Name:{}\nDesignation:{}\nAddress:{}'.format(
j['name'], j['designation'], j['address']))
table.setItem(i, 2, item)
item = QTableWidgetItem(
'Message Type:{}\nMessage:{}'.format(
j['msg_type'].title(), j['msg_body']))
table.setItem(i, 3, item)
states = QComboBox()
self.populate_states(states, j['msg_state'].title())
states.currentIndexChanged.connect(
lambda index, row=i: self.changed_state(row, index))
table.setCellWidget(i, 4, states)
elif args[0] == 'new':
initial = table.rowCount()
row = table.rowCount() + len(args[1])
table.setRowCount(row)
forward_range = range(initial, row)
for i, j in zip(forward_range, args[1]):
item = QTableWidgetItem(j['msg_id'])
table.setItem(i, 0, item)
item = QTableWidgetItem(j['date'])
table.setItem(i, 1, item)
item = QTableWidgetItem(
'Name:{}\nDesignation:{}\nAddress:{}'.format(
j['name'], j['designation'], j['address']))
table.setItem(i, 2, item)
item = QTableWidgetItem(
'Message Type:{}\nMessage:{}'.format(
j['msg_type'].title(), j['msg_body']))
table.setItem(i, 3, item)
states = QComboBox()
self.populate_states(states, j['msg_state'].title())
states.currentIndexChanged.connect(
lambda index, row=i: self.changed_state(row, index))
table.setCellWidget(i, 4, states)
table.setColumnWidth(0, (table.width() * 0.5) / 5)
table.setColumnWidth(1, (table.width() * 0.5) / 5)
table.setColumnWidth(2, table.width() / 5)
table.setColumnWidth(3, (table.width() * 2) / 5)
self.notification_schedule_table.resizeRowsToContents()
def on_addFilesButton_clicked(self):
if len(self.tags) == 0:
QMessageBox.critical(self, u'错误', u'请先添加至少一个类别')
else:
addedFiles = QFileDialog.getOpenFileNames(self, u'选择文件')[0]
tag = self.selectedTag.currentText()
for idx, filePath in enumerate(addedFiles):
if filePath in self.files: continue
fileName = os.path.split(filePath)[1]
self.file_tag_map[fileName] = tag
self.tags_files_table.insertRow(self.files_count + idx)
self.tags_files_table.setItem(self.files_count + idx, 0,
QTableWidgetItem(tag))
self.tags_files_table.setItem(self.files_count + idx, 1,
QTableWidgetItem(fileName))
self.files.extend(addedFiles)
self.files_count = len(self.files)
def _add_or_modify_change(self, objname, prop, value, type, row_number=-1):
table = self.form.changesView
if row_number < 0:
row_count = table.rowCount()
row_number = row_count
table.insertRow(row_number)
table.setItem(row_number, 0, QTableWidgetItem())
table.setItem(row_number, 1, QTableWidgetItem())
table.setItem(row_number, 2, QTableWidgetItem())
table.item(row_number, 0).setText(objname)
table.item(row_number, 1).setText(prop)
val_item = table.item(row_number, 2)
# A lil' HACK. Store the value type as tooltip so we can retrieve it later :)
val_item.setText(value)
val_item.setToolTip(type)
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 coloredTableWidgetItem(self, text, color, userData=None):
item = QTableWidgetItem(text)
item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable)
item.setForeground(color)
if userData:
item.setData(Qt.UserRole, userData)
return item
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 setDataInTable(self, tab):
Icol = 0
if self.ndb:
data_dic = self.mysql.dataCol(self.ndb, tab)
cols = self.mysql.getColumns(self.ndb, tab)
self.table.setColumnCount(len(cols))
if data_dic != None:
self.table.setRowCount(int(data_dic[1]))
for col in cols:
item = QTableWidgetItem
self.table.setHorizontalHeaderItem(Icol, item(col))
Irow = 0
for row in data_dic[0][col]:
self.item = QTableWidgetItem(str(row))
self.item.setFont(QFont("andalus", 12))
self.table.setItem(Irow, Icol, self.item)
Irow += 1
Icol += 1
def _showAllFunctions(self):
"""
Populates the functions list.
From this it is possible to select endpoints to
create a ConnectGraph for example
"""
self._console_output("Displaying all known functions...")
current_ea, _ = misc.function_boundaries()
func_list = self.ba.get_all_functions()
if not func_list:
return
self.table.setColumnCount(2)
self.table.setHorizontalHeaderLabels(("Address", "Name"))
self.table_label.setText("Functions in current binary")
self.table.clearContents()
self.table.setRowCount(0)
# Current table index
c_idx = 0
for idx, (f_ea, f_name) in enumerate(func_list):
self.table.insertRow(idx)
addr_item = QTableWidgetItem("%08x" % f_ea)
addr_item.setFlags(addr_item.flags() ^ QtCore.Qt.ItemIsEditable)
name_item = QTableWidgetItem("%s" % f_name)
if f_ea == current_ea:
current_ea_item = addr_item
c_idx = idx
self.table.setItem(idx, 0, addr_item)
self.table.setItem(idx, 1, name_item)
# Conveniently scroll to the current EA
self.table.scrollToItem(
#current_ea_item,
self.table.item(c_idx, 0),
QtGui.QAbstractItemView.PositionAtTop
)
def onScanFinish(self, normalTermination):
global infectionsList
self.theScanWorker.sigWriteScan.disconnect()
# infectionsList = []
print("Entering onScanFinish, from signalManager, normalTermination = " + str(normalTermination))
if hasattr(self, 'theScanWorker'):
self.theScanWorker.exit()
while not self.theScanWorker.wait():
print("Waiting for scan worker to finish")
self._theMainWindow.theScan.theScanProgress.btnExitScan.setText(langmodule.btnExitUpdateProgTitle)
if hasattr(self, 'theScanWorker'):
del self.theScanWorker
print("The Scan Worker is being Deleted")
else:
print("The Scan Worker Was Already Deleted")
try:
lockerFinish = QMutexLocker(mutexTermination)
if normalTermination=="True":
if infectionsList:
header1 = QTableWidgetItem("Threats")
header2 = QTableWidgetItem(("Files"))
self._theMainWindow.theScan.theScanProgress.theShowScanResults.tableWidget.setColumnCount(2)
self._theMainWindow.theScan.theScanProgress.theShowScanResults.tableWidget.setRowCount(len(infectionsList))
self._theMainWindow.theScan.theScanProgress.theShowScanResults.tableWidget.setHorizontalHeaderItem(0, header1)
self._theMainWindow.theScan.theScanProgress.theShowScanResults.tableWidget.setHorizontalHeaderItem(1, header2)
self._theMainWindow.theScan.theScanProgress.theShowScanResults.tableWidget.horizontalHeader().setStretchLastSection(True)
for i in range(1, len(infectionsList) + 1):
newItem0 = QTableWidgetItem(infectionsList[i-1])
newItem1 = QTableWidgetItem(infectedFiles[i-1])
print("line " + str(i) + ": " + newItem0.text())
print("line " + str(i) + ": " + newItem1.text())
self._theMainWindow.theScan.theScanProgress.theShowScanResults.tableWidget.setItem(i-1, 0, newItem0)
self._theMainWindow.theScan.theScanProgress.theShowScanResults.tableWidget.setItem(i-1, 1, newItem1)
self._theMainWindow.theScan.theScanProgress.theShowScanResults.tableWidget.resizeColumnsToContents()
self._theMainWindow.theScan.theScanProgress.theShowScanResults.show()
self.theSQLITEWorker.start()
except Exception as errmut2:
print(str(errmut2))
exit(-1)
gc.collect()
def populateUiSearchResult(self, results):
self.tblSearchResult.clearContents()
self.tblSearchResult.setRowCount(len(results))
for row in range(len(results)):
newItem = QTableWidgetItem()
newItem.setCheckState(Qt.Unchecked)
self.tblSearchResult.setItem(row, 0, newItem)
newTitle = QTableWidgetItem(results[row].getTitle().split("_免费高速下载")[0])
self.tblSearchResult.setItem(row, 1, newTitle)
print QTableWidgetItem(results[row].getContent())
filesize = results[row].getContent().split(" 分享者")[0].split(' 文件大小:')[1].strip()
newDesc = QTableWidgetItem(filesize)
self.tblSearchResult.setItem(row, 2, newDesc)
newUrl = QTableWidgetItem(results[row].getURL())
self.tblSearchResult.setItem(row, 3, newUrl)
pass
def _commentsInThisFunction(self):
"""
Shows all comments within the current function
"""
show_unique_c = self.config.display_unique_comments
msg = "Searching comments within function '" + \
misc.get_function_name() + "'"
self._console_output(msg)
comment_list = self.ba.comments_in_function()
# Found any comment at all?
nrows = len(comment_list)
if not nrows:
self._console_output("[!] No comments found", err = True)
return
self.table.setColumnCount(2)
self.table_label.setText("Comments within current function")
self.table.setHorizontalHeaderLabels(("Address", "Comments"))
self.table.clearContents()
self.table.setRowCount(0)
# Fill with contents
displayed_comments = []
idx = 0
for (addr, comment) in comment_list:
if show_unique_c and comment in displayed_comments:
continue
displayed_comments.append(comment)
self.table.insertRow(idx)
addr_item = QTableWidgetItem("%08x" % addr)
addr_item.setFlags(addr_item.flags() ^ QtCore.Qt.ItemIsEditable)
comment_item = QTableWidgetItem(comment)
self.table.setItem(idx, 0, addr_item)
self.table.setItem(idx, 1, comment_item)
idx += 1
def _showConnectedBBs(self):
"""
Shows a list of paths between selected basic blocks
"""
self._console_output("Calculating paths between basic blocks...")
bb_paths = self.ba.get_bb_connect_graph(self.config.connect_bb_cutoff)
if not bb_paths:
self._console_output("[!] Could not find paths between \
basic blocks", err = True)
return
self.table.setColumnCount(2)
self.table.setHorizontalHeaderLabels(("Path ID", "Length"))
# Override the default double click callback
self.table.cellDoubleClicked.connect(self._bbTableDoubleClicked)
self.table_label.setText("Paths between Basic Blocks")
self.table.clearContents()
self.table.setRowCount(0)
bb_paths_l = list(bb_paths) # To reference by index :)
if len(bb_paths_l) == 0:
self._console_output("[!] Could not find paths. \
Try increasing cutoff under Options", err = True)
return
for idx, path in enumerate(bb_paths_l):
self.table.insertRow(idx)
path_item = QTableWidgetItem("%d" % idx)
path_item.setFlags(path_item.flags() ^ QtCore.Qt.ItemIsEditable)
len_item = cw.NumQTableWidgetItem("%d" % len(path))
len_item.setFlags(len_item.flags() ^ QtCore.Qt.ItemIsEditable)
self.table.setItem(idx, 0, path_item)
self.table.setItem(idx, 1, len_item)
# Cache this
self.ba.cache.bb_paths = bb_paths_l
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()
nrows = len(callee_list)
if not nrows:
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)
self.table.setItem(idx, 0, addr_item)
self.table.setItem(idx, 1, callee_item)
idx += 1
def setData(self, role, value):
""" Set Data in Item """
if role == Qt.EditRole:
dataSaved = self.saveData(value)
if dataSaved:
for callback in self.callbacks:
callback()
if self.shouldSetData(role):
try:
return QTableWidgetItem.setData(self, role, self.getData())
except RuntimeError:
pass
def insert_row(self, row, list_of_data):
self.insertRow(row)
for c, data_item in enumerate(list_of_data):
qtype = self.get_qtype(data_item)
newItem = QTableWidgetItem(type=qtype)
if type(data_item) == str:
newItem.setText(data_item)
else:
newItem.setData(QtCore.Qt.DisplayRole, data_item)
newItem.setFont(QFont("Helvetica", 12))
self.setItem(row, c, newItem)
def _showIntegerIssues(self):
"""
This is the GUI part of the integer issues functionality
"""
self._console_output("Looking for integer issues (comparisons)")
try:
integer_issues_ins = self.ii.search_integer_issues()
except NotImplementedError:
self._console_output("[!] x86_64 not implemented yet", err = True)
return
# Is there any integer issues at all?
nrows = len(integer_issues_ins)
if not nrows:
self._console_output("[-] No integer issues found.")
return
self.table.setColumnCount(3)
self.table_label.setText("Possible integer issues")
self.table.setHorizontalHeaderLabels(
('Address', 'Function name', 'Notes'))
self.table.clearContents()
self.table.setRowCount(0)
# Fill with contents
for idx, ins_ea in enumerate(integer_issues_ins):
self.table.insertRow(idx)
addr_item = QTableWidgetItem("%x" % ins_ea)
addr_item.setFlags(addr_item.flags() ^ QtCore.Qt.ItemIsEditable)
name_item = QTableWidgetItem(misc.get_function_name(ins_ea))
mnem_item = QTableWidgetItem("") # placeholder
self.table.setItem(idx, 0, addr_item)
self.table.setItem(idx, 1, name_item)
self.table.setItem(idx, 2, mnem_item)
def __init__(self, messages, hiddenLifelines, parent = None):
super(HiddenMessageDialog, self).__init__(parent)
self.lifelineList = hiddenLifelines
self.msgList = messages
layout = QVBoxLayout(self)
listTitle = QLabel('Hidden Messages')
layout.addWidget(listTitle)
self.listHiddenMessages = QtGui.QTableWidget(len(self.msgList),4)
self.listHiddenMessages.setHorizontalHeaderLabels(['Index','Name','Departure','Destination'])
self.listHiddenMessages.setFixedWidth(400)
#self.listHiddenMessages.setSelectionMode(QtGui.QAbstractItemView.MultiSelection)
self.listHiddenMessages.setSelectionBehavior(QAbstractItemView.SelectRows)
for idx, msg in enumerate(self.msgList):
self.listHiddenMessages.setItem(idx,0,QTableWidgetItem("%d" % msg['messageindex']))
self.listHiddenMessages.setItem(idx,1,QTableWidgetItem(msg['message']))
item = QTableWidgetItem(msg['departure']['class'])
item.setTextAlignment(QtCore.Qt.AlignmentFlag.AlignRight)
if msg['departure']['class'] in self.lifelineList:
item.setForeground(QColor(200,200,200))
self.listHiddenMessages.setItem(idx,2,item)
item = QTableWidgetItem(msg['dest'])
item.setTextAlignment(QtCore.Qt.AlignmentFlag.AlignRight)
if msg['dest'] in self.lifelineList:
item.setForeground(QColor(200,200,200))
self.listHiddenMessages.setItem(idx,3,item)
layout.addWidget(self.listHiddenMessages)
buttons = QtGui.QDialogButtonBox(QtGui.QDialogButtonBox.Ok | QtGui.QDialogButtonBox.Cancel, QtCore.Qt.Horizontal, self)
buttons.button(QDialogButtonBox.Ok).setText('Show')
buttons.accepted.connect(self.accept)
buttons.rejected.connect(self.reject)
layout.addWidget(buttons)
def setUpTable(self):
self.table.horizontalHeader().setVisible(False)
for i in xrange(0, 26, 1):
self.vhfont = QFont('Times', pointSize = 10, weight=QFont.Bold)
timePos = i+6
if i == 0:
item = QTableWidgetItem(u'[標題]')
elif i == 1:
item = QTableWidgetItem(u'[設定]')
elif 2 < timePos < 24:
item = QTableWidgetItem(('{0}~{1}').format(timePos, timePos+1))
else:
item = QTableWidgetItem(('{0}~{1}').format(timePos-24, timePos-23))
item.setFont(self.vhfont)
item.setTextAlignment(Qt.AlignCenter)
self.table.setVerticalHeaderItem(i, item)
def __loadUsers(self):
"""Loads user's data from DB"""
users = self.parentWidget().app.getUsers()
self.user_table.clearContents()
self.user_table.setRowCount(len(users))
for i in range(len(users)):
username_item = QTableWidgetItem(users[i].username)
username_item.setFlags(username_item.flags() ^ Qt.ItemIsEditable)
blocked_checkbox = QCheckBox()
if users[i].blocked:
blocked_checkbox.setChecked(True)
def create_blocked_toggle(checkbox, user):
def blocked_toggle():
user.blocked = (1 if checkbox.isChecked() else 0)
self.parentWidget().app.updateUser(user)
self.__loadUsers()
return blocked_toggle
blocked_checkbox.toggled.connect(create_blocked_toggle(blocked_checkbox, users[i]))
password_restrict_checkbox = QCheckBox()
if users[i].restrictions:
password_restrict_checkbox.setChecked(True)
def create_password_restrict_toggle(checkbox, user):
def password_restrict_toggle():
user.restrictions = (1 if checkbox.isChecked() else 0)
self.parentWidget().app.updateUser(user)
self.__loadUsers()
return password_restrict_toggle
password_restrict_checkbox.toggled.connect(
create_password_restrict_toggle(password_restrict_checkbox, users[i]))
self.user_table.setItem(i, 0, username_item)
self.user_table.setCellWidget(i, 1, blocked_checkbox)
self.user_table.setCellWidget(i, 2, password_restrict_checkbox)
