def load(self, highlights):
s = self.style()
icon_size = s.pixelMetric(s.PM_SmallIconSize, None, self)
dpr = self.devicePixelRatioF()
is_dark = is_dark_theme()
self.clear()
self.uuid_map = {}
highlights = (h for h in highlights
if not h.get('removed') and h.get('highlighted_text'))
section_map = defaultdict(list)
section_tt_map = {}
for h in self.sorted_highlights(highlights):
tfam = h.get('toc_family_titles') or ()
if tfam:
tsec = tfam[0]
lsec = tfam[-1]
else:
tsec = h.get('top_level_section_title')
lsec = h.get('lowest_level_section_title')
sec = lsec or tsec or _('Unknown')
if len(tfam) > 1:
lines = []
for i, node in enumerate(tfam):
lines.append('\xa0\xa0' * i + '➤ ' + node)
tt = ngettext('Table of Contents section:',
'Table of Contents sections:', len(lines))
tt += '\n' + '\n'.join(lines)
section_tt_map[sec] = tt
section_map[sec].append(h)
for secnum, (sec, items) in enumerate(section_map.items()):
section = QTreeWidgetItem([sec], 1)
section.setFlags(Qt.ItemIsEnabled)
section.setFont(0, self.section_font)
tt = section_tt_map.get(sec)
if tt:
section.setToolTip(0, tt)
self.addTopLevelItem(section)
section.setExpanded(True)
for itemnum, h in enumerate(items):
txt = h.get('highlighted_text')
txt = txt.replace('\n', ' ')
if len(txt) > 100:
txt = txt[:100] + '…'
item = QTreeWidgetItem(section, [txt], 2)
item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled
| Qt.ItemNeverHasChildren)
item.setData(0, Qt.UserRole, h)
try:
dec = decoration_for_style(self.palette(),
h.get('style') or {}, icon_size,
dpr, is_dark)
except Exception:
import traceback
traceback.print_exc()
dec = None
if dec is None:
dec = self.default_decoration
item.setData(0, Qt.DecorationRole, dec)
self.uuid_map[h['uuid']] = secnum, itemnum
self.num_of_items += 1
def add_result(self, result):
section_title = _('Unknown')
section_id = -1
toc_nodes = getattr(result, 'toc_nodes', ()) or ()
if toc_nodes:
section_title = toc_nodes[-1].get('title') or _('Unknown')
section_id = toc_nodes[-1].get('id')
if section_id is None:
section_id = -1
section_key = section_id
section = self.section_map.get(section_key)
if section is None:
section = QTreeWidgetItem([section_title], 1)
section.setFlags(Qt.ItemIsEnabled)
section.setFont(0, self.section_font)
lines = []
for i, node in enumerate(toc_nodes):
lines.append('\xa0\xa0' * i + '➤ ' + (node.get('title') or _('Unknown')))
tt = ngettext('Table of Contents section:', 'Table of Contents sections:', len(lines))
tt += '\n' + '\n'.join(lines)
section.setToolTip(0, tt)
self.section_map[section_key] = section
self.addTopLevelItem(section)
section.setExpanded(True)
item = QTreeWidgetItem(section, [' '], 2)
item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled | Qt.ItemNeverHasChildren)
item.setData(0, Qt.UserRole, result)
item.setData(0, Qt.UserRole + 1, len(self.search_results))
item.setIcon(0, self.blank_icon)
self.item_map[len(self.search_results)] = item
self.search_results.append(result)
n = self.number_of_results
self.count_changed.emit(n)
return n
def set_results(self, results, emphasize_text):
self.clear()
self.delegate.emphasize_text = emphasize_text
self.number_of_results = 0
self.item_map = []
book_id_map = {}
db = current_db()
for result in results:
book_id = result['book_id']
if book_id not in book_id_map:
book_id_map[book_id] = {
'title': db.field_for('title', book_id),
'matches': []
}
book_id_map[book_id]['matches'].append(result)
for book_id, entry in book_id_map.items():
section = QTreeWidgetItem([entry['title']], 1)
section.setFlags(Qt.ItemIsEnabled)
section.setFont(0, self.section_font)
self.addTopLevelItem(section)
section.setExpanded(True)
for result in entry['matches']:
item = QTreeWidgetItem(section, [' '], 2)
self.item_map.append(item)
item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled
| Qt.ItemNeverHasChildren)
item.setData(0, Qt.UserRole, result)
item.setData(0, Qt.UserRole + 1, self.number_of_results)
self.number_of_results += 1
if self.item_map:
self.setCurrentItem(self.item_map[0])
def create_item(self, parent, child, idx=-1):
if idx == -1:
c = QTreeWidgetItem(parent)
else:
c = QTreeWidgetItem()
parent.insertChild(idx, c)
self.populate_item(c, child)
return c
def setupQuestTree(self, questMan, treeWd):
activeRoot = QTreeWidgetItem(treeWd, [StrUtil.tStr(StrUtil.QUEST_ACTIVE)])
for q in questMan.activeQuests:
item = QTreeWidgetItem(activeRoot, [StrUtil.tStr(q.getTitle())])
item.setData(0, Qt.UserRole, (q,))
completedRoot = QTreeWidgetItem(treeWd, [StrUtil.tStr(StrUtil.QUEST_COMPLETED)])
for q in questMan.finishedQuests:
item = QTreeWidgetItem(completedRoot, [StrUtil.tStr(q.getTitle())])
item.setData(0, Qt.UserRole, (q,))
treeWd.expandItem(activeRoot)
def add_result(self, result):
section_title = _('Unknown')
section_id = -1
toc_nodes = getattr(result, 'toc_nodes', ()) or ()
if toc_nodes:
section_title = toc_nodes[-1].get('title') or _('Unknown')
section_id = toc_nodes[-1].get('id')
if section_id is None:
section_id = -1
section_key = section_id
section = self.section_map.get(section_key)
spine_idx = getattr(result, 'spine_idx', -1)
if section is None:
section = QTreeWidgetItem([section_title], 1)
section.setFlags(Qt.ItemFlag.ItemIsEnabled)
section.setFont(0, self.section_font)
section.setData(0, SPINE_IDX_ROLE, spine_idx)
lines = []
for i, node in enumerate(toc_nodes):
lines.append('\xa0\xa0' * i + '➤ ' +
(node.get('title') or _('Unknown')))
if lines:
tt = ngettext('Table of Contents section:',
'Table of Contents sections:', len(lines))
tt += '\n' + '\n'.join(lines)
section.setToolTip(0, tt)
self.section_map[section_key] = section
for s in range(self.topLevelItemCount()):
ti = self.topLevelItem(s)
if ti.data(0, SPINE_IDX_ROLE) > spine_idx:
self.insertTopLevelItem(s, section)
break
else:
self.addTopLevelItem(section)
section.setExpanded(True)
item = QTreeWidgetItem(section, [' '], 2)
item.setFlags(Qt.ItemFlag.ItemIsSelectable | Qt.ItemFlag.ItemIsEnabled
| Qt.ItemFlag.ItemNeverHasChildren)
item.setData(0, SEARCH_RESULT_ROLE, result)
item.setData(0, RESULT_NUMBER_ROLE, len(self.search_results))
item.setData(0, SPINE_IDX_ROLE, spine_idx)
if isinstance(result, SearchResult):
tt = '<p>…' + escape(result.before, False) + '<b>' + escape(
result.text, False) + '</b>' + escape(result.after,
False) + '…'
item.setData(0, Qt.ItemDataRole.ToolTipRole, tt)
item.setIcon(0, self.blank_icon)
self.item_map[len(self.search_results)] = item
self.search_results.append(result)
n = self.number_of_results
self.count_changed.emit(n)
return n
def update_motor_tree(self, baud_for_ids):
self.window.motor_tree.clear()
for b, ids in baud_for_ids.items():
baud_root = QTreeWidgetItem(self.window.motor_tree, [str(b)])
baud_root.setExpanded(True)
f = int(baud_root.flags()) - int(QtCore.Qt.ItemIsSelectable)
baud_root.setFlags(QtCore.Qt.ItemFlags(f))
dxl_io = get_dxl_connection(self.port, b, self.protocol)
models = dxl_io.get_model(ids)
release_dxl_connection()
for id, model in zip(ids, models):
QTreeWidgetItem(baud_root, ['', str(id), model])
def setup_ui(self):
self.l = l = QVBoxLayout(self)
self.setLayout(l)
self.msg = m = QLabel(self.msg or _(
'Choose the folder into which the files will be placed'))
l.addWidget(m)
m.setWordWrap(True)
self.folders = f = QTreeWidget(self)
f.setHeaderHidden(True)
f.itemDoubleClicked.connect(self.accept)
l.addWidget(f)
f.setContextMenuPolicy(Qt.CustomContextMenu)
f.customContextMenuRequested.connect(self.show_context_menu)
self.root = QTreeWidgetItem(f, ('/',))
def process(node, parent):
parent.setIcon(0, QIcon(I('mimetypes/dir.png')))
for child in sorted(node, key=numeric_sort_key):
c = QTreeWidgetItem(parent, (child,))
process(node[child], c)
process(create_folder_tree(current_container()), self.root)
self.root.setSelected(True)
f.expandAll()
l.addWidget(self.bb)
def __init__(self, window, msg, formats):
'''
formats is a list of tuples: [(format, exists, convertible)].
format: Lower case format identifier. E.G. mobi
exists: String representing the number of books that
exist in the format.
convertible: True if the format is a convertible format.
formats should be ordered in the device's preferred format ordering.
'''
QDialog.__init__(self, window)
Ui_ChooseFormatDeviceDialog.__init__(self)
self.setupUi(self)
self.formats.activated[QModelIndex].connect(self.activated_slot)
self.msg.setText(msg)
for i, (format, exists, convertible) in enumerate(formats):
t_item = QTreeWidgetItem()
t_item.setIcon(0,
file_icon_provider().icon_from_ext(format.lower()))
t_item.setText(0, format.upper())
t_item.setText(1, exists)
if convertible:
t_item.setIcon(2, QIcon(I('ok.png')))
self.formats.addTopLevelItem(t_item)
if i == 0:
self.formats.setCurrentItem(t_item)
t_item.setSelected(True)
self.formats.resizeColumnToContents(2)
self.formats.resizeColumnToContents(1)
self.formats.resizeColumnToContents(0)
self.formats.header().resizeSection(
0,
self.formats.header().sectionSize(0) * 2)
self._format = None
def _init(self):
handlers = gVar.app.protocolHandlerManager().protocolHandlers()
for name, handler in handlers.items():
item = QTreeWidgetItem(self._ui.treeWidget)
item.setText(0, name)
item.setText(1, handler.host())
self._ui.treeWidget.addTopLevelItem(item)
def update_widget(self, services):
"""
Update the QTreeWidget and its items
:param services: list of :class:`Services <alignak_app.items.service.Service>` items
:type services: list
"""
self.services = services
# Update services dashboard
self.services_dashboard.update_widget(self.services)
# Clear QTreeWidget
self.services_tree_widget.clear()
self.services_tree_widget.setIconSize(QSize(16, 16))
if self.services:
# Set as "Global" aggregation who are empty
for service in self.services:
if not service.data['aggregation']:
service.data['aggregation'] = 'Global'
# First sort list by state then by aggregation
newlist = sorted(self.services,
key=lambda s: itemgetter(
'ls_state', 'ls_acknowledged', 'aggregation')
(s.data))
self.services = newlist
# Get list of aggregations
aggregations = []
for service in self.services:
if service.data['aggregation'] not in aggregations:
aggregations.append(service.data['aggregation'])
# Add QTreeWidgetItems
for aggregation in aggregations:
main_tree = QTreeWidgetItem()
main_tree.setText(0, aggregation)
main_tree.setIcon(0, QIcon(settings.get_image('tree')))
main_tree.setToolTip(0, aggregation)
for service in self.services:
if service.data['aggregation'] == aggregation:
service_tree = ServiceTreeItem()
service_tree.initialize(service)
service_tree.setToolTip(0, service.get_tooltip())
self.services_tree_widget.clicked.connect(
self.update_service_data)
main_tree.addChild(service_tree)
self.services_tree_widget.addTopLevelItem(main_tree)
self.service_data_widget.hide()
else:
# If no services, reset service item to None and hide data widget
self.service_data_widget.service_item = None
self.service_data_widget.hide()
def create_folder(self, item):
text, ok = QInputDialog.getText(self, _('Folder name'), _('Enter a name for the new folder'))
if ok and unicode_type(text):
c = QTreeWidgetItem(item, (unicode_type(text),))
c.setIcon(0, QIcon(I('mimetypes/dir.png')))
for item in self.folders.selectedItems():
item.setSelected(False)
c.setSelected(True)
self.folders.setCurrentItem(c)
def create_item(self, f, parent):
name = f.name
ans = QTreeWidgetItem(parent, [name])
ans.setData(0, Qt.UserRole, '/'.join(f.full_path[1:]))
ans.setFlags(Qt.ItemIsUserCheckable | Qt.ItemIsEnabled)
ans.setCheckState(0,
Qt.Unchecked if self.dev.is_folder_ignored(f.storage_id, f.full_path[1:]) else Qt.Checked)
ans.setData(0, Qt.DecorationRole, file_icon_provider().icon_from_ext('dir'))
return ans
def create_treeview_nodes(self, nodelist=None):
'''
append nodes into datatable treeview
'''
if nodelist:
for table in nodelist:
child = QTreeWidgetItem(self.__tb_treeview_root)
child.setText(0,table)
child.setText(1,'child')
def _connectServer(self):
self.ui.connectBtn.setEnabled(False)
host = self.ui.mongoHost.text()
if host == "":
host = "localhost"
try:
indexOfSep = host.index(":")
hostName, portStr = host.split(":")
port = int(portStr)
except ValueError as e:
hostName = host
port = 27017
try:
self.conn = pymongo.MongoClient(hostName, port)
self.showMsg("connect " + host + " success!")
self.databases = self.conn.database_names()
colsMap = {}
for db in self.databases:
colsMap[db] = self.conn[db].collection_names()
self.ui.treeWidget.clear()
treeItems = []
for db in self.databases:
dbItem = QTreeWidgetItem(self.ui.treeWidget, [db])
treeItems.append(dbItem)
cols = colsMap[db]
for col in cols:
colItem = QTreeWidgetItem(dbItem, [col])
self.ui.treeWidget.insertTopLevelItems(0, treeItems)
self.log.info(self.databases)
except Exception as e:
self.log.error(e)
errorMsg = host + " connect failed:"
self.showMsg(errorMsg)
traceback.print_exc(file=sys.stdout)
self.ui.connectBtn.setEnabled(True)
def process_node(toc, parent):
for child in toc:
node = QTreeWidgetItem(parent)
node.setText(0, child.title or '')
node.setData(0, DEST_ROLE, child.dest or '')
node.setData(0, FRAG_ROLE, child.frag or '')
tt = _('File: {0}\nAnchor: {1}').format(
child.dest or '', child.frag or _('Top of file'))
node.setData(0, Qt.ToolTipRole, tt)
process_node(child, node)
def process_duplicates(self, db, duplicates):
ta = _('%(title)s by %(author)s [%(formats)s]')
bf = QFont(self.dup_list.font())
bf.setBold(True)
itf = QFont(self.dup_list.font())
itf.setItalic(True)
for mi, cover, formats in duplicates:
# formats is a list of file paths
# Grab just the extension and display to the user
# Based only off the file name, no file type tests are done.
incoming_formats = ', '.join(
os.path.splitext(path)[-1].replace('.', '').upper()
for path in formats)
item = QTreeWidgetItem([
ta % dict(title=mi.title,
author=mi.format_field('authors')[1],
formats=incoming_formats)
], 0)
item.setCheckState(0, Qt.CheckState.Checked)
item.setFlags(Qt.ItemFlag.ItemIsEnabled
| Qt.ItemFlag.ItemIsUserCheckable)
item.setData(0, Qt.ItemDataRole.FontRole, bf)
item.setData(0, Qt.ItemDataRole.UserRole, (mi, cover, formats))
matching_books = db.books_with_same_title(mi)
def add_child(text):
c = QTreeWidgetItem([text], 1)
c.setFlags(Qt.ItemFlag.ItemIsEnabled)
item.addChild(c)
return c
add_child(_('Already in calibre:')).setData(
0, Qt.ItemDataRole.FontRole, itf)
author_text = {}
for book_id in matching_books:
author_text[book_id] = authors_to_string([
a.replace('|', ',') for a in (
db.authors(book_id, index_is_id=True) or '').split(',')
])
def key(x):
return primary_sort_key(unicode_type(author_text[x]))
for book_id in sorted(matching_books, key=key):
add_child(
ta %
dict(title=db.title(book_id, index_is_id=True),
author=author_text[book_id],
formats=db.formats(
book_id, index_is_id=True, verify_formats=False)))
add_child('')
yield item
def create_item(name, linear=None):
imt = container.mime_map.get(name, guess_type(name))
icat = get_category(name, imt)
category = 'text' if linear is not None else ({'text':'misc'}.get(icat, icat))
item = QTreeWidgetItem(self.categories['text' if linear is not None else category], 1)
flags = Qt.ItemIsEnabled | Qt.ItemIsSelectable
if category == 'text':
flags |= Qt.ItemIsDragEnabled
if name not in cannot_be_renamed:
flags |= Qt.ItemIsEditable
item.setFlags(flags)
item.setStatusTip(0, _('Full path: ') + name)
item.setData(0, NAME_ROLE, name)
item.setData(0, CATEGORY_ROLE, category)
item.setData(0, LINEAR_ROLE, bool(linear))
item.setData(0, MIME_ROLE, imt)
set_display_name(name, item)
tooltips = []
emblems = []
if name in {cover_page_name, cover_image_name}:
emblems.append('default_cover.png')
tooltips.append(_('This file is the cover %s for this book') % (_('image') if name == cover_image_name else _('page')))
if name in container.opf_name:
emblems.append('metadata.png')
tooltips.append(_('This file contains all the metadata and book structure information'))
if imt == ncx_mime or name in nav_items:
emblems.append('toc.png')
tooltips.append(_('This file contains the metadata table of contents'))
if name not in manifested_names and not container.ok_to_be_unmanifested(name):
emblems.append('dialog_question.png')
tooltips.append(_('This file is not listed in the book manifest'))
if linear is False:
emblems.append('arrow-down.png')
tooltips.append(_('This file is marked as non-linear in the spine\nDrag it to the top to make it linear'))
if linear is None and icat == 'text':
# Text item outside spine
emblems.append('dialog_warning.png')
tooltips.append(_('This file is a text file that is not referenced in the spine'))
if category == 'text' and name in processed:
# Duplicate entry in spine
emblems.append('dialog_error.png')
tooltips.append(_('This file occurs more than once in the spine'))
if category == 'fonts' and name.rpartition('.')[-1].lower() in ('ttf', 'otf'):
fname = self.get_font_family_name(name)
if fname:
tooltips.append(fname)
else:
emblems.append('dialog_error.png')
tooltips.append(_('Not a valid font'))
render_emblems(item, emblems)
if tooltips:
item.setData(0, Qt.ToolTipRole, '\n'.join(tooltips))
return item
def setMeshGroups(self, groups):
"""
Sets the mesh group list
Arguments:
groups (dict[int, list[tuple[str, int]]]): Mesh groups info.
"""
self._list.clear()
grp_types = sorted(groups.keys())
for typ in grp_types:
names = groups[typ]
if not names:
continue
title = MeshElemType.value2str(typ)
item = QTreeWidgetItem(self._list, [title])
for name, size in names:
sub_item = QTreeWidgetItem(item, [name, str(size)])
sub_item.setFlags(Qt.ItemIsUserCheckable | Qt.ItemIsEnabled)
sub_item.setCheckState(0, Qt.Unchecked)
sub_item.setTextAlignment(1, Qt.AlignRight)
self._list.expandAll()
def unserialize_node(dict_node, parent):
n = QTreeWidgetItem(parent)
n.setData(0, Qt.DisplayRole, dict_node['title'])
n.setData(0, Qt.UserRole, dict_node['toc_node'])
n.setFlags(NODE_FLAGS)
n.setData(0, Qt.DecorationRole, dict_node['icon'])
n.setData(0, Qt.ToolTipRole, dict_node['tooltip'])
self.update_status_tip(n)
n.setExpanded(dict_node['is_expanded'])
n.setSelected(dict_node['is_selected'])
for c in dict_node['children']:
unserialize_node(c, n)
def showFeaturePermissions(self, feature):
'''
@param feature QWebEnginePage::Feature
'''
if feature not in self._granted or feature not in self._denied:
return
self._ui.treeWidget.clear()
for site in self._granted[feature]:
item = QTreeWidgetItem(self._ui.treeWidget)
item.setText(0, site)
item.setText(1, _('Allow'))
item.setData(0, Qt.UserRole + 10, self.Allow)
self._ui.treeWidget.addTopLevelItem(item)
for site in self._denied[feature]:
item = QTreeWidgetItem(self._ui.treeWidget)
item.setText(0, site)
item.setText(1, _('Deny'))
item.setData(0, Qt.UserRole + 10, self.Deny)
self._ui.treeWidget.addTopLevelItem(item)
def browser_item(f, parent):
name = f.name
if not f.is_folder:
name += ' [%s]' % f.last_mod_string
ans = QTreeWidgetItem(parent, [name])
ans.setData(0, Qt.UserRole, f.full_path)
if f.is_folder:
ext = 'dir'
else:
ext = f.name.rpartition('.')[-1]
ans.setData(0, Qt.DecorationRole, file_icon_provider().icon_from_ext(ext))
return ans
def run(self):
for b in self.baudrates:
baud_root = QTreeWidgetItem(self.motor_tree, [str(b)])
baud_root.setExpanded(True)
f = int(baud_root.flags()) - int(QtCore.Qt.ItemIsSelectable)
baud_root.setFlags(QtCore.Qt.ItemFlags(f))
dxl_io = get_dxl_connection(self.port, b, self.protocol)
for id in self.id_range:
if not self.running.is_set():
break
if dxl_io.ping(id):
model = dxl_io.get_model((id, ))[0]
QTreeWidgetItem(baud_root, ['', str(id), model])
self.part_done.emit(self.scan_progress.value() + 1)
release_dxl_connection()
self.done.emit()
def show_fairy_data_in_treewidget(self, reScan=False):
#读取精灵信息显示在treeWidget中
folderIcon = fairy_tab_console.get_icon("folder")
fairyDict = fairy_tab_console.get_fairy_dict(reScan)
# print(fairyDict)
self.treeWidget.clear()
# print("clear")
# print(list(fairyDict.keys()))
fairy_id_list = list(fairyDict.keys())
for fairyID in fairy_id_list:
fairy = fairy_tab_console.get_fairy_info(fairyID)
child = QTreeWidgetItem(self.treeWidget)
child.setIcon(0, folderIcon)
if(fairy is None):
child.setText(0, fairyID+"\t这似乎不是注册文件")
continue
child.setText(0, fairy.id)
fairyXML = QTreeWidgetItem(child)
fairyXML.setText(0,fairy.name)
def _refresh(self):
self._ui.treeWidget.clear()
sessions = gVar.app.sessionManager()._sessionMetaData()
for session in sessions:
item = QTreeWidgetItem()
item.setText(0, session.name)
item.setText(1, QFileInfo(session.filePath).lastModified().toString(Qt.DefaultLocaleShortDate))
item.setData(0, self._SessionFileRole, session.filePath)
item.setData(0, self._IsBackupSessionRole, session.isBackup)
item.setData(0, self._IsActiveSessionRole, session.isActive)
item.setData(0, self._IsDefaultSessionRole, session.isDefault)
self._updateItem(item)
self._ui.treeWidget.addTopLevelItem(item)
self._updateButtons()
def process(node, parent):
parent.setIcon(0, QIcon(I('mimetypes/dir.png')))
for child in sorted(node, key=numeric_sort_key):
c = QTreeWidgetItem(parent, (child,))
process(node[child], c)
def show_detail(self,Item=None):
if Item==None:
return
packet = self.pac_list[int(Item.row())]
self.current_row = int(Item.row())
self.treeWidget.clear()
ether = QTreeWidgetItem(self.treeWidget)
ether.setText(0,'Ethernet')
d_mac = QTreeWidgetItem(ether)
d_mac.setText(0,"Destination:"+packet.ether.d_mac)
s_mac = QTreeWidgetItem(ether)
s_mac.setText(0,"Source:"+packet.ether.s_mac)
type = QTreeWidgetItem(ether)
type.setText(0,"Type:"+packet.ether.next_proto+'(0x'+packet.ether.type+')')
self.treeWidget.addTopLevelItem(ether)
if packet.arp:
arp = QTreeWidgetItem(self.treeWidget)
arp.setText(0, 'ARP')
hw_type = QTreeWidgetItem(arp)
hw_type.setText(0, "Hardware Type:0x" + packet.arp.hardware_type)
pro_type = QTreeWidgetItem(arp)
pro_type.setText(0, "Protocol Type:0x" + packet.arp.protocol_type)
hw_size = QTreeWidgetItem(arp)
hw_size.setText(0, "Hareware Size:"+packet.arp.hardware_size)
pro_size = QTreeWidgetItem(arp)
pro_size.setText(0,"Protocol Size:"+packet.arp.protocol_size)
opcode = QTreeWidgetItem(arp)
opcode.setText(0,"Opcode:"+packet.arp.opcode)
s_mac_a = QTreeWidgetItem(arp)
s_mac_a.setText(0, "Sender Mac Address:" + packet.arp.sender_mac_address)
s_ip_a = QTreeWidgetItem(arp)
s_ip_a.setText(0, "Sender IP Address:" + packet.arp.sender_ip_address)
t_mac_a = QTreeWidgetItem(arp)
t_mac_a.setText(0, "Target Mac Address:" + packet.arp.target_mac_address)
t_ip_a = QTreeWidgetItem(arp)
t_ip_a.setText(0, "Target IP Address:" + packet.arp.target_ip_address)
self.treeWidget.addTopLevelItem(arp)
elif packet.ipv4:
ipv4 = QTreeWidgetItem(self.treeWidget)
ipv4.setText(0,'IPv4')
version = QTreeWidgetItem(ipv4)
version.setText(0, "Version:" + packet.ipv4.version)
hd_len = QTreeWidgetItem(ipv4)
hd_len.setText(0, "Header Length:" + str(packet.ipv4.header_length))
dsf = QTreeWidgetItem(ipv4)
dsf.setText(0, "DSF:" + packet.ipv4.dsf)
total_len = QTreeWidgetItem(ipv4)
total_len.setText(0, "Total Length:" + str(packet.ipv4.total_length))
iden = QTreeWidgetItem(ipv4)
iden.setText(0, "Identification:" + packet.ipv4.identification)
flags = QTreeWidgetItem(ipv4)
flags.setText(0, "Flags:" + packet.ipv4.flags)
ttl = QTreeWidgetItem(ipv4)
ttl.setText(0, "TTL(Time to live):" + packet.ipv4.time_to_live)
next_pro = QTreeWidgetItem(ipv4)
next_pro.setText(0, "Protocal:" + packet.ipv4.next_proto)
checksum = QTreeWidgetItem(ipv4)
checksum.setText(0, "Checksum:" + packet.ipv4.checksum+"(Verified)")
source = QTreeWidgetItem(ipv4)
source.setText(0, "Source:" + packet.ipv4.source)
destination = QTreeWidgetItem(ipv4)
destination.setText(0, "Destination:" + packet.ipv4.destination)
self.treeWidget.addTopLevelItem(ipv4)
if packet.tcp:
tcp = QTreeWidgetItem(self.treeWidget)
tcp.setText(0,'TCP')
s_p = QTreeWidgetItem(tcp)
s_p.setText(0, "Source Port:" + str(packet.tcp.source_port))
d_p = QTreeWidgetItem(tcp)
d_p.setText(0, "Destination Port:" + str(packet.tcp.destination_port))
seq_num = QTreeWidgetItem(tcp)
seq_num.setText(0, "Sequence Number:" + str(packet.tcp.sequence_number))
ack_num = QTreeWidgetItem(tcp)
ack_num.setText(0, "Acknowledgement Number:" + str(packet.tcp.acknowledgement_number))
header_len = QTreeWidgetItem(tcp)
header_len.setText(0, "Header Length:" + str(packet.tcp.header_length))
reserved = QTreeWidgetItem(tcp)
reserved.setText(0, "Reserved:" + packet.tcp.reserved)
flags_tcp = QTreeWidgetItem(tcp)
flags_tcp.setText(0, "Flags:" + packet.tcp.flags)
wsv = QTreeWidgetItem(tcp)
wsv.setText(0, "Window Size Value:" + str(packet.tcp.window_size_value))
checksum_tcp = QTreeWidgetItem(tcp)
checksum_tcp.setText(0, "Checksum:" + packet.tcp.checksum)
ugrent_pointer = QTreeWidgetItem(tcp)
ugrent_pointer.setText(0, "Urgent Pointer:" + packet.tcp.urgent_pointer)
for kind in packet.tcp.kind:
options = QTreeWidgetItem(tcp)
options.setText(0, "Options:" + kind)
sdl = QTreeWidgetItem(tcp)
sdl.setText(0, "Segment Data Length:" + str(packet.tcp.segment_data_length))
self.treeWidget.addTopLevelItem(tcp)
elif packet.icmp:
icmp = QTreeWidgetItem(self.treeWidget)
icmp.setText(0, 'ICMP')
type_icmp = QTreeWidgetItem(icmp)
type_icmp.setText(0, "Type:" + packet.icmp.type_list[packet.icmp.type+packet.icmp.code]+'(0x'+packet.icmp.type+')')
code_icmp = QTreeWidgetItem(icmp)
code_icmp.setText(0, "Checksum:" + packet.icmp.code)
checksum_icmp = QTreeWidgetItem(icmp)
checksum_icmp.setText(0, "Checksum:" + packet.icmp.checksum)
id_be_icmp = QTreeWidgetItem(icmp)
id_be_icmp.setText(0, "Identifier BE:" + packet.icmp.identifier_be)
id_le_icmp = QTreeWidgetItem(icmp)
id_le_icmp.setText(0, "Identifier LE:" + packet.icmp.identifier_le)
seq_num_be_icmp = QTreeWidgetItem(icmp)
seq_num_be_icmp.setText(0, "Sequence Number BE:" + packet.icmp.sequence_number_be)
seq_num_le_icmp = QTreeWidgetItem(icmp)
seq_num_le_icmp.setText(0, "Sequence Number LE:" + packet.icmp.sequence_number_le)
timestamp_icmp = QTreeWidgetItem(icmp)
timestamp_icmp.setText(0, "Timestamp From ICMP Data:" + packet.icmp.timestamp_from_icmp_data)
data_len_icmp = QTreeWidgetItem(icmp)
data_len_icmp.setText(0, "Data Length:" + str(packet.icmp.data_length))
self.treeWidget.addTopLevelItem(icmp)
elif packet.udp:
udp = QTreeWidgetItem(self.treeWidget)
udp.setText(0, 'UDP')
s_p_udp = QTreeWidgetItem(udp)
s_p_udp.setText(0,"Source Port:"+str(packet.udp.source_port))
d_p_udp = QTreeWidgetItem(udp)
d_p_udp.setText(0, "Destination Port:"+str(packet.udp.destination_port))
len_udp = QTreeWidgetItem(udp)
len_udp.setText(0, "Length:"+str(packet.udp.length))
checksum_udp = QTreeWidgetItem(udp)
checksum_udp.setText(0, "Checksum:"+packet.udp.checksum)
self.treeWidget.addTopLevelItem(udp)
if packet.dns:
dns = QTreeWidgetItem(self.treeWidget)
dns.setText(0, 'DNS')
trans_id_dns = QTreeWidgetItem(dns)
trans_id_dns.setText(0, "Transaction Id:"+packet.dns.transaction_id)
flags_dns = QTreeWidgetItem(dns)
flags_dns.setText(0, "Flags:"+packet.dns.flags)
response_dns = QTreeWidgetItem(dns)
response_dns.setText(0, "Response:"+packet.dns.response)
questions_dns = QTreeWidgetItem(dns)
questions_dns.setText(0, "Questions:"+str(packet.dns.questions))
answer_rrs_dns = QTreeWidgetItem(dns)
answer_rrs_dns.setText(0, "Answer RRS:"+str(packet.dns.answer_rrs))
authority_rrs_dns = QTreeWidgetItem(dns)
authority_rrs_dns.setText(0, "Authority RRS:"+str(packet.dns.authority_rrs))
additional_rrs_dns = QTreeWidgetItem(dns)
additional_rrs_dns.setText(0, "Additional RRS:"+str(packet.dns.additional_rrs))
elif packet.ipv6:
ipv6 = QTreeWidgetItem(self.treeWidget)
ipv6.setText(0, 'IPv6')
version_ipv6 = QTreeWidgetItem(ipv6)
version_ipv6.setText(0,"Version:"+packet.ipv6.version)
traffic_class_ipv6 = QTreeWidgetItem(ipv6)
traffic_class_ipv6.setText(0, "Traffic Class:" + packet.ipv6.traffic_class)
dsc_ipv6 = QTreeWidgetItem(ipv6)
dsc_ipv6.setText(0, "Differentiated Service Codepoint:" + str(packet.ipv6.differentiated_service_codepoint))
ecn_ipv6 = QTreeWidgetItem(ipv6)
ecn_ipv6.setText(0, "Explicit Congestion Notification:" + str(packet.ipv6.explicit_congestion_notification))
fl_ipv6 = QTreeWidgetItem(ipv6)
fl_ipv6.setText(0, "Flow Label:" + packet.ipv6.flow_label)
pl_ipv6 = QTreeWidgetItem(ipv6)
pl_ipv6.setText(0, "Payload Length:" + str(packet.ipv6.payload_length))
np_ipv6 = QTreeWidgetItem(ipv6)
np_ipv6.setText(0, "Protocol:" + packet.ipv6.next_proto)
hl_ipv6 = QTreeWidgetItem(ipv6)
hl_ipv6.setText(0, "Hop Limit:" + str(packet.ipv6.hop_limit))
s_ipv6 = QTreeWidgetItem(ipv6)
s_ipv6.setText(0, "Source:" + packet.ipv6.source)
d_ipv6 = QTreeWidgetItem(ipv6)
d_ipv6.setText(0, "Destination:" + packet.ipv6.destination)
if packet.icmpv6:
icmpv6 = QTreeWidgetItem(self.treeWidget)
icmpv6.setText(0, 'ICMPv6')
type_icmpv6 = QTreeWidgetItem(icmpv6)
type_icmpv6.setText("Type:"+packet.icmpv6.info()+'('+str(packet.icmpv6.type)+')')
code_icmpv6 = QTreeWidgetItem(icmpv6)
code_icmpv6.setText("Code:"+str(packet.icmpv6.code))
checksum_icmpv6 = QTreeWidgetItem(icmpv6)
checksum_icmpv6.setText("Checksum:"+packet.icmpv6.checksum)
chl_icmpv6 = QTreeWidgetItem(icmpv6)
chl_icmpv6.setText("Cur Hop Limit:"+str(packet.icmpv6.cur_hop_limit))
flags_icmpv6 = QTreeWidgetItem(icmpv6)
flags_icmpv6.setText("Flags:"+packet.icmpv6.flags)
rl_icmpv6 = QTreeWidgetItem(icmpv6)
rl_icmpv6.setText("Router LifeTime:"+str(packet.icmpv6.router_lifetime))
rt_icmpv6 = QTreeWidgetItem(icmpv6)
rt_icmpv6.setText("Reachable Time:"+str(packet.icmpv6.reachable_time))
rtt_icmpv6 = QTreeWidgetItem(icmpv6)
rtt_icmpv6.setText("Retrans Time:"+str(packet.icmpv6.retrans_time))
options_icmpv6 = QTreeWidgetItem(icmpv6)
options_icmpv6.setText("Options:"+packet.icmpv6.options)
def add_child(text):
c = QTreeWidgetItem([text], 1)
c.setFlags(Qt.ItemIsEnabled)
item.addChild(c)
return c
def build(self, container, preserve_state=True):
if container is None:
return
if preserve_state:
state = self.get_state()
self.clear()
self.root = self.invisibleRootItem()
self.root.setFlags(Qt.ItemIsDragEnabled)
self.categories = {}
for category, text, __ in CATEGORIES:
self.categories[category] = i = QTreeWidgetItem(self.root, 0)
i.setText(0, text)
i.setData(0, Qt.DecorationRole, self.top_level_pixmap_cache[category])
f = i.font(0)
f.setBold(True)
i.setFont(0, f)
i.setData(0, NAME_ROLE, category)
flags = Qt.ItemIsEnabled
if category == 'text':
flags |= Qt.ItemIsDropEnabled
i.setFlags(flags)
processed, seen = {}, {}
cover_page_name = get_cover_page_name(container)
cover_image_name = get_raster_cover_name(container)
manifested_names = set()
for names in container.manifest_type_map.itervalues():
manifested_names |= set(names)
def get_category(name, mt):
category = 'misc'
if mt.startswith('image/'):
category = 'images'
elif mt in OEB_FONTS:
category = 'fonts'
elif mt in OEB_STYLES:
category = 'styles'
elif mt in OEB_DOCS:
category = 'text'
ext = name.rpartition('.')[-1].lower()
if ext in {'ttf', 'otf', 'woff'}:
# Probably wrong mimetype in the OPF
category = 'fonts'
return category
def set_display_name(name, item):
if tprefs['file_list_shows_full_pathname']:
text = name
else:
if name in processed:
# We have an exact duplicate (can happen if there are
# duplicates in the spine)
item.setText(0, processed[name].text(0))
item.setText(1, processed[name].text(1))
return
parts = name.split('/')
text = parts.pop()
while text in seen and parts:
text = parts.pop() + '/' + text
seen[text] = item
item.setText(0, text)
item.setText(1, hexlify(sort_key(text)))
def render_emblems(item, emblems):
emblems = tuple(emblems)
if not emblems:
return
icon = self.rendered_emblem_cache.get(emblems, None)
if icon is None:
pixmaps = []
for emblem in emblems:
pm = self.emblem_cache.get(emblem, None)
if pm is None:
pm = self.emblem_cache[emblem] = QIcon(I(emblem)).pixmap(self.iconSize())
pixmaps.append(pm)
num = len(pixmaps)
w, h = pixmaps[0].width(), pixmaps[0].height()
if num == 1:
icon = self.rendered_emblem_cache[emblems] = QIcon(pixmaps[0])
else:
canvas = QPixmap((num * w) + ((num-1)*2), h)
canvas.setDevicePixelRatio(pixmaps[0].devicePixelRatio())
canvas.fill(Qt.transparent)
painter = QPainter(canvas)
for i, pm in enumerate(pixmaps):
painter.drawPixmap(int(i * (w + 2)/canvas.devicePixelRatio()), 0, pm)
painter.end()
icon = self.rendered_emblem_cache[emblems] = canvas
item.setData(0, Qt.DecorationRole, icon)
cannot_be_renamed = container.names_that_must_not_be_changed
ncx_mime = guess_type('a.ncx')
nav_items = frozenset(container.manifest_items_with_property('nav'))
def create_item(name, linear=None):
imt = container.mime_map.get(name, guess_type(name))
icat = get_category(name, imt)
category = 'text' if linear is not None else ({'text':'misc'}.get(icat, icat))
item = QTreeWidgetItem(self.categories['text' if linear is not None else category], 1)
flags = Qt.ItemIsEnabled | Qt.ItemIsSelectable
if category == 'text':
flags |= Qt.ItemIsDragEnabled
if name not in cannot_be_renamed:
flags |= Qt.ItemIsEditable
item.setFlags(flags)
item.setStatusTip(0, _('Full path: ') + name)
item.setData(0, NAME_ROLE, name)
item.setData(0, CATEGORY_ROLE, category)
item.setData(0, LINEAR_ROLE, bool(linear))
item.setData(0, MIME_ROLE, imt)
set_display_name(name, item)
tooltips = []
emblems = []
if name in {cover_page_name, cover_image_name}:
emblems.append('default_cover.png')
tooltips.append(_('This file is the cover %s for this book') % (_('image') if name == cover_image_name else _('page')))
if name in container.opf_name:
emblems.append('metadata.png')
tooltips.append(_('This file contains all the metadata and book structure information'))
if imt == ncx_mime or name in nav_items:
emblems.append('toc.png')
tooltips.append(_('This file contains the metadata table of contents'))
if name not in manifested_names and not container.ok_to_be_unmanifested(name):
emblems.append('dialog_question.png')
tooltips.append(_('This file is not listed in the book manifest'))
if linear is False:
emblems.append('arrow-down.png')
tooltips.append(_('This file is marked as non-linear in the spine\nDrag it to the top to make it linear'))
if linear is None and icat == 'text':
# Text item outside spine
emblems.append('dialog_warning.png')
tooltips.append(_('This file is a text file that is not referenced in the spine'))
if category == 'text' and name in processed:
# Duplicate entry in spine
emblems.append('dialog_error.png')
tooltips.append(_('This file occurs more than once in the spine'))
render_emblems(item, emblems)
if tooltips:
item.setData(0, Qt.ToolTipRole, '\n'.join(tooltips))
return item
for name, linear in container.spine_names:
processed[name] = create_item(name, linear=linear)
for name in container.name_path_map:
if name in processed:
continue
processed[name] = create_item(name)
for name, c in self.categories.iteritems():
c.setExpanded(True)
if name != 'text':
c.sortChildren(1, Qt.AscendingOrder)
if preserve_state:
self.set_state(state)
if self.current_edited_name:
item = self.item_from_name(self.current_edited_name)
if item is not None:
self.mark_item_as_current(item)
def initUI(self):
'''
UI initialize
'''
# set the window position(x,y) and size
self.setGeometry(self.__posx, self.__posy, self.__width, self.__height)
# set the window title
self.setWindowTitle(self.__title)
# update window status
self.update_status('Loading...')
# add menu bar
self.__mainMenu = self.menuBar()
self.__fileMenu = self.__mainMenu.addMenu('File')
self.__editMenu = self.__mainMenu.addMenu('Edit')
self.__viewMenu = self.__mainMenu.addMenu('View')
self.__searchMenu = self.__mainMenu.addMenu('Search')
self.__toolsMenu = self.__mainMenu.addMenu('Tools')
self.__helpMenu = self.__mainMenu.addMenu('Help')
# add frame
self.__lefttop_square = QFrame(self)
self.__lefttop_square.setGeometry(10, 30, 230, 150)
self.__leftbtm_square = QFrame(self)
self.__leftbtm_square.setGeometry(10, 190, 230, 510)
self.__right_square = QFrame(self)
self.__right_square.setGeometry(250, 30, 820, 670)
# add database combobox and add items
self.__db_comboBox = QComboBox(self.__lefttop_square)
self.__db_comboBox.setGeometry(QRect(15, 30, 200, 30))
self.__db_comboBox.setObjectName(("comboBox"))
# load data
self.on_load_combolist(self.__db_comboBox) # load event
# add datatable treeview and add items
self.__tb_treeview = QTreeWidget(self.__leftbtm_square)
self.__tb_treeview.setGeometry(15, 30, 200, 440)
self.__tb_treeview_root = QTreeWidgetItem(self.__tb_treeview)
self.__tb_treeview_root.setText(0, "Tables")
self.__tb_treeview_root.setText(1, "root")
self.__tb_treeview.addTopLevelItem(self.__tb_treeview_root)
self.__tb_treeview.expandAll()
self.__tb_treeview.setHeaderHidden(True)
# add tab
self.__tab = QTabWidget(self.__right_square)
self.__tab.setGeometry(10, 10, 800, 620)
# add datagrid buttons
self.__new_rec_btn = QPushButton('New',self)
self.__new_rec_btn.setToolTip('Add a new record')
self.__new_rec_btn.resize(60, 30)
self.__new_rec_btn.move(400,665)
self.__new_rec_btn.clicked.connect(self.click_new_rec_btn) # button click event
self.__del_rec_btn = QPushButton('Delete',self)
self.__del_rec_btn.setToolTip('Delete a new record')
self.__del_rec_btn.resize(60, 30)
self.__del_rec_btn.move(470,665)
# event
self.__del_rec_btn.clicked.connect(self.click_del_rec_btn) # button click event
self.__db_comboBox.currentIndexChanged.connect(self.on_combox_selection_change) # selection change event
self.__tb_treeview.doubleClicked.connect(self.on_treeview_doubleClick) # selection change event
# show the window
self.show()
