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 _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 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 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)