def _addChildrenToParent(self, replaceParentNode, standardItemParent):
if len(replaceParentNode.expressions) > 0:
for e in replaceParentNode.expressions:
if isinstance(e, list):
listItem = QStandardItem('+')
listItem.setEditable(False)
for e2 in e:
item = QStandardItem(self._buildTreeStringLabel(e2))
item.setEditable(False)
self._addChildrenToParent(e2, item)
listItem.appendRow(item)
standardItemParent.appendRow(listItem)
else:
item = QStandardItem(self._buildTreeStringLabel(e))
item.setEditable(False)
self._addChildrenToParent(e, item)
standardItemParent.appendRow(item)
if len(replaceParentNode.children) > 0:
for c in replaceParentNode.children:
item = QStandardItem(self._buildTreeStringLabel(c))
item.setEditable(False)
self._addChildrenToParent(c, item)
standardItemParent.appendRow(item)
def test_tooltree(self):
tree = ToolTree()
role = tree.actionRole()
model = QStandardItemModel()
tree.setModel(model)
item = QStandardItem("One")
item.setData(QAction("One", tree), role)
model.appendRow([item])
cat = QStandardItem("A Category")
item = QStandardItem("Two")
item.setData(QAction("Two", tree), role)
cat.appendRow([item])
item = QStandardItem("Three")
item.setData(QAction("Three", tree), role)
cat.appendRow([item])
model.appendRow([cat])
def p(action):
print "triggered", action.text()
tree.triggered.connect(p)
tree.show()
self.app.exec_()
def on_ions_updated(self, new_ions):
qmodel = QStandardItemModel()
qmodel.setColumnCount(2)
qmodel.setHorizontalHeaderItem(0, QStandardItem('Ion'))
qmodel.setHorizontalHeaderItem(1, QStandardItem('Abundance (%)'))
root = qmodel.invisibleRootItem()
element_keyfunc = lambda x: x.isotope.element
sorted_ions = sorted(new_ions, key=element_keyfunc)
for element, ions in itertools.groupby(sorted_ions, key=element_keyfunc):
element_item = QStandardItem(element)
element_item.setCheckable(True)
element_item.setCheckState(2)
root.appendRow(element_item)
for ion in ions:
ion_name = QStandardItem(ion.name)
ion_name.setData(ion,32)
ion_name.emitDataChanged()
ion_abundance = QStandardItem(str(ion.isotope.abundance))
element_item.appendRow([ion_name, ion_abundance])
self.ionlistTree.setModel(qmodel)
self.ionlistTree.expandAll()
self.addionsButton.setEnabled(True)
self._qmodel=qmodel
def test_tooltree(self):
tree = ToolTree()
role = tree.actionRole()
model = QStandardItemModel()
tree.setModel(model)
item = QStandardItem("One")
item.setData(QAction("One", tree), role)
model.appendRow([item])
cat = QStandardItem("A Category")
item = QStandardItem("Two")
item.setData(QAction("Two", tree), role)
cat.appendRow([item])
item = QStandardItem("Three")
item.setData(QAction("Three", tree), role)
cat.appendRow([item])
model.appendRow([cat])
def p(action):
print "triggered", action.text()
tree.triggered.connect(p)
tree.show()
self.app.exec_()
def findMatches(self):
regexp, content = self.getRegExpAndText()
if not regexp : return # Or if not content : return
end = len(content)
matches = bret.search(regexp, content, 0 if self.NoMatchesLimitCheckBox.isChecked() else self.MatchesLimitSpinBox.value(), 0, end)
headers = [_translate("MatchesTreeView", 'Match', None), _translate("MatchesTreeView", 'From position', None), _translate("MatchesTreeView", 'to position', None)] if self.PositionsCheckBox.isChecked() else [_translate("MatchesTreeView", 'Match', None)]
self.matchesModel.setHorizontalHeaderLabels(headers)
for m in matches :
item = QStandardItem(m.group())
item.setToolTip(_translate("MatchesTreeView", "Double-click to copy", None))
if self.PositionsCheckBox.isChecked() :
startPositionItem = QStandardItem(str(m.start()))
endPositionItem = QStandardItem(str(m.end()))
self.matchesModel.appendRow([item, startPositionItem, endPositionItem])
else :
self.matchesModel.appendRow([item])
if self.GroupsCheckBox.isChecked() :
for i in range(len(m.groups())) :
subgroupItem = QStandardItem(m.group(i+1))
subgroupItem.setToolTip(_translate("MatchesTreeView", "Double-click to copy", None))
if self.PositionsCheckBox.isChecked() :
subgroupStartItem = QStandardItem(str(m.start(i+1)))
subgroupEndItem = QStandardItem(str(m.end(i+1)))
item.appendRow([subgroupItem, subgroupStartItem, subgroupEndItem])
else :
item.appendRow([subgroupItem])
numberOfResults = len(matches)
self.NumberOfResultsLabel.setText('<i>' + _translate("CentralWidget", 'Number of results returned :', None) + ' </i><b>' + str(numberOfResults) + '</b>')
self.MatchesTreeView.expandAll()
self.MatchesTreeView.resizeColumnToContents(0)
def show_frame_info(self, process):
""" show the frame info """
if not self.isVisible:
return
#TODO: no update if top frame is the same
self.clear()
root = self.frame_data.invisibleRootItem()
self.source_files.clear()
self.frames.clear()
if process is None or not process.is_alive:
return
#if process.num_of_threads == 1:
for thread in process:
thread_name = thread.GetName()
if not thread_name:
thread_name = '[No Thread]'
thread_row = QStandardItem(thread_name)
thread_row.setEditable(False)
thread_row.setSelectable(False)
dummy = QStandardItem('')
dummy.setEditable(False)
dummy.setSelectable(False)
root.appendRow([thread_row, dummy])
if len(thread.frames):
self.top_frame = thread.frames[0]
self.frame_changed.emit(self.top_frame)
for frame in thread.frames:
# first show the frame on the top of call stack.
frame_idx = '#%d: ' % frame.idx
frame_info = ''
selectable = False
if frame.name:
frame_idx += frame.name
if self._show_args.isChecked():
args = ','.join([str(x) for x in frame.args])
frame_info += ' (%s)' % args
line = frame.line_entry
if line:
file_info = ' at %s:%d' % (str(line.GetFileSpec()), line.GetLine())
frame_info += file_info
selectable = True
else:
frame_info += str(frame.module.GetFileSpec())
if frame.is_inlined:
frame_info += ' (inlined)'
col_idx = QStandardItem(frame_idx)
self.source_files[col_idx] = line
self.frames[col_idx] = frame
col_idx.setEditable(False)
col_idx.setSelectable(selectable)
col_info = QStandardItem(frame_info)
col_info.setEditable(False)
col_info.setSelectable(selectable)
thread_row.appendRow([col_idx, col_info])
self.expandToDepth(1)
def __init__(self, template, character, parent=None):
super(SubPowerWidget, self).__init__(parent)
self.__storage = template
self.__character = character
self.__model = QStandardItemModel()
# Das ungenutzte Model dient dazu, alle Unterkräfte aufzunehmen, die ich nicht darstellen möchte. Ist einfacher, als diese im View zu verstecken.
self.__modelUnused = QStandardItemModel()
self._layout = QVBoxLayout()
self.setLayout(self._layout)
self.__view = QTreeView()
self.__view.setHeaderHidden(True)
self.__view.setModel(self.__model)
self._layout.addWidget(self.__view)
self._typ = "Subpower"
categories = self.__storage.categories(self._typ)
self.__items = {}
self.__rootItem = QStandardItem()
self.__rootItem = self.__model.invisibleRootItem()
self.__rootItemUnused = QStandardItem()
self.__rootItemUnused = self.__modelUnused.invisibleRootItem()
for item in categories:
categoryItem = QStandardItem(item)
self.__rootItem.appendRow(categoryItem)
## Ich benötige diese Items auch im ungenutzten Model.
categoryItemUnused = QStandardItem(item)
self.__rootItemUnused.appendRow(categoryItemUnused)
traitList = list(self.__character.traits[self._typ][item].items())
traitList.sort()
for trait in traitList:
traitItem = QStandardItem(trait[1].name)
traitItem.setCheckable(True)
## Unhashable Type
self.__items[trait[1]] = traitItem
categoryItem.appendRow(traitItem)
## Funktioniert mit PySide nicht:
#trait[1].availableChanged.connect(traitItem.setEnabled)
## Funktioniert auch mit PySide:
trait[1].availableChanged.connect(
lambda enable, item=traitItem: item.setEnabled(enable))
trait[1].valueChanged.connect(lambda val, trait=trait[
1], item=traitItem: self.__setItemValue(trait, item))
self.__model.itemChanged.connect(self.__getItemValue)
self.__character.speciesChanged.connect(self.hideOrShowToolPage)
self.__character.breedChanged.connect(self.hideOrShowToolPage)
self.__character.factionChanged.connect(self.hideOrShowToolPage)
def importFromTsv(self, filename):
# append file item
rootItem = self.model.invisibleRootItem()
basename = os.path.basename(filename)
parent = QStandardItem(os.path.splitext(basename)[0])
rootItem.appendRow([parent])
# load service info from tsv file
try:
with codecs.open(filename, "r", "utf-8") as f:
lines = f.readlines()
except Exception as e:
QgsMessageLog.logMessage(self.tr("Fail to read {0}: {1}").format(basename, unicode(e)),
self.tr("TileLayerPlugin"))
return False
for i, line in enumerate(lines):
if line.startswith("#"):
continue
vals = line.rstrip().split("\t")
nvals = len(vals)
try:
if nvals < 3:
raise
title, attribution, url = vals[0:3]
if not url:
raise
if nvals < 4:
serviceInfo = TileLayerDefinition(title, attribution, url)
else:
yOriginTop = int(vals[3])
if nvals < 6:
serviceInfo = TileLayerDefinition(title, attribution, url, yOriginTop)
else:
zmin, zmax = map(int, vals[4:6])
if nvals < 10:
serviceInfo = TileLayerDefinition(title, attribution, url, yOriginTop, zmin, zmax)
else:
bbox = BoundingBox.fromString(",".join(vals[6:10]))
epsg = None
try:
epsg = int(vals[10])
except Exception as e:
i = 0
serviceInfo = TileLayerDefinition(title, attribution, url, yOriginTop, zmin, zmax, bbox, epsg)
except:
QgsMessageLog.logMessage(self.tr("Invalid line format: {} line {}").format(basename, i + 1),
self.tr("TileLayerPlugin"))
continue
# append the service info into the tree
vals = serviceInfo.toArrayForTreeView() + [len(self.serviceInfoList)]
rowItems = map(QStandardItem, map(unicode, vals))
parent.appendRow(rowItems)
self.serviceInfoList.append(serviceInfo)
return True
def writeModeData(self,data):
''' get data output and add on QtableWidgets '''
ParentMaster = QStandardItem('[ {0[src]} > {0[dst]} ] {1[Method]} {1[Host]}{1[Path]}'.format(
data['urlsCap']['IP'], data['urlsCap']['Headers']))
ParentMaster.setIcon(QIcon('icons/accept.png'))
ParentMaster.setSizeHint(QSize(30,30))
for item in data['urlsCap']['Headers']:
ParentMaster.appendRow([QStandardItem('{}'.format(item)),
QStandardItem(data['urlsCap']['Headers'][item])])
self.model.appendRow(ParentMaster)
self.setFirstColumnSpanned(ParentMaster.row(),
self.rootIndex(), True)
self.scrollToBottom()
def writeModeData(self,data):
''' get data output and add on QtableWidgets '''
ParentMaster = QStandardItem('[ {0[src]} > {0[dst]} ] {1[Method]} {1[Host]}{1[Path]}'.format(
data['urlsCap']['IP'], data['urlsCap']['Headers']))
ParentMaster.setIcon(QIcon('icons/accept.png'))
ParentMaster.setSizeHint(QSize(30,30))
for item in data['urlsCap']['Headers']:
ParentMaster.appendRow([QStandardItem('{}'.format(item)),
QStandardItem(data['urlsCap']['Headers'][item])])
self.model.appendRow(ParentMaster)
self.setFirstColumnSpanned(ParentMaster.row(),
self.rootIndex(), True)
self.scrollToBottom()
def addNcFile(self, ncFileName):
f = NetCDFFile(ncFileName)
self.files[ncFileName] = f
fItem = QStandardItem(ncFileName)
fItem.setIcon(self.icons['file'])
fItem.setData(QVariant(ncFileName))
fItem.ncItem = ('F', f)
self.rootItem.appendRow(fItem)
for an,av in ncFAttributes(f).items():
aItem = QStandardItem(an)
aItem.setIcon(self.icons['attribute'])
aItem.setData(QVariant(an))
aItem.ncItem = ('A', av)
fItem.appendRow(aItem)
for dn,dv in f.dimensions.items():
dItem = QStandardItem(dn)
dItem.setIcon(self.icons['dimension'])
dItem.setData(QVariant(dn))
dItem.ncItem = ('D', dv)
fItem.appendRow(dItem)
for vn, vv in f.variables.items():
vItem = QStandardItem(vn)
vItem.setIcon(self.icons['variable'])
vItem.setData(QVariant(vn))
vItem.ncItem = ('V', vv)
fItem.appendRow(vItem)
for an,av in ncVAttributes(vv).items():
aItem = QStandardItem(an)
aItem.setIcon(self.icons['attribute'])
aItem.setData(QVariant(an))
aItem.ncItem = ('A', av)
vItem.appendRow(aItem)
def update_bp_info(self, target):
""" update breakpoint info """
self.clear()
root = self.bp_data.invisibleRootItem()
for breakpoint in target.breakpoint_iter():
if not breakpoint.IsValid() or breakpoint.IsInternal():
continue
bp_item = QStandardItem(str(breakpoint.id))
bp_row =[bp_item, QStandardItem(str(breakpoint.GetHitCount())),
QStandardItem(str(breakpoint.GetIgnoreCount())), QStandardItem(str(breakpoint.GetCondition()))]
for loc in breakpoint:
loc_row = [QStandardItem(str(loc.GetID())), QStandardItem(str(loc.GetAddress().GetLineEntry()))]
bp_item.appendRow(loc_row)
root.appendRow(bp_row)
self.expandToDepth(1)
def add_widget(self, n):
std_item = QStandardItem('{}th item'.format(n))
self._datamodel.setItem(n, 0, std_item)
node_widget = QPushButton('{}th button'.format(n))
qindex_widget = self._datamodel.index(n, 1, QModelIndex())
self.setIndexWidget(qindex_widget, node_widget)
if n == 2:
std_item_child = QStandardItem('child')
std_item.appendRow(std_item_child)
node_widget_child = QPushButton('petit button')
qindex_widget_child = self._datamodel.index(n, 1, QModelIndex())
self.setIndexWidget(qindex_widget_child, node_widget_child)
def add_widget(self, n):
std_item = QStandardItem('{}th item'.format(n))
self._datamodel.setItem(n, 0, std_item)
node_widget = QPushButton('{}th button'.format(n))
qindex_widget = self._datamodel.index(n, 1, QModelIndex())
self.setIndexWidget(qindex_widget, node_widget)
if n == 2:
std_item_child = QStandardItem('child')
std_item.appendRow(std_item_child)
node_widget_child = QPushButton('petit button')
qindex_widget_child = self._datamodel.index(n, 1, QModelIndex())
self.setIndexWidget(qindex_widget_child, node_widget_child)
def model_init(self):
categories = {}
if not categories:
with open('categories.json') as f:
categories = load(f)
for element in categories:
catItem = QStandardItem(element.keys()[0])
catItem.setCheckable(True)
catItem.setCheckState(element[element.keys()[0]])
for type_name, check_state in element["Types"].items():
typeItem = QStandardItem(type_name)
typeItem.setCheckable(True)
typeItem.setCheckState(check_state)
catItem.appendRow(typeItem)
self.model.appendRow(catItem)
self.treeView.setModel(self.model)
self.submit_file_types()
def addPeakToOneCluster(self, action):
#if action.text() == 'Identification':
#print "launch Identification"
# return
idx = self.view.treeView_3.selectedIndexes()[0]
model = idx.model()
s = self.currentSample[
2] #self.model.sample(idx.parent().data().toString(), fullNameEntry=False)
peak = s.peakAt(str(idx.data().toString()))
peakToAdd = s.peakAt(str(action.text()))
peak.fragCluster += [peakToAdd] #first add the parent
peak.fragCluster += peakToAdd.fragCluster + peakToAdd.isoCluster #then add its child
#add item
item = QStandardItem(action.text())
gotFragItem = False
for i in xrange(model.itemFromIndex(idx).rowCount()):
if model.itemFromIndex(idx).child(
i).text() == "fragments/adducts:":
gotFragItem = True
fragItem = model.itemFromIndex(idx).child(i)
fragItem.appendRow(item)
break
if not gotFragItem:
fragItem = QStandardItem("fragments/adducts:")
fragItem.appendRow(item)
model.itemFromIndex(idx).appendRow(fragItem)
#remove the entry peakToAdd
for i in xrange(model.rowCount()):
item_ = model.item(i, 0)
if item_.text() == s.shortName():
for j in xrange(item_.rowCount()):
if item_.child(j).text() == action.text():
selector = self.view.treeView_3.selectionModel()
for idx in self.view.treeView_3.selectedIndexes():
selector.select(idx, QItemSelectionModel.Deselect)
item.setIcon(item_.child(j).icon())
selector.select(model.indexFromItem(item_.child(j)),
QItemSelectionModel.Select)
self.view.treeView_3.removeSelected()
break
break
def addCategory( self, category, items ):
# Items
root = QStandardItem( category )
root.setFlags( Qt.ItemIsEnabled | Qt.ItemIsSelectable )
self._model.appendRow( root )
# Styling
root.setFlags( Qt.ItemIsEnabled )
f = root.font()
f.setPointSize( 10 )
f.setBold( True )
root.setFont( f )
for item in items:
ins = item()
child = QStandardItem( QIcon.fromTheme( ins.iconname ), ins.description )
child.setData( QVariant( item ), Qt.UserRole )
child.setFlags( Qt.ItemIsEnabled | Qt.ItemIsSelectable | Qt.ItemIsDragEnabled )
if ins.__doc__ is not None and len( ins.__doc__ ) > 0: child.setWhatsThis( ins.__doc__ )
root.appendRow( child )
def updateStagesModel(self):
'''
Used to update the tree model for the Stages tree
'''
self.stagesModel.clear()
parent = self.stagesModel.invisibleRootItem();
i = 0
for stage in self.stageTrees:
i += 1
stageItem = QStandardItem(stage.replaceVariable)
stageItem.setEditable(False)
item = QStandardItem(self._buildTreeStringLabel(stage))
item.setEditable(False)
self._addChildrenToParent(stage, item)
stageItem.appendRow(item)
parent.appendRow(stageItem)
self.ui.stagesTreeView.setModel(self.stagesModel)
def __init__(self, data, parent=None):
"""Constructor."""
super(GDALLocationInfoForm, self).__init__(parent)
self.setupUi(self)
self.treeView.setSelectionBehavior(QAbstractItemView.SelectRows)
model = QStandardItemModel()
model.setHorizontalHeaderLabels([self.tr('object/attribute'), self.tr('value')])
self.treeView.setModel(model)
self.treeView.setUniformRowHeights(True)
for object_name, object_attrs in data.items():
parent = QStandardItem(object_name)
for attr_name, attr_value in object_attrs.items():
attr_name_item = QStandardItem(attr_name)
attr_value_item = QStandardItem(attr_value)
parent.appendRow([attr_name_item, attr_value_item])
model.appendRow(parent)
def addPeakToOneCluster(self, action):
#if action.text() == 'Identification':
#print "launch Identification"
# return
idx=self.view.treeView_3.selectedIndexes()[0]
model=idx.model()
s=self.currentSample[2]#self.model.sample(idx.parent().data().toString(), fullNameEntry=False)
peak= s.peakAt(str(idx.data().toString()))
peakToAdd=s.peakAt(str(action.text()))
peak.fragCluster += [peakToAdd]#first add the parent
peak.fragCluster += peakToAdd.fragCluster+peakToAdd.isoCluster#then add its child
#add item
item=QStandardItem(action.text())
gotFragItem=False
for i in xrange (model.itemFromIndex(idx).rowCount()):
if model.itemFromIndex(idx).child(i).text() == "fragments/adducts:":
gotFragItem = True
fragItem = model.itemFromIndex(idx).child(i)
fragItem.appendRow(item)
break
if not gotFragItem:
fragItem = QStandardItem("fragments/adducts:")
fragItem.appendRow(item)
model.itemFromIndex(idx).appendRow(fragItem)
#remove the entry peakToAdd
for i in xrange(model.rowCount()):
item_=model.item(i, 0)
if item_.text()==s.shortName():
for j in xrange(item_.rowCount()):
if item_.child(j).text()==action.text():
selector=self.view.treeView_3.selectionModel()
for idx in self.view.treeView_3.selectedIndexes():
selector.select(idx ,QItemSelectionModel.Deselect)
item.setIcon(item_.child(j).icon())
selector.select(model.indexFromItem(item_.child(j)), QItemSelectionModel.Select)
self.view.treeView_3.removeSelected()
break
break
def populateTree(self, disco):
if len(disco) > 0:
attribs = [
x + "modified" for x in disco[0].getOptionalValues(self.comm)
]
nodes = [QStandardItem("unmatchableStringForNonEmptyInit")]
# Create root node
root = QStandardItem('All music')
self.model().appendRow(root)
else:
# Create empty root node
root = [QStandardItem('Nothing')]
self.model().appendRow(root)
# For every song
for s in disco:
attr = s.getOptionalValues(self.comm)
length = len(attr)
# First attribut separated because attached to node
if attr[0] != attribs[0]:
node = QStandardItem(attr[0])
nodes = [node]
attribs = [x + "modified" for x in attr]
root.appendRow(nodes[0])
attribs[0] = attr[0]
for i in range(1, length - 1):
if (attr[i] != attribs[i]):
node = QStandardItem(attr[i])
nodes[i - 1].appendRow(node)
if i < len(nodes):
nodes[i] = node
else:
nodes.append(node)
attribs[i] = attr[i]
# Last attribut
node = QStandardItem(attr[length - 1])
nodes[-1].appendRow(node)
node.setData(s)
def __init__(self, parent = None):
QDialog.__init__(self)
self.setupUi(self)
self.selectedDevice = None
self.listdevices = {}
self.devices = Devices()
self.logical = Logical()
self.combodevice = TreeComboBox()
self.gridLayout.addWidget(self.combodevice, 0, 1, 1, 1)
self.__model = QStandardItemModel()
lidx = 0
if len(self.logical):
logicalitems = QStandardItem(self.tr("Logical drives"))
self.__model.appendRow(logicalitems)
for lidx in range(0, len(self.logical)):
logicalitem = QStandardItem(self.logical[lidx].model())
logicalitems.appendRow(logicalitem)
self.listdevices[lidx] = self.logical[lidx]
lidx += 1
if len(self.devices):
physicalitems = QStandardItem(self.tr("Physical drives"))
self.__model.appendRow(physicalitems)
for pidx in range(0, len(self.devices)):
model = self.devices[pidx].model()
if model != "Unknown":
physicalitem = QStandardItem(self.devices[pidx].blockDevice() + " (" + model + ")")
else:
physicalitem = QStandardItem(self.devices[pidx].blockDevice())
physicalitems.appendRow(physicalitem)
self.listdevices[lidx+pidx] = self.devices[pidx]
self.combodevice.setModel(self.__model)
self.combodevice.view().expandAll()
if len(self.devices):
self.setDeviceInformations(self.devices[0], True)
self.selectedDevice = self.devices[0]
self.connect(self.combodevice, SIGNAL("currentIndexChanged(int)"), self.deviceChanged)
def populateTree(self,disco):
if len(disco) >0:
attribs = [x+"modified" for x in disco[0].getOptionalValues(self.comm)]
nodes = [QStandardItem("unmatchableStringForNonEmptyInit")]
# Create root node
root = QStandardItem('All music')
self.model().appendRow(root)
else:
# Create empty root node
root = [QStandardItem('Nothing')]
self.model().appendRow(root)
# For every song
for s in disco:
attr = s.getOptionalValues(self.comm)
length=len(attr)
# First attribut separated because attached to node
if attr[0] != attribs[0]:
node=QStandardItem(attr[0])
nodes = [node]
attribs = [x+"modified" for x in attr]
root.appendRow(nodes[0])
attribs[0]=attr[0]
for i in range(1, length-1):
if (attr[i] != attribs[i]):
node=QStandardItem(attr[i])
nodes[i-1].appendRow(node)
if i<len(nodes):
nodes[i]=node
else:
nodes.append(node)
attribs[i]=attr[i]
# Last attribut
node = QStandardItem(attr[length-1])
nodes[-1].appendRow(node)
node.setData(s)
def addCategory(self, category, items):
# Items
root = QStandardItem(category)
root.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable)
self._model.appendRow(root)
# Styling
root.setFlags(Qt.ItemIsEnabled)
f = root.font()
f.setPointSize(10)
f.setBold(True)
root.setFont(f)
for item in items:
ins = item()
child = QStandardItem(QIcon.fromTheme(ins.iconname),
ins.description)
child.setData(QVariant(item), Qt.UserRole)
child.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable
| Qt.ItemIsDragEnabled)
if ins.__doc__ is not None and len(ins.__doc__) > 0:
child.setWhatsThis(ins.__doc__)
root.appendRow(child)
def append_order_details(self, order_item, order):
order_id = QStandardItem(self.tr('订单编号： ' + str(order.order_id)))
strategy_id = QStandardItem(self.tr('策略编号： ') + str(order.strategy_id))
symbol = QStandardItem(self.tr('品种： ') + str(order.symbol))
direction = self.tr('买入') if order.type == ORDER_BUY else self.tr('卖出')
direction = QStandardItem(self.tr('方向： ') + direction)
price = QStandardItem(self.tr('开仓价： ') + str(order.price))
open_time = QStandardItem(self.tr('开仓时间： ') + str(order.order_time))
order_profit = QStandardItem(self.tr('总盈利： ') + str(order.profit))
close_profit = QStandardItem(self.tr('每次平仓盈利'))
for item in zip(order.get_close_profit_list(),
order.get_close_time_list()):
cp = QStandardItem(str(item[1]) + self.tr(': ') + str(item[0]))
close_profit.appendRow(cp)
order_item.appendRow(order_id)
order_item.appendRow(strategy_id)
order_item.appendRow(symbol)
order_item.appendRow(direction)
order_item.appendRow(price)
order_item.appendRow(open_time)
order_item.appendRow(order_profit)
order_item.appendRow(close_profit)
def updateComboQueries(self):
self.queriesModel.clear()
self.queriesModel.setHorizontalHeaderLabels(['Files'])
item = QStandardItem(self.tr(u"Query File"))
item.setSelectable(False)
self.queriesModel.appendRow(item)
# read directories with sql files
for path, dirs, files in os.walk(self.queriesFolder):
for rep in dirs:
item = QStandardItem(rep)
item.setData(rep, Qt.UserRole)
item.setSelectable(False)
self.queriesModel.appendRow(item)
# in each directory, look for sql files
for nomfich in glob.glob(self.queriesFolder + "/" + rep + "/*.sql"):
fileName, fileExtension = os.path.splitext(os.path.basename(nomfich))
# one item found
subitem = QStandardItem(fileName)
subitem.setData(nomfich, Qt.UserRole)
item.appendRow(subitem)
def actualizeClusterModel(sample):
model = QApplication.instance().view.clusterModel
if model.rowCount():
model.clear()
idItems = []
for peak in sample.imappedPeaks():
std_item = QStandardItem(str(peak))
std_item.setEditable(False)
if peak.isFoundInDatabase:
std_item.setBackground(QBrush(Qt.green))
#put the formula with the best score
o = QStandardItem(peak.formulas.keys()[0])
o.setBackground(QBrush(Qt.green))
idItems.append(o)
else:
idItems.append(QStandardItem("not found"))
MSDialogController.setRightIcon(peak, std_item)
if peak.isoCluster:
iso_item = QStandardItem("isotopic cluster:")
iso_item.setEditable(False)
for iso in peak.isoCluster:
item = QStandardItem(str(iso))
item.setEditable(False)
MSDialogController.setRightIcon(iso, item)
iso_item.appendRow(item)
std_item.appendRow(iso_item)
if peak.fragCluster:
frag_item = QStandardItem("fragments/adducts:")
frag_item.setEditable(False)
for frag in peak.fragCluster:
item = QStandardItem("/".join([
str(frag.mass()),
str(frag.rt),
str(frag.annotation.values())[2:-2]
]))
item.setEditable(False)
MSDialogController.setRightIcon(frag, item)
frag_item.appendRow(item)
std_item.appendRow(frag_item)
model.appendRow(std_item)
model.appendColumn(idItems)
def actualizeClusterModel(sample):
model=QApplication.instance().view.clusterModel
if model.rowCount():
model.clear()
idItems = []
for peak in sample.imappedPeaks():
std_item = QStandardItem(str(peak))
std_item.setEditable(False)
if peak.isFoundInDatabase:
std_item.setBackground(QBrush(Qt.green))
#put the formula with the best score
o = QStandardItem(peak.formulas.keys()[0])
o.setBackground(QBrush(Qt.green))
idItems.append(o)
else:
idItems.append(QStandardItem("not found"))
MSDialogController.setRightIcon(peak, std_item)
if peak.isoCluster:
iso_item = QStandardItem("isotopic cluster:")
iso_item.setEditable(False)
for iso in peak.isoCluster:
item = QStandardItem(str(iso))
item.setEditable(False)
MSDialogController.setRightIcon(iso, item)
iso_item.appendRow(item)
std_item.appendRow(iso_item)
if peak.fragCluster:
frag_item = QStandardItem("fragments/adducts:")
frag_item.setEditable(False)
for frag in peak.fragCluster:
item =QStandardItem("/".join([str(frag.mass()), str(frag.rt), str(frag.annotation.values())[2:-2]]))
item.setEditable(False)
MSDialogController.setRightIcon(frag, item)
frag_item.appendRow(item)
std_item.appendRow(frag_item)
model.appendRow(std_item)
model.appendColumn(idItems)
def __init__(self, template, character, parent=None):
super(SubPowerWidget, self).__init__(parent)
self.__storage = template
self.__character = character
self.__model = QStandardItemModel()
# Das ungenutzte Model dient dazu, alle Unterkräfte aufzunehmen, die ich nicht darstellen möchte. Ist einfacher, als diese im View zu verstecken.
self.__modelUnused = QStandardItemModel()
self._layout = QVBoxLayout()
self.setLayout( self._layout )
self.__view = QTreeView()
self.__view.setHeaderHidden(True)
self.__view.setModel( self.__model)
self._layout.addWidget(self.__view)
self._typ = "Subpower"
categories = self.__storage.categories(self._typ)
self.__items = {}
self.__rootItem = QStandardItem()
self.__rootItem = self.__model.invisibleRootItem()
self.__rootItemUnused = QStandardItem()
self.__rootItemUnused = self.__modelUnused.invisibleRootItem()
for item in categories:
categoryItem = QStandardItem(item)
self.__rootItem.appendRow(categoryItem)
## Ich benötige diese Items auch im ungenutzten Model.
categoryItemUnused = QStandardItem(item)
self.__rootItemUnused.appendRow(categoryItemUnused)
traitList = list( self.__character.traits[self._typ][item].items() )
traitList.sort()
for trait in traitList:
traitItem = QStandardItem(trait[1].name)
traitItem.setCheckable(True)
## Unhashable Type
self.__items[trait[1]] = traitItem
categoryItem.appendRow(traitItem)
## Funktioniert mit PySide nicht:
#trait[1].availableChanged.connect(traitItem.setEnabled)
## Funktioniert auch mit PySide:
trait[1].availableChanged.connect(
lambda enable, item=traitItem: item.setEnabled(enable)
)
trait[1].valueChanged.connect(
lambda val, trait=trait[1], item=traitItem: self.__setItemValue(trait, item)
)
self.__model.itemChanged.connect(self.__getItemValue)
self.__character.speciesChanged.connect(self.hideOrShowToolPage)
self.__character.breedChanged.connect(self.hideOrShowToolPage)
self.__character.factionChanged.connect(self.hideOrShowToolPage)
class ProjectXML():
def __init__(self, xmlPath, treeControl, parent=None):
""" Constructor """
if xmlPath is None or not os.path.isfile(xmlPath):
msg = "..."
q = QMessageBox(QMessageBox.Warning, "Could not find that file",
msg)
q.setStandardButtons(QMessageBox.Ok)
i = QIcon()
i.addPixmap(QPixmap("..."), QIcon.Normal)
q.setWindowIcon(i)
q.exec_()
else:
self.tree = treeControl
self.model = QStandardItemModel()
# Set up an invisible root item for the tree.
#self.treeRoot = self.model.invisibleRootItem()
self.treeRoot = QStandardItem("Root Item")
self.model.appendRow(self.treeRoot)
self.tree.setModel(self.model)
self.tree.doubleClicked.connect(self.item_doubleClicked)
self.tree.customContextMenuRequested.connect(self.openMenu)
self.tree.setDragEnabled(True)
self.xmlTreeDir = os.path.join(os.path.dirname(__file__),
"Resources/XML/")
self.xmlProjfile = xmlPath
self.xmlProjDir = os.path.dirname(xmlPath)
self.namespace = "{http://tempuri.org/ProjectDS.xsd}"
self.xmlTreePath = None
# Load the GCD Project (the raw data that will be used to populate the tree)
# instead of ET.fromstring(xml)
self.xmlProjectDoc = self.LoadXMLFile(self.xmlProjfile)
if self.FindTreeParser():
print "got ya"
# Load the tree file (the rules we use to build the tree)
else:
print "This is an error"
# Set up the first domino for the recursion
projectName = self.xmlProjectDoc.find("Project/name")
if projectName is not None:
self.treeRoot.setText(projectName.text)
self.LoadNode(None, self.xmlTemplateDoc.find("node"),
self.xmlProjectDoc)
self.tree.expandToDepth(5)
def FindTreeParser(self):
# Now we need to figure out which kind of project it is.
for subdir, dirs, files in os.walk(self.xmlTreeDir):
for filename in files:
if filename.endswith(".xml"):
filePath = os.path.join(subdir, filename)
candidate = self.LoadXMLFile(filePath)
testNode = candidate.find('test')
if len(testNode.text) > 10 and not testNode is None:
if self.xmlProjectDoc.find("./" +
testNode.text) is not None:
found = True
self.xmlTreePath = filePath
self.xmlTemplateDoc = ET.parse(self.xmlTreePath)
return True
return False
def LoadXMLFile(self, file):
with open(file, 'r') as myfile:
data = myfile.read().replace('\n', '')
it = ET.iterparse(StringIO(data))
# strip all namespaces
for _, el in it:
if '}' in el.tag:
el.tag = el.tag.split('}', 1)[1]
return it.root
def LoadNode(self, tnParent, templateNode, projNode):
""" Load a single node """
data = {}
label = self.getLabel(templateNode, projNode)
# Detect if this is an XML node element and reset the root Project node to this.
entityType = templateNode.find('entity/type')
entityXPath = templateNode.find('entity/xpath')
newProjNode = projNode
if entityXPath is not None:
newProjNode = projNode.find(entityXPath.text)
# This node might be a leaf. If so we need to get some meta dat
if entityType is not None and entityXPath is not None:
filepathNode = projNode.find(entityXPath.text)
if filepathNode is not None:
# normalize the slashes
# filepath = re.sub('[\\\/]+', os.path.sep, filepathNode.text)
# make it an absolute path
filepath = os.path.join(self.xmlProjDir, filepathNode.text)
data['filepath'] = filepath
if entityXPath is not None:
data['xpath'] = entityXPath.text
symbologyNode = templateNode.find('entity/symbology')
if symbologyNode is not None:
data['symbology'] = symbologyNode.text
# Add the leaf to the tree
newTreeItem = QStandardItem(label)
if tnParent is None:
self.treeRoot.appendRow(newTreeItem)
else:
tnParent = tnParent.appendRow(newTreeItem)
# Just a regular node with children
for xChild in templateNode.findall("children/node"):
self.LoadNode(newTreeItem, xChild, newProjNode)
for xRepeater in templateNode.findall("children/repeater"):
self.LoadRepeater(newTreeItem, xRepeater, newProjNode)
data['group_layers'] = self.getTreeAncestry(newTreeItem)
newTreeItem.setData(data)
def LoadRepeater(self, tnParent, templateNode, projNode):
""" Repeater is for using an XPAth in the project file for repeating elements """
label = self.getLabel(templateNode, projNode)
newTreeItem = QStandardItem(label)
if tnParent is None:
self.treeRoot.appendRow(newTreeItem)
else:
tnParent = tnParent.appendRow(newTreeItem)
# REmember, repeaters can only contain one "pattern" node
xPatternNode = templateNode.find("node")
# If there is an Xpath then reset the base project node to that.
xpath = templateNode.find("xpath")
xNewProjList = []
if xPatternNode is not None and xpath is not None:
absoluteXPath = xpath.text[:1] == "/"
# Should we search from the root or not.
if absoluteXPath:
xNewProjList = self.xmlProjectDoc.findall("." + xpath.text)
else:
xNewProjList = projNode.findall(xpath.text)
for xProjChild in xNewProjList:
self.LoadNode(newTreeItem, xPatternNode, xProjChild)
def getTreeAncestry(self, item):
ancestry = []
parent = item.parent()
while parent is not None:
ancestry.append(parent.text())
parent = parent.parent()
ancestry.reverse()
return ancestry
def item_doubleClicked(self, index):
item = self.tree.selectedIndexes()[0]
self.addToMap(item.model().itemFromIndex(index))
def openMenu(self, position):
""" Handle the contextual menu """
index = self.tree.selectedIndexes()[0]
item = index.model().itemFromIndex(index)
menu = QMenu()
receiver = lambda item=item: self.addToMap(item)
menu.addAction("Add to Map", receiver)
menu.exec_(self.tree.viewport().mapToGlobal(position))
def getLabel(self, templateNode, projNode):
""" Either use the liral text inside <label> or look it
up in the project node if there's a <label xpath="/x/path">
"""
labelNode = templateNode.find("label")
label = "TITLE_NOT_FOUND"
if labelNode is not None:
if "xpath" in labelNode.attrib:
xpath = labelNode.attrib['xpath']
label = projNode.find(xpath).text
else:
label = labelNode.text
return label
def addToMap(self, item):
print "ADDING TO MAP::", item.data()
itemExt = path.splitext(item.data()['filepath'])[1]
if itemExt == '.shp':
AddVectorLayer(item)
else:
AddRasterLayer(item)
def fillTree(self):
self.items = {}
self.model.clear()
self.model.setHorizontalHeaderLabels([self.tr('Setting'),
self.tr('Value')])
text = unicode(self.searchBox.text())
settings = ProcessingConfig.getSettings()
rootItem = self.model.invisibleRootItem()
priorityKeys = [self.tr('General'), self.tr('Models'), self.tr('Scripts')]
for group in priorityKeys:
groupItem = QStandardItem(group)
icon = ProcessingConfig.getGroupIcon(group)
groupItem.setIcon(icon)
groupItem.setEditable(False)
emptyItem = QStandardItem()
emptyItem.setEditable(False)
rootItem.insertRow(0, [groupItem, emptyItem])
for setting in settings[group]:
if setting.hidden or setting.name.startswith("MENU_"):
continue
if text == '' or text.lower() in setting.description.lower():
labelItem = QStandardItem(setting.description)
labelItem.setIcon(icon)
labelItem.setEditable(False)
self.items[setting] = SettingItem(setting)
groupItem.insertRow(0, [labelItem, self.items[setting]])
if text != '':
self.tree.expand(groupItem.index())
providersItem = QStandardItem(self.tr('Providers'))
icon = QIcon(os.path.join(pluginPath, 'images', 'alg.png'))
providersItem.setIcon(icon)
providersItem.setEditable(False)
emptyItem = QStandardItem()
emptyItem.setEditable(False)
rootItem.insertRow(0, [providersItem, emptyItem])
for group in settings.keys():
if group in priorityKeys or group == menusSettingsGroup:
continue
groupItem = QStandardItem(group)
icon = ProcessingConfig.getGroupIcon(group)
groupItem.setIcon(icon)
groupItem.setEditable(False)
for setting in settings[group]:
if setting.hidden:
continue
if text == '' or text.lower() in setting.description.lower():
labelItem = QStandardItem(setting.description)
labelItem.setIcon(icon)
labelItem.setEditable(False)
self.items[setting] = SettingItem(setting)
groupItem.insertRow(0, [labelItem, self.items[setting]])
emptyItem = QStandardItem()
emptyItem.setEditable(False)
providersItem.appendRow([groupItem, emptyItem])
menusItem = QStandardItem(self.tr('Menus (requires restart)'))
icon = QIcon(os.path.join(pluginPath, 'images', 'menu.png'))
menusItem.setIcon(icon)
menusItem.setEditable(False)
emptyItem = QStandardItem()
emptyItem.setEditable(False)
rootItem.insertRow(0, [menusItem, emptyItem])
providers = Processing.providers
for provider in providers:
groupItem = QStandardItem(provider.getDescription())
icon = provider.getIcon()
groupItem.setIcon(icon)
groupItem.setEditable(False)
for alg in provider.algs:
labelItem = QStandardItem(alg.name)
labelItem.setIcon(icon)
labelItem.setEditable(False)
try:
setting = ProcessingConfig.settings["MENU_" + alg.commandLineName()]
except:
continue
self.items[setting] = SettingItem(setting)
groupItem.insertRow(0, [labelItem, self.items[setting]])
emptyItem = QStandardItem()
emptyItem.setEditable(False)
menusItem.appendRow([groupItem, emptyItem])
self.tree.sortByColumn(0, Qt.AscendingOrder)
self.adjustColumns()
def add_device_to_tree(self, device):
# check if device is already added
if len(device['uid']) > 0:
for row in range(self.model_devices.rowCount()):
existing_name = self.model_devices.item(row, 0).text()
exisitng_uid = self.tree_devices.indexWidget(self.model_devices.item(row, 1).index()).text()
if device['name'] == existing_name and device['uid'] == exisitng_uid:
EventLogger.info('Ignoring duplicate device "{0}" with UID "{1}"'
.format(device['name'], device['uid']))
return
# add device
name_item = QStandardItem(device['name'])
uid_item = QStandardItem('')
self.model_devices.appendRow([name_item, uid_item])
edit_uid = QLineEdit()
edit_uid.setPlaceholderText('Enter UID')
edit_uid.setValidator(QRegExpValidator(QRegExp('^[{0}]{{1,6}}$'.format(BASE58)))) # FIXME: use stricter logic
edit_uid.setText(device['uid'])
self.tree_devices.setIndexWidget(uid_item.index(), edit_uid)
value_specs = device_specs[device['name']]['values']
parent_item = QStandardItem('Values')
name_item.appendRow([parent_item, QStandardItem('')])
self.tree_devices.expand(parent_item.index())
# add values
for value_spec in value_specs:
value_name_item = QStandardItem(value_spec['name'])
value_interval_item = QStandardItem('')
parent_item.appendRow([value_name_item, value_interval_item])
spinbox_interval = QSpinBox()
spinbox_interval.setRange(0, (1 << 31) - 1)
spinbox_interval.setSingleStep(1)
spinbox_interval.setValue(device['values'][value_spec['name']]['interval'])
spinbox_interval.setSuffix(' seconds')
self.tree_devices.setIndexWidget(value_interval_item.index(), spinbox_interval)
if value_spec['subvalues'] != None:
for subvalue_name in value_spec['subvalues']:
subvalue_name_item = QStandardItem(subvalue_name)
subvalue_check_item = QStandardItem('')
value_name_item.appendRow([subvalue_name_item, subvalue_check_item])
check_subvalue = QCheckBox()
check_subvalue.setChecked(device['values'][value_spec['name']]['subvalues'][subvalue_name])
self.tree_devices.setIndexWidget(subvalue_check_item.index(), check_subvalue)
self.tree_devices.expand(name_item.index())
# add options
option_specs = device_specs[device['name']]['options']
if option_specs != None:
parent_item = QStandardItem('Options')
name_item.appendRow([parent_item, QStandardItem('')])
for option_spec in option_specs:
option_name_item = QStandardItem(option_spec['name'])
option_widget_item = QStandardItem('')
parent_item.appendRow([option_name_item, option_widget_item])
if option_spec['type'] == 'choice':
widget_option_value = QComboBox()
for option_value_spec in option_spec['values']:
widget_option_value.addItem(option_value_spec[0].decode('utf-8'), option_value_spec[1])
widget_option_value.setCurrentIndex(widget_option_value.findText(device['options'][option_spec['name']]['value'].decode('utf-8')))
elif option_spec['type'] == 'int':
widget_option_value = QSpinBox()
widget_option_value.setRange(option_spec['minimum'], option_spec['maximum'])
widget_option_value.setSuffix(option_spec['suffix'])
widget_option_value.setValue(device['options'][option_spec['name']]['value'])
elif option_spec['type'] == 'bool':
widget_option_value = QCheckBox()
widget_option_value.setChecked(device['options'][option_spec['name']]['value'])
self.tree_devices.setIndexWidget(option_widget_item.index(), widget_option_value)
def add_device_to_tree(self, device):
# check if device is already added
if len(device['uid']) > 0:
for row in range(self.model_devices.rowCount()):
existing_name = self.model_devices.item(row, 0).text()
exisitng_uid = self.tree_devices.indexWidget(
self.model_devices.item(row, 1).index()).text()
if device['name'] == existing_name and device[
'uid'] == exisitng_uid:
EventLogger.info(
'Ignoring duplicate device "{0}" with UID "{1}"'.
format(device['name'], device['uid']))
return
# add device
name_item = QStandardItem(device['name'])
uid_item = QStandardItem('')
self.model_devices.appendRow([name_item, uid_item])
edit_uid = QLineEdit()
edit_uid.setPlaceholderText('Enter UID')
edit_uid.setValidator(
QRegExpValidator(QRegExp(
'^[{0}]{{1,6}}$'.format(BASE58)))) # FIXME: use stricter logic
edit_uid.setText(device['uid'])
self.tree_devices.setIndexWidget(uid_item.index(), edit_uid)
value_specs = device_specs[device['name']]['values']
parent_item = QStandardItem('Values')
name_item.appendRow([parent_item, QStandardItem('')])
self.tree_devices.expand(parent_item.index())
# add values
for value_spec in value_specs:
value_name_item = QStandardItem(value_spec['name'])
value_interval_item = QStandardItem('')
parent_item.appendRow([value_name_item, value_interval_item])
spinbox_interval = QSpinBox()
spinbox_interval.setRange(0, (1 << 31) - 1)
spinbox_interval.setSingleStep(1)
spinbox_interval.setValue(
device['values'][value_spec['name']]['interval'])
spinbox_interval.setSuffix(' seconds')
self.tree_devices.setIndexWidget(value_interval_item.index(),
spinbox_interval)
if value_spec['subvalues'] != None:
for subvalue_name in value_spec['subvalues']:
subvalue_name_item = QStandardItem(subvalue_name)
subvalue_check_item = QStandardItem('')
value_name_item.appendRow(
[subvalue_name_item, subvalue_check_item])
check_subvalue = QCheckBox()
check_subvalue.setChecked(device['values'][
value_spec['name']]['subvalues'][subvalue_name])
self.tree_devices.setIndexWidget(
subvalue_check_item.index(), check_subvalue)
self.tree_devices.expand(name_item.index())
# add options
option_specs = device_specs[device['name']]['options']
if option_specs != None:
parent_item = QStandardItem('Options')
name_item.appendRow([parent_item, QStandardItem('')])
for option_spec in option_specs:
option_name_item = QStandardItem(option_spec['name'])
option_widget_item = QStandardItem('')
parent_item.appendRow([option_name_item, option_widget_item])
if option_spec['type'] == 'choice':
widget_option_value = QComboBox()
for option_value_spec in option_spec['values']:
widget_option_value.addItem(
option_value_spec[0].decode('utf-8'),
option_value_spec[1])
widget_option_value.setCurrentIndex(
widget_option_value.findText(device['options'][
option_spec['name']]['value'].decode('utf-8')))
elif option_spec['type'] == 'int':
widget_option_value = QSpinBox()
widget_option_value.setRange(option_spec['minimum'],
option_spec['maximum'])
widget_option_value.setSuffix(option_spec['suffix'])
widget_option_value.setValue(
device['options'][option_spec['name']]['value'])
elif option_spec['type'] == 'bool':
widget_option_value = QCheckBox()
widget_option_value.setChecked(
device['options'][option_spec['name']]['value'])
self.tree_devices.setIndexWidget(option_widget_item.index(),
widget_option_value)
class SubPowerWidget(QWidget):
"""
@brief Zeigt alle Unterkräfte in einer Baumstruktur an.
"""
def __init__(self, template, character, parent=None):
super(SubPowerWidget, self).__init__(parent)
self.__storage = template
self.__character = character
self.__model = QStandardItemModel()
# Das ungenutzte Model dient dazu, alle Unterkräfte aufzunehmen, die ich nicht darstellen möchte. Ist einfacher, als diese im View zu verstecken.
self.__modelUnused = QStandardItemModel()
self._layout = QVBoxLayout()
self.setLayout(self._layout)
self.__view = QTreeView()
self.__view.setHeaderHidden(True)
self.__view.setModel(self.__model)
self._layout.addWidget(self.__view)
self._typ = "Subpower"
categories = self.__storage.categories(self._typ)
self.__items = {}
self.__rootItem = QStandardItem()
self.__rootItem = self.__model.invisibleRootItem()
self.__rootItemUnused = QStandardItem()
self.__rootItemUnused = self.__modelUnused.invisibleRootItem()
for item in categories:
categoryItem = QStandardItem(item)
self.__rootItem.appendRow(categoryItem)
## Ich benötige diese Items auch im ungenutzten Model.
categoryItemUnused = QStandardItem(item)
self.__rootItemUnused.appendRow(categoryItemUnused)
traitList = list(self.__character.traits[self._typ][item].items())
traitList.sort()
for trait in traitList:
traitItem = QStandardItem(trait[1].name)
traitItem.setCheckable(True)
## Unhashable Type
self.__items[trait[1]] = traitItem
categoryItem.appendRow(traitItem)
## Funktioniert mit PySide nicht:
#trait[1].availableChanged.connect(traitItem.setEnabled)
## Funktioniert auch mit PySide:
trait[1].availableChanged.connect(
lambda enable, item=traitItem: item.setEnabled(enable))
trait[1].valueChanged.connect(lambda val, trait=trait[
1], item=traitItem: self.__setItemValue(trait, item))
self.__model.itemChanged.connect(self.__getItemValue)
self.__character.speciesChanged.connect(self.hideOrShowToolPage)
self.__character.breedChanged.connect(self.hideOrShowToolPage)
self.__character.factionChanged.connect(self.hideOrShowToolPage)
def __setItemValue(self, trait, item):
"""
Setzt den Wert der Angezeigten Items.
"""
if trait.value == 0:
item.setCheckState(Qt.Unchecked)
elif trait.value == 1:
item.setCheckState(Qt.PartiallyChecked)
else:
item.setCheckState(Qt.Checked)
def __getItemValue(self, item):
"""
Setzt den Wert der Eigenschaft im Speicher.
"""
for trait in self.__items.items():
if id(trait[1]) == id(item):
trait[0].value = item.checkState()
break
def hideOrShowToolPage(self, res):
"""
Alle Eigenschaften, die nicht zur Verfügung stehen, werden verborgen, indem sie in ein anderes Model verschoben werden.
\bug Möglicher Fehler in PySide: Der Aufruf von QStandardItem.model() führt beim Beenden des Programms zu einem Segmentation Fault.
"""
# Versteckt alle Unterkräfte, die zu gewähltem Charakter nicht passen.
for item in self.__items.items():
if ((item[0].species
and item[0].species != self.__character.species) or
(item[0].only and self.__character.breed not in item[0].only
and self.__character.faction not in item[0].only)):
#self.__view.setRowHidden(item[1].index().row(), item[1].parent().index(), True)
#Debug.debug(item[1].model())
## Hier wird beispielsweise besagter Aufruf getätigt, der zu einem segfault führt.
if item[1].model() == self.__model:
parent = item[1].parent()
itemUnused = parent.takeRow(item[1].index().row())
parentUnused = self.__modelUnused.findItems(
parent.text())[0]
parentUnused.appendRow(itemUnused)
else:
#self.__view.setRowHidden(item[1].index().row(), item[1].parent().index(), False)
if item[1].model() == self.__modelUnused:
parent = item[1].parent()
itemUsed = parent.takeRow(item[1].index().row())
parentUsed = self.__model.findItems(parent.text())[0]
parentUsed.appendRow(itemUsed)
## Versteckt alle Elternzeilen, wenn sie keine Kinder enthalten.
for i in range(self.__model.rowCount()):
categoryItem = self.__model.item(i)
if categoryItem.hasChildren():
self.__view.setRowHidden(categoryItem.index().row(),
self.__rootItem.index(), False)
else:
self.__view.setRowHidden(categoryItem.index().row(),
self.__rootItem.index(), True)
for j in range(4):
item = QStandardItem("({0}, {1})".format(i, j))
model.setItem(i, j, item)
if i == 1:
item.appendRow([QStandardItem("..({0}, {1})".format(i*3, k)) for k in range(4)])
"""
model = QStandardItemModel(2,1)
model.setHorizontalHeaderItem(0,QStandardItem("Menu"))
cadastro = QStandardItem("Cadastro")
model.setItem(0,0,cadastro)
pesquisa = QStandardItem("Pesquisa")
model.setItem(1,0,pesquisa)
for i in ["Usuarios", "Empresas"]:
cadastro.appendRow(QStandardItem(i))
pesquisa.appendRow(QStandardItem(i))
parent = QModelIndex()
"""model = QDirModel()
model.setFilter(QDir.AllDirs | QDir.NoDotAndDotDot)
parent = model.index(QDir.currentPath())"""
"""model = QFileSystemModel()"""
p = PainelConsole()
l = TreeViewTela(6)
l.setModel(model)
l.setRootIndex(parent)
class OrderTreeModel(QAbstractItemModel):
""""""
order_reg = re.compile(u'订单[0-9]+')
def __init__(self, order):
super(OrderTreeModel, self).__init__()
self.__root = QStandardItem()
self.append_orders(order)
def data(self, index, role=Qt.DisplayRole):
"""获取index位置的数据"""
if not index.isValid():
return QVariant()
if role == Qt.TextColorRole:
node = self.node_from_index(index)
string = node.text()
if OrderTreeModel.order_reg.match(string): # 订单结点
profit_child = node.child(6) # 第6个孩子结点是收益结点
if '-' in profit_child.text(): # 收益为负，订单结点绿色，否则红色
return QBrush(QColor(0, 180, 0))
else:
return QBrush(QColor(255, 0, 0))
elif role == Qt.DisplayRole:
node = self.node_from_index(index)
return QVariant(node.text())
else:
return QVariant()
def node_from_index(self, index):
if index.isValid():
return index.internalPointer()
else:
return self.__root
def index(self, row, column, parent=None, *args, **kwargs):
if not self.hasIndex(row, column, parent):
return QModelIndex()
if not parent.isValid():
parent_item = self.__root
else:
parent_item = parent.internalPointer()
child_item = parent_item.child(row)
if child_item:
return self.createIndex(row, column, child_item)
else:
return QModelIndex()
def parent(self, index=None):
if not index.isValid():
return QModelIndex()
child_item = index.internalPointer()
parent_item = child_item.parent()
if parent_item == self.__root:
return QModelIndex()
return self.createIndex(parent_item.row(), 0, parent_item)
def columnCount(self, parent=None, *args, **kwargs):
return 1
def rowCount(self, parent=None, *args, **kwargs):
if not parent.isValid():
parent_item = self.__root
else:
parent_item = parent.internalPointer()
return parent_item.rowCount()
def append_orders(self, orders):
for i, order in enumerate(orders):
order_item = QStandardItem(self.tr('订单') + str(i))
self.append_order_details(order_item, order)
self.__root.appendRow(order_item)
def append_order_details(self, order_item, order):
order_id = QStandardItem(self.tr('订单编号： ' + str(order.order_id)))
strategy_id = QStandardItem(self.tr('策略编号： ') + str(order.strategy_id))
symbol = QStandardItem(self.tr('品种： ') + str(order.symbol))
direction = self.tr('买入') if order.type == ORDER_BUY else self.tr('卖出')
direction = QStandardItem(self.tr('方向： ') + direction)
price = QStandardItem(self.tr('开仓价： ') + str(order.price))
open_time = QStandardItem(self.tr('开仓时间： ') + str(order.order_time))
order_profit = QStandardItem(self.tr('总盈利： ') + str(order.profit))
close_profit = QStandardItem(self.tr('每次平仓盈利'))
for item in zip(order.get_close_profit_list(),
order.get_close_time_list()):
cp = QStandardItem(str(item[1]) + self.tr(': ') + str(item[0]))
close_profit.appendRow(cp)
order_item.appendRow(order_id)
order_item.appendRow(strategy_id)
order_item.appendRow(symbol)
order_item.appendRow(direction)
order_item.appendRow(price)
order_item.appendRow(open_time)
order_item.appendRow(order_profit)
order_item.appendRow(close_profit)
class SubPowerWidget(QWidget):
"""
@brief Zeigt alle Unterkräfte in einer Baumstruktur an.
"""
def __init__(self, template, character, parent=None):
super(SubPowerWidget, self).__init__(parent)
self.__storage = template
self.__character = character
self.__model = QStandardItemModel()
# Das ungenutzte Model dient dazu, alle Unterkräfte aufzunehmen, die ich nicht darstellen möchte. Ist einfacher, als diese im View zu verstecken.
self.__modelUnused = QStandardItemModel()
self._layout = QVBoxLayout()
self.setLayout( self._layout )
self.__view = QTreeView()
self.__view.setHeaderHidden(True)
self.__view.setModel( self.__model)
self._layout.addWidget(self.__view)
self._typ = "Subpower"
categories = self.__storage.categories(self._typ)
self.__items = {}
self.__rootItem = QStandardItem()
self.__rootItem = self.__model.invisibleRootItem()
self.__rootItemUnused = QStandardItem()
self.__rootItemUnused = self.__modelUnused.invisibleRootItem()
for item in categories:
categoryItem = QStandardItem(item)
self.__rootItem.appendRow(categoryItem)
## Ich benötige diese Items auch im ungenutzten Model.
categoryItemUnused = QStandardItem(item)
self.__rootItemUnused.appendRow(categoryItemUnused)
traitList = list( self.__character.traits[self._typ][item].items() )
traitList.sort()
for trait in traitList:
traitItem = QStandardItem(trait[1].name)
traitItem.setCheckable(True)
## Unhashable Type
self.__items[trait[1]] = traitItem
categoryItem.appendRow(traitItem)
## Funktioniert mit PySide nicht:
#trait[1].availableChanged.connect(traitItem.setEnabled)
## Funktioniert auch mit PySide:
trait[1].availableChanged.connect(
lambda enable, item=traitItem: item.setEnabled(enable)
)
trait[1].valueChanged.connect(
lambda val, trait=trait[1], item=traitItem: self.__setItemValue(trait, item)
)
self.__model.itemChanged.connect(self.__getItemValue)
self.__character.speciesChanged.connect(self.hideOrShowToolPage)
self.__character.breedChanged.connect(self.hideOrShowToolPage)
self.__character.factionChanged.connect(self.hideOrShowToolPage)
def __setItemValue(self, trait, item):
"""
Setzt den Wert der Angezeigten Items.
"""
if trait.value == 0:
item.setCheckState(Qt.Unchecked)
elif trait.value == 1:
item.setCheckState(Qt.PartiallyChecked)
else:
item.setCheckState(Qt.Checked)
def __getItemValue(self, item):
"""
Setzt den Wert der Eigenschaft im Speicher.
"""
for trait in self.__items.items():
if id(trait[1]) == id(item):
trait[0].value = item.checkState()
break
def hideOrShowToolPage(self, res):
"""
Alle Eigenschaften, die nicht zur Verfügung stehen, werden verborgen, indem sie in ein anderes Model verschoben werden.
\bug Möglicher Fehler in PySide: Der Aufruf von QStandardItem.model() führt beim Beenden des Programms zu einem Segmentation Fault.
"""
# Versteckt alle Unterkräfte, die zu gewähltem Charakter nicht passen.
for item in self.__items.items():
if (
(
item[0].species and
item[0].species != self.__character.species
) or (
item[0].only and
self.__character.breed not in item[0].only and
self.__character.faction not in item[0].only
)
):
#self.__view.setRowHidden(item[1].index().row(), item[1].parent().index(), True)
#Debug.debug(item[1].model())
## Hier wird beispielsweise besagter Aufruf getätigt, der zu einem segfault führt.
if item[1].model() == self.__model:
parent = item[1].parent()
itemUnused = parent.takeRow(item[1].index().row())
parentUnused = self.__modelUnused.findItems(parent.text())[0]
parentUnused.appendRow(itemUnused)
else:
#self.__view.setRowHidden(item[1].index().row(), item[1].parent().index(), False)
if item[1].model() == self.__modelUnused:
parent = item[1].parent()
itemUsed = parent.takeRow(item[1].index().row())
parentUsed = self.__model.findItems(parent.text())[0]
parentUsed.appendRow(itemUsed)
## Versteckt alle Elternzeilen, wenn sie keine Kinder enthalten.
for i in range(self.__model.rowCount()):
categoryItem = self.__model.item(i)
if categoryItem.hasChildren():
self.__view.setRowHidden(categoryItem.index().row(), self.__rootItem.index(), False)
else:
self.__view.setRowHidden(categoryItem.index().row(), self.__rootItem.index(), True)
class GCDXML():
def __init__(self, xmlPath, treeControl, parent = None):
""" Constructor """
if xmlPath is None or not os.path.isfile(xmlPath):
msg = "..."
q = QMessageBox(QMessageBox.Warning, "Could not find that file", msg)
q.setStandardButtons(QMessageBox.Ok);
i = QIcon()
i.addPixmap(QPixmap("..."), QIcon.Normal)
q.setWindowIcon(i)
q.exec_()
else:
self.tree = treeControl
self.model = QStandardItemModel()
# Set up an invisible root item for the tree.
#self.treeRoot = self.model.invisibleRootItem()
self.treeRoot = QStandardItem("Root Item")
self.model.appendRow(self.treeRoot)
self.tree.setModel(self.model)
self.tree.doubleClicked.connect(self.item_doubleClicked)
self.tree.customContextMenuRequested.connect(self.openMenu)
self.tree.setDragEnabled(True)
# This is the GCD projet viewer so no harm in hardcoding this for now.
self.xmlTreePath = os.path.join(os.path.dirname(__file__), "Resources/XML/gcd_tree.xml")
self.xmlProjfile = xmlPath
self.xmlProjDir = os.path.dirname(xmlPath)
self.namespace = "{http://tempuri.org/ProjectDS.xsd}"
# Load the tree file (the rules we use to build the tree)
self.xmlTemplateDoc = ET.parse(self.xmlTreePath)
# Load the GCD Project (the raw data that will be used to populate the tree)
# instead of ET.fromstring(xml)
with open(self.xmlProjfile, 'r') as myfile:
data=myfile.read().replace('\n', '')
it = ET.iterparse(StringIO(data))
for _, el in it:
if '}' in el.tag:
el.tag = el.tag.split('}', 1)[1] # strip all namespaces
self.xmlProjectDoc = it.root
# Set up the first domino for the recursion
projectName = self.xmlProjectDoc.find("Project/Name")
if projectName is not None:
self.treeRoot.setText(projectName.text)
self.LoadNode(None, self.xmlTemplateDoc.find("node"), self.xmlProjectDoc)
self.tree.expandToDepth(5)
def LoadNode(self, tnParent, templateNode, projNode):
""" Load a single node """
data = {}
label = self.getLabel(templateNode, projNode)
# Detect if this is an XML node element and reset the root Project node to this.
entityType = templateNode.find('entity/type')
entityXPath = templateNode.find('entity/xpath')
newProjNode = projNode
if entityXPath is not None:
newProjNode = projNode.find(entityXPath.text)
# This node might be a leaf. If so we need to get some meta dat
if entityType is not None:
filepathNode = projNode.find(entityXPath.text)
if filepathNode is not None:
# normalize the slashes
filepath = re.sub('[\\\/]+', os.path.sep, filepathNode.text)
# make it an absolute path
filepath = os.path.join(self.xmlProjDir, filepath)
data['filepath'] = filepath
if entityXPath is not None:
data['xpath'] = entityXPath.text
symbologyNode = templateNode.find('entity/symbology')
if symbologyNode is not None:
data['symbology'] = symbologyNode.text
# Add the leaf to the tree
newTreeItem = QStandardItem(label)
if tnParent is None:
self.treeRoot.appendRow(newTreeItem)
else:
tnParent = tnParent.appendRow(newTreeItem)
# Just a regular node with children
for xChild in templateNode.findall("children/node"):
self.LoadNode(newTreeItem, xChild, newProjNode)
for xRepeater in templateNode.findall("children/repeater"):
self.LoadRepeater(newTreeItem, xRepeater, newProjNode)
data['group_layers'] = self.getTreeAncestry(newTreeItem)
newTreeItem.setData(data)
def LoadRepeater(self, tnParent, templateNode, projNode):
""" Repeater is for using an XPAth in the project file for repeating elements """
label = self.getLabel(templateNode, projNode)
newTreeItem = QStandardItem(label)
if tnParent is None:
self.treeRoot.appendRow(newTreeItem)
else:
tnParent = tnParent.appendRow(newTreeItem)
# REmember, repeaters can only contain one "pattern" node
xPatternNode = templateNode.find("node")
# If there is an Xpath then reset the base project node to that.
xpath = templateNode.find("xpath")
xNewProjList = []
if xPatternNode is not None and xpath is not None:
absoluteXPath = xpath.text[:1] == "/"
# Should we search from the root or not.
if absoluteXPath:
xNewProjList = self.xmlProjectDoc.findall("." + xpath.text)
else:
xNewProjList = projNode.findall(xpath.text)
for xProjChild in xNewProjList:
self.LoadNode(newTreeItem, xPatternNode, xProjChild)
def getTreeAncestry(self, item):
ancestry = []
parent = item.parent()
while parent is not None:
ancestry.append(parent.text())
parent = parent.parent()
ancestry.reverse()
return ancestry
def item_doubleClicked(self, index):
item = self.tree.selectedIndexes()[0]
self.addToMap( item.model().itemFromIndex(index))
def openMenu(self, position):
""" Handle the contextual menu """
index = self.tree.selectedIndexes()[0]
item = index.model().itemFromIndex(index)
menu = QMenu()
receiver = lambda item=item: self.addToMap(item)
menu.addAction("Add to Map", receiver)
menu.exec_(self.tree.viewport().mapToGlobal(position))
def getLabel(self, templateNode, projNode):
""" Either use the liral text inside <label> or look it
up in the project node if there's a <label xpath="/x/path">
"""
labelNode = templateNode.find("label")
label = "TITLE_NOT_FOUND"
if labelNode is not None:
if "xpath" in labelNode.attrib:
xpath = labelNode.attrib['xpath']
label = projNode.find(xpath).text
else:
label = labelNode.text
return label
def addToMap(self, item):
print "ADDING TO MAP::", item.data()
AddRasterLayer(item)
def randomize_groups(self):
#participant_list_form = Participant_list()
#participant_list_form.show()
#participant_list_form.ui3.label.setText("sdsdfdsf")
#ex2.ui.label_6.setText("test")
participant_list_form = ex3
# participant_list_form = Participant_list()
# participant_list_form.show()
tv = participant_list_form.ui3.tableView
# set the table model
tablemdata = 0
#tabledata.append([2, 2, 2, 2, 2])
# tabledata.remove([0])
# tabledata.append([1, 1, 1, 1, 1])
# table.model().layoutChanged.emit()
tablemodel = MyTableModel(tabledata, header, self)
rowcount = int(tablemodel.rowCount(None))
tvmodel = tv.model()
nums = [x+1 for x in range(rowcount)]
random.shuffle(nums)
print nums
#iterating list
#print i+1 % groups_to_create
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# init widgets
view = ex8.ui8.treeView
view.setSelectionBehavior(QAbstractItemView.SelectRows)
model = QStandardItemModel()
model.setHorizontalHeaderLabels(header)
view.setModel(model)
view.setUniformRowHeights(True)
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# populate data
groups_to_create = int(self.ui.lineEdit.text())
participants_in_group = int(self.ui.lineEdit_2.text())
divider = 0
group = 1
parent1 = QStandardItem('Grupa {}'.format(group))
for i, val in enumerate(nums):
if divider == participants_in_group:
divider = 0
group = group + 1
parent1 = QStandardItem('Grupa {}'.format(group))
divider = divider + 1
if val != 0:
print "Grupa " + str(group) + " Osoby: " + str(val)
self.tableindex_id = tablemodel.index (val-1,1)
self.tableindex_surname = tablemodel.index (val-1,2)
child1 = QStandardItem(str(val)+' '+" ")
child2 = QStandardItem(str(tablemodel.data(self.tableindex_id, Qt.DisplayRole)))
child3 = QStandardItem(str(tablemodel.data(self.tableindex_surname, Qt.DisplayRole)))
parent1.appendRow([child1, child2, child3])
model.appendRow(parent1)
# span container columns
view.setFirstColumnSpanned(i, view.rootIndex(), True)
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# expand third container
index = model.indexFromItem(parent1)
view.expand(index)
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# select last row
selmod = view.selectionModel()
index2 = model.indexFromItem(child3)
selmod.select(index2, QItemSelectionModel.Select | QItemSelectionModel.Rows)
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
print i+1
if i+1 > 3:
print i / groups_to_create
else:
print i / groups_to_create
#index = tablemodel.index(row, 1)
print nums
def fillTree(self):
self.items = {}
self.model.clear()
self.model.setHorizontalHeaderLabels([self.tr('Setting'),
self.tr('Value')])
text = unicode(self.searchBox.text())
settings = ProcessingConfig.getSettings()
rootItem = self.model.invisibleRootItem()
priorityKeys = [self.tr('General'), self.tr('Models'), self.tr('Scripts')]
for group in priorityKeys:
groupItem = QStandardItem(group)
icon = ProcessingConfig.getGroupIcon(group)
groupItem.setIcon(icon)
groupItem.setEditable(False)
emptyItem = QStandardItem()
emptyItem.setEditable(False)
rootItem.insertRow(0, [groupItem, emptyItem])
for setting in settings[group]:
if setting.hidden:
continue
if text == '' or text.lower() in setting.description.lower():
labelItem = QStandardItem(setting.description)
labelItem.setIcon(icon)
labelItem.setEditable(False)
self.items[setting] = SettingItem(setting)
groupItem.insertRow(0, [labelItem, self.items[setting]])
if text != '':
self.tree.expand(groupItem.index())
providersItem = QStandardItem(self.tr('Providers'))
icon = QIcon(os.path.join(pluginPath, 'images', 'alg.png'))
providersItem.setIcon(icon)
providersItem.setEditable(False)
emptyItem = QStandardItem()
emptyItem.setEditable(False)
rootItem.insertRow(0, [providersItem, emptyItem])
for group in settings.keys():
if group in priorityKeys:
continue
groupItem = QStandardItem(group)
icon = ProcessingConfig.getGroupIcon(group)
groupItem.setIcon(icon)
groupItem.setEditable(False)
for setting in settings[group]:
if setting.hidden:
continue
if text == '' or text.lower() in setting.description.lower():
labelItem = QStandardItem(setting.description)
labelItem.setIcon(icon)
labelItem.setEditable(False)
self.items[setting] = SettingItem(setting)
groupItem.insertRow(0, [labelItem, self.items[setting]])
emptyItem = QStandardItem()
emptyItem.setEditable(False)
providersItem.appendRow([groupItem, emptyItem])
self.tree.sortByColumn(0, Qt.AscendingOrder)
self.adjustColumns()
def func(*args):
parent1 = QStandardItem('par')
child3 = QStandardItem('child')
child2 = QStandardItem('child2')
parent1.appendRow([child2, child3])
model.appendRow(parent1)
