def setModified(self, item: QTreeWidgetItem, modified: bool):
f = item.font(0)
f.setItalic(modified)
item.setFont(0, f)
item.setFont(1, f)
f.setBold(modified)
item.setFont(2, f)
def __init__( self, pluginManager, cdmPlugin, active, category ):
self.plugin = cdmPlugin
self.active = active
self.category = category
name = self.plugin.getName()
ver = self.plugin.getVersion()
QTreeWidgetItem.__init__( self, [ "", "", "", name, ver ] )
if not self.plugin.conflictType in [ pluginManager.NO_CONFLICT,
pluginManager.USER_DISABLED ]:
self.setIcon( CONFLICT_COL, PixmapCache().getIcon( 'pluginconflict.png' ) )
self.setToolTip( CONFLICT_COL, self.plugin.conflictMessage )
self.setToolTip( STATE_COL, "Enable / disable" )
self.setToolTip( CONFLICT_COL, "Conflict" )
if self.plugin.isUser():
self.setIcon( TYPE_COL, PixmapCache().getIcon( 'pluginuser.png' ) )
self.setToolTip( TYPE_COL, "User plugin" )
else:
self.setIcon( TYPE_COL, PixmapCache().getIcon( 'pluginsystem.png' ) )
self.setToolTip( TYPE_COL, "System wide plugin" )
self.setFlags( self.flags() | Qt.ItemIsUserCheckable )
if active:
self.setCheckState( STATE_COL, Qt.Checked )
else:
self.setCheckState( STATE_COL, Qt.Unchecked )
return
def __init__( self, logInfo ):
self.logInfo = logInfo
message = ""
if logInfo.message:
message = str( logInfo.message )
authorTooltip = ""
author = ""
if logInfo.author:
authorTooltip = str( logInfo.author )
author = authorTooltip.split( "@", 1 )[ 0 ]
revision = ""
if logInfo.revision:
if logInfo.revision.number:
revision = str( logInfo.revision.number )
date = ""
if logInfo.date:
date = timestampToString( logInfo.date )
QTreeWidgetItem.__init__( self, [ "", "", revision, date,
author, message ] )
self.setCheckState( SELECT_COL, Qt.Unchecked )
self.setToolTip( REVISION_COL, revision )
self.setToolTip( DATE_COL, date )
self.setToolTip( AUTHOR_COL, authorTooltip )
self.setToolTip( MESSAGE_COL, message )
return
def populateTree(self):
self.uptodateItem = QTreeWidgetItem()
self.uptodateItem.setText(0, self.tr('Installed'))
self.toupdateItem = QTreeWidgetItem()
self.toupdateItem.setText(0, self.tr('Updatable'))
self.notinstalledItem = QTreeWidgetItem()
self.notinstalledItem.setText(0, self.tr('Not installed'))
self.toupdateItem.setIcon(0, self.icon)
self.uptodateItem.setIcon(0, self.icon)
self.notinstalledItem.setIcon(0, self.icon)
resources = readUrl(self.urlBase + 'list.txt').splitlines()
resources = [r.split(',') for r in resources]
self.resources = {f: (v, n) for f, v, n in resources}
for filename, version, name in sorted(resources, key=lambda kv: kv[2].lower()):
treeBranch = self.getTreeBranchForState(filename, float(version))
item = TreeItem(filename, name, self.icon)
treeBranch.addChild(item)
if treeBranch != self.notinstalledItem:
item.setCheckState(0, Qt.Checked)
self.tree.addTopLevelItem(self.toupdateItem)
self.tree.addTopLevelItem(self.notinstalledItem)
self.tree.addTopLevelItem(self.uptodateItem)
self.webView.setHtml(self.HELP_TEXT)
def updateMemberInformation(self, peerID=None, peerInfo=None):
if peerID != None and peerID != self.get_selected_log_member():
# only update if selected member updated
return
self.memberInformationTable.clear()
if self.get_selected_log_member() == None:
self.memberInformationTable.setColumnCount(0)
self.memberInformationTable.setHeaderLabel("No member selected.")
return
if peerInfo == None:
peerInfo = get_peers().getPeerInfo(pID=self.get_selected_log_member())
if peerInfo == None:
self.memberInformationTable.setColumnCount(0)
self.memberInformationTable.setHeaderLabel("No member information available.")
return
self.memberInformationTable.setColumnCount(len(peerInfo))
headers = sorted(peerInfo.keys(), key=lambda s: s.lower())
self.memberInformationTable.setHeaderLabels(QStringList(headers))
item = QTreeWidgetItem(self.memberInformationTable)
for col, header in enumerate(headers):
item.setData(col, Qt.DisplayRole, QVariant(peerInfo[header]))
for col in range(self.memberInformationTable.columnCount()):
self.memberInformationTable.resizeColumnToContents(col)
def createTree(self):
objects = list(self.model)
objects = [object for object in objects
if self.filter.match(object)]
objects.sort(key=getIdentifier)
groups = {}
for object in objects:
if isinstance(object, Group):
key = None
else:
key = self.getTreeKey(object)
if key in groups:
groups[key].append(object)
else:
groups[key] = [object]
root = []
for key in sorted(groups.keys()):
if key:
label = self.createTreeKeyLabel(key)
else:
label = tr('Groups')
tree = QTreeWidgetItem([label])
unsetFlag(tree, Qt.ItemIsSelectable)
for object in groups[key]:
node = self.createTreeItem(object)
tree.addChild(node)
root.append(tree)
return root
def fillTreeWidget(self):
""" Заполняем tree widget записями, на основе разбиения на категории"""
self._loadingData = True
self._ui.twEntries.clear()
for key in self._categories:
self._categories[key] = sorted(self._categories[key], key=attrgetter('title'))
item = DateTreeWidgetItem(self._ui.twEntries)
font = item.font(0)
font.setPointSize(11)
font.setBold(True)
item.setFont(0, font)
if settings.showEntryCountInCategory():
item.setText(0, "{} ({})".format(key, len(self._categories[key])))
else:
item.setText(0, key)
item.setData(0, Qt.UserRole, self._keyForCategory[key])
for e in self._categories[key]:
entryItem = QTreeWidgetItem(item)
font = entryItem.font(0)
font.setPointSize(12)
entryItem.setCheckState(0, Qt.Checked if e.interesting else Qt.Unchecked)
entryItem.setText(0, e.title)
entryItem.setFont(0, font)
entryItem.setData(0, Qt.UserRole, e.id)
self._setToolTipForItem(e, entryItem)
self._ui.twEntries.sortItems(0, Qt.AscendingOrder)
self._ui.twEntries.expandAll()
self._loadingData = False
def init_main_panel(self):
from PyQt4.QtGui import QTreeWidgetItem as Twi
this = self.mw
coco = self.coco
tree = this.friends_list_tree
self.root = []
friends = coco.friends
from copy import deepcopy
# 有些好友并不在任何返回的群组中(可能是陌生人或者黑名单吧，没有测试过)
friends_copy = deepcopy(friends)
for cat in coco.categories:
group_item = Twi(tree, [cat["name"]])
group_item.setSizeHint(0, QSize(0, 30))
self.root.append(group_item)
index = cat["index"]
friends_of_this_group = friends_copy.pop(index)
for friend in friends_of_this_group:
uin = friend["uin"]
# 有备注就取备注否则取昵称
nick = coco.friend_cache[uin]["nick"]
t = Twi(group_item, [nick])
# 将uin存储在item上
t.uin = uin
coco.friend_cache[uin]["nick"] = nick
if friends_copy:
logging.debug("thers are friends that not belong to any category.")
tree.insertTopLevelItems(0, self.root)
def _add_symbol_to_tree_widget(self, symbol):
""" Add the given symbol to the tree widget. If this
is a new category create it, otherwise append it
to the already existing one.
"""
# find category
category = symbol["category"]
categoryItems = self.availableSymbolsWidget.findItems(category,
Qt.MatchExactly, 0)
name = symbol["name"]
symbolItem = QTreeWidgetItem([name])
symbolItem.setData(0, Qt.UserRole, name)
symbolItem.setFlags(Qt.ItemIsSelectable |
Qt.ItemIsUserCheckable |
Qt.ItemIsEnabled)
if categoryItems:
categoryItems[0].addChild(symbolItem)
else:
categoryItem = QTreeWidgetItem(self.availableSymbolsWidget,
[category])
categoryItem.setFlags(Qt.ItemIsEnabled)
categoryItem.addChild(symbolItem)
self.availableSymbolsWidget.resizeColumnToContents(0)
self.availableSymbolsWidget.sortItems(0, Qt.AscendingOrder)
self.availableSymbolsWidget.setCurrentItem(symbolItem)
def __init__(self, parent, _name, path):
QTreeWidgetItem.__init__(self, parent)
self._parent = parent
self.setText(0, _name)
self.path = path
self.isFolder = True
self.setForeground(0, QBrush(QColor(255, 165, 0)))
project = json_manager.read_ninja_project(path)
self.name = project.get('name', '')
if self.name == '':
self.name = _name
self.setText(0, self.name)
self.projectType = project.get('project-type', '')
self.description = project.get('description', '')
self.url = project.get('url', '')
self.license = project.get('license', '')
self.mainFile = project.get('mainFile', '')
self.preExecScript = project.get('preExecScript', '')
self.postExecScript = project.get('postExecScript', '')
self.indentation = project.get('indentation', settings.INDENT)
self.useTabs = project.get('use-tabs', settings.USE_TABS)
self.extensions = project.get('supported-extensions',
settings.SUPPORTED_EXTENSIONS)
self.pythonPath = project.get('pythonPath', settings.PYTHON_PATH)
self.PYTHONPATH = project.get('PYTHONPATH', '')
self.programParams = project.get('programParams', '')
self.venv = project.get('venv', '')
self.related_projects = project.get('relatedProjects', [])
self.update_paths()
self.addedToConsole = False
def __init__(self, song, pos):
QTreeWidgetItem.__init__(self)
self.song = song
self.pos = pos
self.setText(0,mpdlibrary.songArtist(song))
self.setText(1,mpdlibrary.songTitle(song))
self.setText(2,mpdlibrary.songAlbum(song))
def __init__(self, action, collection, name):
QTreeWidgetItem.__init__(self)
self.collection = collection
self.name = name
self.setIcon(0, action.icon())
self.setText(0, qutil.removeAccelelator(action.text()))
self._shortcuts = {}
def build_menu_item(action):
"""Return a QTreeWidgetItem with children for all the actions in the submenu."""
menuitem = QTreeWidgetItem()
text = qutil.removeAccelelator(action.text())
menuitem.setText(0, _("Menu {name}").format(name=text))
add_actions(menuitem, action.menu().actions())
return menuitem
def __init__(self, parent, name, lineno=None):
QTreeWidgetItem.__init__(self, parent, name)
self.lineno = lineno
self.isClickable = True
self.isAttribute = False
self.isClass = False
self.isMethod = False
def __init__( self, parent, isGlobal,
displayName, displayValue, displayType ):
self.__isGlobal = isGlobal
self.__value = displayValue
self.__name = displayName
self.__type = displayType
# Decide about the display value
displayValue = getDisplayValue( displayValue )
# Decide about the tooltip
self.__tooltip = "Name: " + displayName + "\n" + \
"Type: " + displayType + "\n" + \
"Value: "
tooltipDisplayValue = getTooltipValue( self.__value )
if '\r' in tooltipDisplayValue or '\n' in tooltipDisplayValue:
self.__tooltip += "\n" + tooltipDisplayValue
else:
self.__tooltip += tooltipDisplayValue
QTreeWidgetItem.__init__( self, parent, [ displayName, displayValue,
displayType ] )
self.populated = True
return
def appendPage(self, path, widget, icon=None):
"""Append page to the tree. Called by a plugin for creating own page. Example:
::
widget = MitSchemeSettings(dialog)
dialog.appendPage(u"Modes/MIT Scheme", widget, QIcon(':/enkiicons/languages/scheme.png'))
"""
pathParts = path.split('/')
if len(pathParts) == 1:
parentItem = None
else:
parentItem = self._itemByPath(pathParts[:-1])
twItem = QTreeWidgetItem([pathParts[-1]])
if icon is not None:
twItem.setIcon(0, icon)
if parentItem is not None:
parentItem.addChild(twItem)
else:
self.twMenu.addTopLevelItem(twItem)
self.swPages.addWidget(widget)
self._pageForItem[path] = widget
def populateTree(self):
self.uptodateItem = QTreeWidgetItem()
self.uptodateItem.setText(0, self.tr("Installed"))
self.toupdateItem = QTreeWidgetItem()
self.toupdateItem.setText(0, self.tr("Updatable"))
self.notinstalledItem = QTreeWidgetItem()
self.notinstalledItem.setText(0, self.tr("Not installed"))
self.toupdateItem.setIcon(0, self.icon)
self.uptodateItem.setIcon(0, self.icon)
self.notinstalledItem.setIcon(0, self.icon)
resources = readUrl(self.urlBase + "list.txt").splitlines()
resources = [r.split(",") for r in resources]
self.resources = {f: (v, n) for f, v, n in resources}
for filename, version, name in resources:
treeBranch = self.getTreeBranchForState(filename, float(version))
item = TreeItem(filename, name, self.icon)
treeBranch.addChild(item)
if treeBranch != self.notinstalledItem:
item.setCheckState(0, Qt.Checked)
self.tree.addTopLevelItem(self.toupdateItem)
self.tree.addTopLevelItem(self.notinstalledItem)
self.tree.addTopLevelItem(self.uptodateItem)
self.webView.setHtml(self.HELP_TEXT)
def _updateCacheView(self, build_dir):
# Do nothing if build dir is not configured
if not build_dir:
return
self.cacheViewPage.cacheItems.clear() # Remove previously collected cache
is_advanced = self.cfgPage.mode.isChecked()
try:
items = cmake_help_parser.get_cache_content(build_dir, is_advanced)
except ValueError as error:
kate.ui.popup(
i18nc('@title:window', 'Error')
, i18nc(
'@info:tooltip'
, 'Unable to get CMake cache content:<nl/><message>%1</message>'
, str(error)
)
, 'dialog-error'
)
return
# Add items to a list
for key, value in items.items():
item = QTreeWidgetItem(self.cacheViewPage.cacheItems, [key, value[1], value[0]])
item.setToolTip(0, value[2])
self.cacheViewPage.cacheItems.resizeColumnToContents(0)
self.cacheViewPage.cacheItems.resizeColumnToContents(1)
self.cacheViewPage.cacheItems.resizeColumnToContents(2)
def OpenProjectFromFile(self, name):
self.demands = {}
self.project = Project()
#try:
self.project.Load(name)
#except :
# TODO: proper exceptioning
# QMessageBox.critical(self, self.tr("An error occured"), self.tr("File is not a valid project file: ") + name)
# return
self.projectFile = name
self.resourcesGraphEditor.setData(self.project.resources)
self.ui.demands.clear()
for d in self.project.demands:
it = QTreeWidgetItem(self.ui.demands, QStringList([d.id, str(d.startTime), str(d.endTime), self.tr("No") if d.critical else self.tr("Yes"), self.tr("Yes") if d.assigned else self.tr("No")]))
cb = QComboBox()
cb.addItems([self.tr("No"),self.tr("Yes")])
cb.setCurrentIndex(0 if d.critical else 1)
QObject.connect(cb, SIGNAL("currentIndexChanged(int)"), it.emitDataChanged)
self.ui.demands.setItemWidget(it,3,cb)
it.setFlags(Qt.ItemIsEditable | Qt.ItemIsEnabled | Qt.ItemIsSelectable)
self.demands[it] = d
self.UpdateRecentFiles()
self.setWindowTitle(self.project.name + " - " + self.basename)
self.ui.projectname.setText(self.project.name)
self.showStats()
self.backupTimer.start()
self.autosaveTimer.start()
def __init__(self, filename, name, icon):
QTreeWidgetItem.__init__(self)
self.name = name
self.filename = filename
self.setText(0, name)
self.setIcon(0, icon)
self.setCheckState(0, Qt.Unchecked)
def populateTable(self):
"""Populates table with data from ItemTracker."""
self.selectedWidget.clear()
self.selectedWidget.setSortingEnabled(False)
numRows = len(self.tableResults)
self.mkInfo("Selected items in ItemTracker: {0}".format(numRows))
self.selectedWidget.setAlternatingRowColors(True)
header = ["ItemID", "StrainID", "ItemType", "ItemName", "BacteriaItemID"]
self.selectedWidget.setColumnCount(len(header))
self.selectedWidget.setHeaderLabels(header)
# use result and populate table
for result in self.tableResults:
properties = [unicode(i) for i in result]
item = QTreeWidgetItem(self.selectedWidget, properties)
item.setCheckState(0, Qt.Unchecked)
self.selectedWidget.setSortingEnabled(True)
for i in range(len(header)):
self.selectedWidget.resizeColumnToContents(i)
self.stackedWidget.setCurrentIndex(1) # switch view to table
self.statusbar.clearMessage()
self.populatedTable = True
self.updateUi()
def addResults(self, results):
tree = QTreeWidget()
tree.setColumnCount(1)
header = QString("Offset")
tree.setHeaderLabel(header)
tree.setAlternatingRowColors(True)
self.connect(tree, SIGNAL("itemDoubleClicked(QTreeWidgetItem *, int)"), self.treeClicked)
for res in results:
# print hex(res)
item = QTreeWidgetItem(tree)
off = "0x"
off += "%.2x" % res
item.setText(0, str(off))
self.trees.append(tree)
#Add pattern and offsets to tupple
key = binascii.hexlify(self.search.search_th.pattern)
self.search.searchedPatterns[key] = results
if self.search.lastSearchType == 0:
p = binascii.hexlify(self.search.search_th.pattern)
elif self.search.lastSearchType == 1:
p = self.search.search_th.pattern
else:
p = "u("
p += self.search.needle.text()
p += ")"
#Add Ascii hex pattern in searched list for syntaxHighliter
self.insertTab(len(self.trees), tree, p)
def updateLogList(self, logsAdded=None, logsRenamed=None):
selectedMember = self.get_selected_log_member()
if logsAdded == None:
self.log_tree_view.clear()
logsAdded = []
for index, logFile in enumerate(reversed(self.listLogFilesForMember(selectedMember))):
logsAdded.append((index, logFile))
if len(logsAdded) == 0:
self.log_tree_view.clear()
self.log_tree_view.addTopLevelItem(
QTreeWidgetItem(self.log_tree_view, QStringList("No logs available."))
)
self.log_tree_view.setSelectionMode(QTreeWidget.NoSelection)
self.logSizeLabel.setText("No logs")
self.clearLogsButton.setEnabled(False)
return
if logsRenamed != None:
for index, oldName, newName in logsRenamed:
# index + 1 because of the "requesting" item
item = self.log_tree_view.topLevelItem(index + 1)
if item != None:
itemLogFile = convert_string(item.data(0, Qt.UserRole).toString())
if itemLogFile != oldName:
self.logger.warning(
"index does not correspond to item in list:\n\t%s\n\t%s", itemLogFile, oldName
)
self.initializeLogItem(item, newName)
if len(logsAdded) == 0:
self.log_tree_view.takeTopLevelItem(0)
else:
for index, logFile in logsAdded:
oldItem = self.log_tree_view.topLevelItem(index)
item = None
if oldItem != None and oldItem.data(0, Qt.UserRole) == None:
# requested item has been received
item = oldItem
else:
item = QTreeWidgetItem()
oldItem = None
if logFile == None:
item.setData(0, Qt.DisplayRole, QVariant("Requesting..."))
QTimer.singleShot(6000, partial(self.requestTimedOut, item))
else:
self.initializeLogItem(item, logFile)
if oldItem == None:
# else, the old item is being modified
self.log_tree_view.insertTopLevelItem(index, item)
self.log_tree_view.setSelectionMode(QTreeWidget.SingleSelection)
totalSize = 0
for aLogFile in self.listLogFilesForMember(selectedMember):
totalSize += os.path.getsize(aLogFile)
self.logSizeLabel.setText("%s consumed" % self.formatFileSize(totalSize))
self.clearLogsButton.setEnabled(True)
def updateHolesTable(self):
self.treeWidget_holes.clear()
self.treeWidget_holes.setColumnCount(3)
self.treeWidget_holes.setColumnWidth(0, 50)
self.treeWidget_holes.setColumnWidth(1, 50)
self.treeWidget_holes.setColumnWidth(2, 70)
self.treeWidget_holes.setColumnWidth(3, 70)
self.treeWidget_holes.setHeaderLabels(["dia", "#", "X", "Y"])
diaList=list(self.fitHoles.keys())
diaList.sort()
for dia in diaList:
drillItem = QTreeWidgetItem()
drillItem.setText(0, str(dia))
drillItem.setText(1, str(len(self.fitHoles[dia])))
self.treeWidget_holes.addTopLevelItem(drillItem)
for hole in (self.fitHoles[dia]):
x, y, ID = hole
holeItem = QTreeWidgetItem(ID+1000) # use ID of hole as type
holeItem.setText(2, "{:3.1f}".format(x))
holeItem.setText(3, "{:3.1f}".format(y))
drillItem.addChild(holeItem)
if hole in self.selectedHoles:
self.treeWidget_holes.setCurrentItem(holeItem)
#self.treeWidget_holes.expandItem(drillItem)
#self.treeWidget_holes.scrollToItem(holeItem)
if not self.selectedHoles:
self.treeWidget_holes.setCurrentItem(None)
def __init__(self, parent, _name, path):
QTreeWidgetItem.__init__(self, parent)
self._parent = parent
self.setText(0, _name)
self.path = path
self.isFolder = True
self.setForeground(0, QBrush(Qt.darkGray))
project = json_manager.read_ninja_project(path)
self.name = project.get('name', '')
if self.name == '':
self.name = _name
self.setText(0, self.name)
self.projectType = project.get('project-type', '')
self.description = project.get('description', '')
self.url = project.get('url', '')
self.license = project.get('license', '')
self.mainFile = project.get('mainFile', '')
self.preExecScript = project.get('preExecScript', '')
self.postExecScript = project.get('postExecScript', '')
self.extensions = project.get('supported-extensions',
settings.SUPPORTED_EXTENSIONS)
self.pythonPath = project.get('pythonPath', settings.PYTHON_PATH)
self.programParams = project.get('programParams', '')
self.venv = project.get('venv', '')
self.addedToConsole = False
def cb_success(result):
programs, message = result
if message != None:
QMessageBox.critical(get_main_window(), 'Import Error', message)
else:
sorted_programs = {}
for program in programs:
first_upload = program[4]
if first_upload in sorted_programs:
sorted_programs[first_upload][program[1]] = program
else:
sorted_programs[first_upload] = {program[1]: program}
for first_upload in sorted(sorted_programs.keys()):
for identifier in sorted(sorted_programs[first_upload].keys()):
program = sorted_programs[first_upload][identifier]
item = QTreeWidgetItem(program[0:4])
self.tree_programs.addTopLevelItem(item)
item.setSelected(True)
self.refresh_in_progress = False
self.update_ui_state()
self.tree_programs.setFocus()
def __init__(self):
super(ShortcutSection, self).__init__()
container = QVBoxLayout(self)
self.tree = QTreeWidget()
self.tree.setHeaderLabels([self.tr("Keys"), self.tr("Description")])
self.tree.header().setStretchLastSection(True)
self.tree.setColumnWidth(0, 200)
container.addWidget(self.tree)
self.items = {
"new": "Create a new editor to work in a file",
"new-project": "Create a new project",
"open": "Open one or more files",
"open-project": "Opens an existing project Edis",
"reload": "Reload file",
"save": "Save file"
}
for i, e in list(self.items.items()):
item = QTreeWidgetItem(self.tree,
[keymap.get_keymap(i).toString(), e])
item.setFlags(Qt.ItemIsEditable | Qt.ItemIsEnabled)
self.tree.itemDoubleClicked.connect(self._change_shortcut)
# Install
EnvironmentConfiguration.install_widget(self.tr("Shortcuts"), self)
def __init__( self, parentItem, exceptionType, exceptionMessage,
stackTrace ):
QTreeWidgetItem.__init__( self, parentItem )
self.__count = 1
self.__exceptionType = exceptionType
self.__exceptionMessage = exceptionMessage
if exceptionMessage == "" or exceptionMessage is None:
self.setText( 0, str( exceptionType ) )
self.setToolTip( 0, "Type: " + str( exceptionType ) )
else:
self.setText( 0, str( exceptionType ) + ", " +
getDisplayValue( exceptionMessage ) )
tooltip = "Type: " + str( exceptionType ) + "\n" + \
"Message: "
tooltipMessage = getTooltipValue( exceptionMessage )
if '\r' in tooltipMessage or '\n' in tooltipMessage:
tooltip += "\n" + tooltipMessage
else:
tooltip += tooltipMessage
self.setToolTip( 0, tooltip )
if stackTrace:
for fileName, lineNumber in stackTrace:
StackFrameItem( self, fileName, lineNumber )
return
def __init__(self, parent, name, node):
QTreeWidgetItem.__init__(self, parent)
self.setText(0, name)
self._node = node
value = node.get("value") and node.get("value") or ""
self.setText(1, value)
self._recurse_children()
def parseIPTree(self, fatherNode, ip):
IPTree = QTreeWidgetItem(fatherNode)
IPTree.setText(0, 'IP')
IPTup = (('v', 'Version: %d' % ip.v),
('hl', 'Header Length: %d' % (ip.hl << 4)),
('tos', 'Differentiated Services: 0x%.2x' % ip.tos),
('len', 'Total Length: %d' % ip.len),
('id', 'Identification: 0x%.4x' % ip.id),
('flag', 'Flags: 0x%.2x' % (ip.off >> 13)),
('off', 'Fragment Offset: %d' % (ip.off & 0x1fff)),
('ttl', 'Time To Live: %d' % ip.ttl),
('p', 'Protocol: %d' % ip.p),
('sum', 'Header Checksum: 0x%.4x' % ip.sum),
('src', 'Source: %s' % NetFormat.ntoa_ip(ip.src)),
('dst', 'Destination: %s' % NetFormat.ntoa_ip(ip.dst))
)
self.parseDetail(IPTree, IPTup)
self.TreeList.append(IPTree)
if ip.p == dpkt.ip.IP_PROTO_TCP:
self.parseTCPTree(fatherNode, ip.data)
elif ip.p == dpkt.ip.IP_PROTO_UDP:
self.parseUDPTree(fatherNode, ip.data)
elif ip.p == dpkt.ip.IP_PROTO_ICMP:
self.parseICMPTree(fatherNode, ip.data)
elif ip.p == dpkt.ip.IP_PROTO_IGMP:
self.parseIGMPTree(fatherNode, ip.data)
else:
self.parseUnknownTree(fatherNode, ip.data)
def updateToc(self, root, entries):
self.clear()
item = QTreeWidgetItem(self, [root, '0'])
curLevel = 0
for (level, h, p, a) in entries:
val = [h, str(p), a]
if level == curLevel:
item = QTreeWidgetItem(item.parent(), val)
elif level < curLevel:
item = QTreeWidgetItem(item.parent().parent(), val)
curLevel = level
else:
item = QTreeWidgetItem(item, val)
curLevel = level
self.expandAll()
def add_program_to_tree(self, program):
program_info = ProgramInfoMain(self.session, self.script_manager,
self.image_version,
self.executable_versions, program)
program_info.name_changed.connect(self.refresh_program_name)
program_info.status_changed.connect(self.refresh_program_status)
item = QTreeWidgetItem([
program.cast_custom_option_value('name', unicode, '<unknown>'),
get_program_short_status(program)
])
item.setData(0, Qt.UserRole, program_info)
self.tree_programs.addTopLevelItem(item)
self.stacked_container.addWidget(program_info)
def onClickItem(self, item: QtGui.QTreeWidgetItem, column: int):
""" Action performed when an item in the QTreeWidget is clicked.
Keyword arguments:
item -- The item user clicked on.
column -- The column number clicked (not used here).
"""
if self.path and self.key != None:
self.saveValue()
if self.data and item.isLeaf() and len(item.text(0).split()) == 1:
# Update GUI
self.dataClicked(item)
else:
# Update GUI
self.dataStructureClicked(item)
def __init__(self, vector):
"""A new QTreeWidgetItem with the QGis layer information added.
:param isVisible: Is the layer visible within the legend.
:type isVisible: bool
:param vector: Vector object from the mapModel
:type vector: model.vector"""
QTreeWidgetItem.__init__(self)
self.setText(0, vector.name)
self.setIcon(0, self.layerIcon)
if vector.isVisible:
self.setCheckState(0, Qt.Checked)
else:
self.setCheckState(0, Qt.Unchecked)
def createNavTreeItems(self):
self.fs = QTreeWidgetItem(self.navtree)
self.fs.setText(0, "File size")
f = "%.2d" % self.heditor.filesize
self.fs.setText(1, f)
self.curoff = QTreeWidgetItem(self.navtree)
self.curoff.setText(0, "Curr. offset")
self.curpage = QTreeWidgetItem(self.navtree)
self.curpage.setText(0, "Curr. page")
self.curblock = QTreeWidgetItem(self.navtree)
self.curblock.setText(0, "Curr. block")
self.cursoroff = QTreeWidgetItem(self.navtree)
self.cursoroff.setText(0, "Cursor")
self.vbox.addWidget(self.navgroup)
def __init__(self, parent=None):
KVBox.__init__(self, parent)
self.help = QLabel(i18n(helpText), self)
self.layout().setAlignment(self.help, Qt.AlignHCenter)
self.setSpacing(10)
hBox = KHBox(self)
display = QTreeWidget(hBox)
display.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
display.setHeaderLabels(["Volume", "File Path", "Accessible"])
display.setColumnWidth(0, 200)
display.setColumnWidth(1, 300)
# retrieve a list of Solid.Device for this machine
deviceList = Solid.Device.allDevices()
# filter the list of all devices and display matching results
# note that we never create a Solid.StorageAccess object, but
# receive one from the 'asDeviceInterface' call
for device in deviceList:
if device.isDeviceInterface(Solid.DeviceInterface.StorageAccess):
access = device.asDeviceInterface(
Solid.DeviceInterface.StorageAccess)
QTreeWidgetItem(display, [
device.product(),
access.filePath(),
str(access.isAccessible())
])
def setExploits(self, exploits):
self.treeWidget.clear()
for exploit in exploits:
widget = self.__stackedWidgetController.getWidget(exploit.category)
if widget:
# Create a dict like {name:exploit}
self.__exploits[exploit.name] = exploit
item = QTreeWidgetItem(self.treeWidget.invisibleRootItem())
item.setText(0, exploit.name)
widget.setExploit(exploit)
# join an exploit with her widget
self.__stackedWidgetController.setExploitWidget(
exploit.name, widget)
self.stackedWidget.addWidget(widget)
self.stackedWidget.setCurrentWidget(widget)
def _open_refinement_folder(self, path):
"""
Reads the refinement folder, setup the folder daemon and signals
:param path: Path to refinement folder
"""
if path != '':
#for i in reversed(range(self.root.childCount())):
# self.root.removeChild(self.root.child(i))
name = os.path.basename(path)
# qname = QString(name)
root = QTreeWidgetItem([str(path)])
self.root_items_path_dictionary[str(path)] = root
self.tree.addTopLevelItem(root)
fm = QFontMetrics(self.font)
w = fm.width(path)
self.tree.setMinimumWidth(w + 150)
#self.root.setText(0, qname)
self.reader.sig_readfolders.emit(path)
self.monitor = MonitorRefinementFolder(path, self.sig_update_tree,
self)
self.timer = QTimer(self)
self.timer.timeout.connect(self.monitor.update)
self.timer.start(2000)
def _makeTreeWidgetItem(self, node):
l = []
l.append("%r" % node.name)
l.append("%1.1f MB" % (node.usedMemory/1024**2.0))
if node.roi is not None:
l.append("%r\n%r" % (list(node.roi[0]), list(node.roi[1])))
else:
l.append("")
if node.dtype is not None:
if node.dtype == numpy.float32:
l.append("float32")
elif node.dtype == numpy.uint8:
l.append("uint8")
elif node.dtype == numpy.uint32:
l.append("uint32")
elif node.dtype == numpy.float64:
l.append("float64")
else:
l.append(str(node.dtype))
else:
l.append("")
t = str(node.type)
t = t[len("<type '")+1:-len("'>")]
t = t.split(".")[-1]
l.append(t)
return QTreeWidgetItem(l)
def add_to_list(self, command, value, status):
self.tree_widget.insertTopLevelItem(
0,
QTreeWidgetItem([
str(round(time.time() - self.start_time, 2)), command, value,
self.get_status_text(status)
]))
def loadBackendsList(self):
self.ui.backendsList.clear()
for instance_name, name, params in self.weboob.backends_config.iter_backends(
):
info = self.weboob.repositories.get_module_info(name)
if not info or (self.caps and not info.has_caps(self.caps)):
continue
item = QTreeWidgetItem(None, [instance_name, name])
item.setCheckState(
0, Qt.Checked if params.get('_enabled', '1').lower()
in ('1', 'y', 'true', 'on', 'yes') else Qt.Unchecked)
self.set_icon(item, info)
self.ui.backendsList.addTopLevelItem(item)
def groupDocument(self, doc):
"""Called, if grouping is enabled, to group the document."""
i = self._items[doc]
p = path(doc.url())
new_parent = self._paths.get(p)
if new_parent is None:
new_parent = self._paths[p] = QTreeWidgetItem(self)
new_parent._path = p
new_parent.setText(0, p or _("Untitled"))
new_parent.setIcon(0, icons.get("folder-open"))
new_parent.setFlags(Qt.ItemIsEnabled)
new_parent.setExpanded(True)
self.sortItems(0, Qt.AscendingOrder)
old_parent = i.parent()
if old_parent == new_parent:
return
if old_parent:
old_parent.takeChild(old_parent.indexOfChild(i))
if old_parent.childCount() == 0:
self.takeTopLevelItem(self.indexOfTopLevelItem(old_parent))
del self._paths[old_parent._path]
else:
self.takeTopLevelItem(self.indexOfTopLevelItem(i))
new_parent.addChild(i)
new_parent.sortChildren(0, Qt.AscendingOrder)
def createSeparatorItem(self):
"""
Creates a new separator item.
:return <QTreeWidgetItem>
"""
item = QTreeWidgetItem([' '])
font = item.font(0)
font.setStrikeOut(True)
item.setFont(0, font)
item.setData(0, Qt.UserRole, qt.wrapVariant('separator'))
flags = item.flags()
flags ^= Qt.ItemIsDropEnabled
item.setFlags(flags)
return item
def cb_enumerate(self, uid, connected_uid, position, hardware_version,
firmware_version, device_identifier, enumeration_type):
if enumeration_type in [IPConnection.ENUMERATION_TYPE_AVAILABLE,
IPConnection.ENUMERATION_TYPE_CONNECTED] and \
uid not in self.connected_uids:
try:
display_name = device_factory.get_device_display_name(
device_identifier)
except KeyError:
return # unknown device identifier
if display_name in device_specs:
self.connected_uids.append(uid)
self.available_item.addChild(
QTreeWidgetItem(['{0} [{1}]'.format(display_name, uid)]))
self.available_item.setText(
0, 'Devices available at {0}:{1}'.format(
self.host, self.port))
self.available_item.sortChildren(0, Qt.AscendingOrder)
else:
if uid in self.connected_uids:
self.connected_uids.remove(uid)
for i in range(self.available_item.childCount()):
child = self.available_item.child(i)
if '[{0}]'.format(uid) in child.text(0):
self.available_item.takeChild(i)
break
if self.available_item.childCount() == 0:
self.available_item.setText(
0, 'No devices available at {0}:{1}'.format(
self.host, self.port))
def __createLayout(self, pathsToAdd):
" Creates the dialog layout "
self.resize(640, 480)
self.setSizeGripEnabled(True)
vboxLayout = QVBoxLayout(self)
# Paths to add part
vboxLayout.addWidget(
QLabel("Paths to add (total: " + str(len(pathsToAdd)) + ")"))
self.__pathToAddView = QTreeWidget()
self.__configTable(self.__pathToAddView)
self.__pathToAddHeader = QTreeWidgetItem(["", "Path"])
self.__pathToAddView.setHeaderItem(self.__pathToAddHeader)
self.__pathToAddView.header().setSortIndicator(PATH_COL,
Qt.AscendingOrder)
self.__pathToAddView.itemChanged.connect(self.__onAddPathChanged)
vboxLayout.addWidget(self.__pathToAddView)
# Buttons at the bottom
buttonBox = QDialogButtonBox(self)
buttonBox.setOrientation(Qt.Horizontal)
buttonBox.setStandardButtons(QDialogButtonBox.Ok
| QDialogButtonBox.Cancel)
self.__OKButton = buttonBox.button(QDialogButtonBox.Ok)
self.__OKButton.setText("Add")
buttonBox.button(QDialogButtonBox.Cancel).setDefault(True)
buttonBox.accepted.connect(self.userAccept)
buttonBox.rejected.connect(self.close)
vboxLayout.addWidget(buttonBox)
return
def cb_frame_read(self, frame_type, identifier, data):
length = len(data)
parts = []
max_length = 0
extended = False
if frame_type == self.can.FRAME_TYPE_STANDARD_DATA:
parts.append('Standard Data')
max_length = 8
elif frame_type == self.can.FRAME_TYPE_STANDARD_REMOTE:
parts.append('Standard Remote')
elif frame_type == self.can.FRAME_TYPE_EXTENDED_DATA:
parts.append('Extended Data')
max_length = 8
extended = True
elif frame_type == self.can.FRAME_TYPE_EXTENDED_REMOTE:
parts.append('Extended Remote')
extended = True
else:
parts.append('Unknown')
parts.append(self.spin_identifier.textFromValue(identifier))
parts.append(' '.join(
['%02X' % c for c in data[:min(length, max_length)]]))
parts.append(str(length))
scroll_bar = self.tree_frames.verticalScrollBar()
at_bottom = scroll_bar.value() == scroll_bar.maximum()
self.tree_frames.addTopLevelItem(QTreeWidgetItem(parts))
if at_bottom:
self.tree_frames.scrollToBottom()
def update_result(self, dir_name_root, file_name, items):
if items:
root_item = FindInFilesRootItem(self, (file_name, ''),
dir_name_root)
root_item.setExpanded(True)
for line, content in items:
QTreeWidgetItem(root_item, (content, str(line + 1)))
def __addGenericTable(self, table):
" Adds a generic table to the report "
theTable = QTreeWidget(self.bodyWidget)
theTable.setAlternatingRowColors(True)
theTable.setRootIsDecorated(False)
theTable.setItemsExpandable(False)
theTable.setSortingEnabled(False)
theTable.setItemDelegate(NoOutlineHeightDelegate(4))
theTable.setUniformRowHeights(True)
headerLabels = []
for index in range(0, len(table.header)):
headerLabels.append(table.header[index])
theTable.setHeaderLabels(headerLabels)
for item in table.body:
row = []
for index in range(0, len(table.header)):
row.append(item[index])
theTable.addTopLevelItem(QTreeWidgetItem(row))
theTable.setFocusPolicy(Qt.NoFocus)
# Resizing
theTable.header().resizeSections(QHeaderView.ResizeToContents)
theTable.header().setStretchLastSection(True)
# Height
self.__setTableHeight(theTable)
self.__vLayout.addWidget(theTable)
self.__widgets.append(theTable)
return
def __init__(self, parent=None):
KVBox.__init__(self, parent)
self.help = QLabel(i18n(helpText), self)
self.layout().setAlignment(self.help, Qt.AlignHCenter)
self.setSpacing(10)
audioDriverStr = {
Solid.AudioInterface.Alsa: "Alsa",\
Solid.AudioInterface.OpenSoundSystem: "Open Sound",\
Solid.AudioInterface.UnknownAudioDriver: "Unknown"
}
audioInterfaceTypeStr = {
Solid.AudioInterface.UnknownAudioInterfaceType: "Unknown",\
Solid.AudioInterface.AudioControl: "Control",\
Solid.AudioInterface.AudioInput: "In",\
Solid.AudioInterface.AudioOutput: "Out"
}
soundcardTypeStr = {
Solid.AudioInterface.InternalSoundcard: "Internal",\
Solid.AudioInterface.UsbSoundcard: "USB",\
Solid.AudioInterface.FirewireSoundcard: "Firewire",\
Solid.AudioInterface.Headset: "Headset",\
Solid.AudioInterface.Modem: "Modem"
}
hBox = KHBox(self)
display = QTreeWidget(hBox)
display.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
display.setHeaderLabels(
["Item", "Name", "Driver", "I/F Type", "Sound Card Type"])
display.setColumnWidth(0, 300)
display.setColumnWidth(1, 300)
display.setColumnWidth(3, 75)
# retrieve a list of Solid.Device for this machine
deviceList = Solid.Device.allDevices()
# filter the list of all devices and display matching results
# note that we never create a Solid.AudioInterface object, but
# receive one from the 'asDeviceInterface' call
for device in deviceList:
if device.isDeviceInterface(Solid.DeviceInterface.AudioInterface):
audio = device.asDeviceInterface(
Solid.DeviceInterface.AudioInterface)
devtype = audio.deviceType()
devstr = []
for key in audioInterfaceTypeStr:
flag = key & devtype
if flag:
devstr.append(audioInterfaceTypeStr[key])
QTreeWidgetItem(display, [
device.product(),
audio.name(), audioDriverStr[audio.driver()],
"/".join(devstr), soundcardTypeStr[audio.soundcardType()]
])
def __init__(self, text, parent = None, icon=None):
"""
Constructs TaskItem widget item
@param task:
@type task: list
@param parent:
@type parent:
"""
QTreeWidgetItem.__init__(self, parent)
self.setText(COL_RUNNING_ID, text )
self.setIcon(COL_RUNNING_ID, QIcon(":/processes.png") )
if icon is not None:
self.setIcon(COL_RUNNING_ID, icon )
def getDestinationNode(self, destinationRoot, catChild, returnNew=True):
"""
Looks for node in destination and returns it. If none is found, creates one and returns it
"""
#get destination parent, creates one in destination if not exists
destinationCatChild = None
if isinstance(catChild, list):
comparisonText = catChild[0]
if returnNew:
itemTextList = [catChild[i] for i in range(len(catChild))]
else:
comparisonText = catChild.text(0)
if returnNew:
itemTextList = [
catChild.text(i) for i in range(catChild.columnCount())
]
for i in range(destinationRoot.childCount()):
candidate = destinationRoot.child(i)
if candidate.text(0) == comparisonText:
#if candidate is found, returns candidate
return candidate
#if candidate is not found, creates one and returns it
if returnNew:
if not destinationCatChild:
return QTreeWidgetItem(destinationRoot, itemTextList)
else:
return None
def __showTaskResourcesClicked(self):
if self.currentTaskHighlighted:
res = list(self.currentTaskHighlighted.definition.resources)
for i in range(len(res)):
res[i] = os.path.abspath(res[i])
res.sort()
self.showTaskResourcesDialog = ShowTaskResourcesDialog(
self.gui.window)
item = QTreeWidgetItem(["Resources"])
self.showTaskResourcesDialog.ui.folderTreeWidget.insertTopLevelItem(
0, item)
self.showTaskResourcesDialog.ui.closeButton.clicked.connect(
self.__showTaskResCloseButtonClicked)
for r in res:
splited = r.split("\\")
insertItem(item, splited)
self.showTaskResourcesDialog.ui.mainSceneFileLabel.setText(
self.currentTaskHighlighted.definition.mainSceneFile)
self.showTaskResourcesDialog.ui.folderTreeWidget.expandAll()
self.showTaskResourcesDialog.show()
def addRow(self, row):
"""
Add row as a new root item
"""
root = QTreeWidgetItem(self)
root.setIcon( 0, QtGui.QIcon( pulimonitor.Config.root_dir+"/rsrc/graph_32.png" ) )
# self.bold = BoldDelegate(self)
# self.standard = StandardDelegate(self)
# self.setItemDelegateForColumn(4, self.bold)
# self.setItemDelegateForColumn(5, self.standard)
self.setItemValues( root, row )
if "items" in row:
for item in row["items"]:
self.addItem( root, item)
def populate_methods(self, parent, c_name, methods):
"""Populate methods"""
for lineno, m_name in methods:
decorator = m_name.startswith('@')
if decorator:
m_name = m_name[1:]
item = QTreeWidgetItem(parent, [m_name])
self.lines[item] = lineno
if m_name.startswith('__'):
item.setIcon(0, get_icon('private2.png'))
elif m_name.startswith('_'):
item.setIcon(0, get_icon('private1.png'))
elif decorator:
item.setIcon(0, get_icon('decorator.png'))
else:
item.setIcon(0, get_icon('method.png'))
def __populate(self):
" Populate the properties list "
# Get the currently selected name
selectedName = None
selected = list(self.__propsView.selectedItems())
if selected:
selectedName = str(selected[0].text(0))
self.__propsView.clear()
properties = readProperties(self.__client, self.__path)
if properties:
for itemPath, itemProps in properties:
if self.__path == itemPath or \
self.__path == itemPath + os.path.sep:
for name, value in itemProps.iteritems():
name = str(name).strip()
value = str(value).strip()
newItem = QTreeWidgetItem([name, value])
self.__propsView.addTopLevelItem(newItem)
self.__resizePropsView()
self.__sortPropsView()
if selectedName:
index = 0
for index in xrange(0, self.__propsView.topLevelItemCount()):
item = self.__propsView.topLevelItem(index)
if selectedName == item.text(0):
item.setSelected(True)
return
def moveTreeItem(self, trFrom, trTo):
if (trFrom.currentItem()):
name = trFrom.currentItem().text(0)
item = QTreeWidgetItem(trTo, QStringList(name))
#add
trFrom.takeTopLevelItem(
trFrom.indexOfTopLevelItem(trFrom.currentItem()))
def processtrigger(self, q):
self.set_params()
if q.text() == 'Загрузить данные':
dlg = QFileDialog()
dlg.setFileMode(QFileDialog.AnyFile)
dlg.setFileMode(QFileDialog.ExistingFiles)
filenames = QStringListModel()
if dlg.exec_():
filenames = dlg.selectedFiles()
if self.active_class_item is not None:
for f in filenames:
self.active_class_item.addChild(QTreeWidgetItem([str(f)]))
img = imread(f, mode='P')
lbl = self.active_class_item.text(0)[
-1] #считаем, что не будет двузначных меток
if self.active_class_item.text(0) == 'Тест':
self.mController.add_test(img, self.params)
else:
self.mController.add_data(img, lbl, self.params)
elif q.text() == 'Очистить':
count = self.active_class_item.childCount()
for _ in range(count):
self.active_class_item.removeChild(
self.active_class_item.child(0))
if self.active_class_item.text(0) == 'Тест':
self.mController.delete_test()
else:
lbl = self.active_class_item.text(0)[-1]
self.mController.delete_data(lbl)
self.active_class_item = None
def __init__(self, parent=None):
super(RestoreDialog, self).__init__(parent)
self.messageLabel().setWordWrap(True)
userguide.addButton(self.buttonBox(), "snippets")
self.tree = QTreeWidget(headerHidden=True, rootIsDecorated=False)
self.setMainWidget(self.tree)
self.deletedItem = QTreeWidgetItem(self.tree)
self.deletedItem.setFlags(Qt.ItemIsUserCheckable)
self.changedItem = QTreeWidgetItem(self.tree)
self.changedItem.setFlags(Qt.ItemIsUserCheckable)
self.tree.itemChanged.connect(self.slotItemChanged)
app.translateUI(self)
app.languageChanged.connect(self.populate)
self.accepted.connect(self.updateSnippets)
qutil.saveDialogSize(self, "snippettool/restoredialog/size")
def addSetEvent(self):
index = self.trSchedTable.topLevelItem(0).indexOfChild(self.curtree)
tbl = self.cfg.table[index]
tbl.actionList.append('SetEvent(NULL,NULL)')
name = QString('SetEvent(NULL,NULL)')
item = QTreeWidgetItem(self.curtree, QStringList(name))
self.curtree.addChild(item)
self.curtree.setExpanded(True)
def addActivateTask(self):
index = self.trSchedTable.topLevelItem(0).indexOfChild(self.curtree)
tbl = self.cfg.table[index]
tbl.actionList.insert(0, 'ActivateTask(NULL)')
name = QString('ActivateTask(NULL)')
item = QTreeWidgetItem(None, QStringList(name))
self.curtree.insertChild(0, item)
self.curtree.setExpanded(True)
