def CreateTreeItem(self, node, parentId):
itemId = self.AppendItem(parentId, node.GetLabel(), node.imageIndex,
-1, wx.TreeItemData(node))
node.SetAttributes(self, itemId)
self.visibleNodes[node] = itemId
if node.childs:
self.SetItemHasChildren(itemId, True)
if node in self.expandedNodes:
self.Expand(itemId)
return itemId
def add_root(self, text=None, image=None, selected_image=None, data=None):
if text is None:
text = ""
if image is None:
image = -1
if selected_image is None:
selected_image = -1
if data is not None and not IS_PHOENIX:
data = wx.TreeItemData(data)
return self.control.AddRoot(text, image, selected_image, data)
def __init__(self, *args, **kargs):
wx.TreeCtrl.__init__(self, *args, **kargs)
tBIL = WorkerRegistry.getInstance().getToolBoxInfoList()
rootId = self.AddRoot('toolboxes')
for tBI in tBIL:
toolBoxId = self.AppendItem(rootId, tBI.name)
for workerInfo in tBI.workerInfos:
wIId = self.AppendItem(toolBoxId, workerInfo.name)
self.SetItemData(wIId, wx.TreeItemData(workerInfo))
self.Bind(wx.EVT_TREE_BEGIN_DRAG, self.onDragInit, id=self.GetId())
def refreshCtrl(self):
self.DeleteAllItems()
title = self.model.config.options['Title']
rootItem = self.AddRoot(title,
0,
data=wx.TreeItemData(
(title, None, self.model.contents)))
self.SetItemHasChildren(rootItem, True)
self.Expand(rootItem)
def LoadFolderTree(self, folderParentId, folderTree, ParentTreeNode):
childFolders = self.FindChildFolders(folderParentId, folderTree)
for childFolder in childFolders:
childTreeNode = self.m_treeCtrlFoldersAndFiles.AppendItem(ParentTreeNode, childFolder["Name"])
self.m_treeCtrlFoldersAndFiles.SetItemData(childTreeNode,
wx.TreeItemData(treenodeinfo.TreeNodeInfo('', childFolder["FolderID"])))
self.m_treeCtrlFoldersAndFiles.SetItemImage(childTreeNode, 1, wx.TreeItemIcon_Normal)
self.LoadFolderTree(childFolder["FolderID"], folderTree, childTreeNode)
def __init__(self, parent, flow, **kwargs):
super(TaskStatusTreePanel, self).__init__(parent, -1, **kwargs)
main_sizer = wx.BoxSizer(wx.VERTICAL)
vbox = wx.BoxSizer(wx.VERTICAL)
panel1 = awx.Panel(self, -1)
panel2 = awx.Panel(self, -1)
self.tree = tree = wx.TreeCtrl(panel1, 1, wx.DefaultPosition, (-1, -1),
wx.TR_HIDE_ROOT | wx.TR_HAS_BUTTONS)
root = self.tree.AddRoot('Task Status')
# entry = collections.namedtuple("Entry", "task wi ti")
#print(status2entries)
self.status2entries = flow.groupby_status()
self.status_nodes = []
for status, entries in self.status2entries.items():
node = tree.AppendItem(root,
"%d %s tasks" % (len(entries), str(status)),
data=wx.TreeItemData(status))
self.status_nodes.append(node)
for entry in entries:
tree.AppendItem(node,
"Task: " + str(entry.task),
data=wx.TreeItemData(entry))
tree.Bind(wx.EVT_TREE_SEL_CHANGED, self.onSelChanged)
tree.Bind(wx.EVT_TREE_ITEM_RIGHT_CLICK, self.onItemRightClick)
self.display = wx.StaticText(panel2,
-1,
'', (10, 10),
style=wx.ALIGN_LEFT)
vbox.Add(self.tree, 1, wx.EXPAND)
main_sizer.Add(panel1, 1, wx.EXPAND)
main_sizer.Add(panel2, 1, wx.EXPAND)
panel1.SetSizerAndFit(vbox)
self.SetSizerAndFit(main_sizer)
self.Centre()
def _add_filter_group(self, root, groupname, rows):
filterGroup = self.movieFilter.AppendItem(root, groupname)
for row in rows:
rowid, name, count = row
itemText = name + u" ({0})".format(count)
self.movieFilter.AppendItem(filterGroup,
itemText,
data=wx.TreeItemData(
(groupname, rowid)))
return filterGroup
def _add_child(self, parent_tree_item_id, child_fs_node):
"""Adds a fs_node to a tree item"""
try:
label = self.node_tool.get_name(child_fs_node)
lower_label = label.lower()
# find a pos to insert(sort by label)
child_tree_item_id, cookie = self.GetFirstChild(
parent_tree_item_id)
index = 0
while child_tree_item_id.IsOk():
child_label = self.GetItemText(child_tree_item_id)
if lower_label < child_label.lower():
break
index += 1
child_tree_item_id, cookie = self.GetNextChild(
parent_tree_item_id, cookie)
if index < self.GetChildrenCount(parent_tree_item_id):
child_tree_item_id = self.InsertItemBefore(
parent_tree_item_id,
index,
text=label,
image=self.get_image_id_by_node(child_fs_node),
data=wx.TreeItemData(child_fs_node))
else:
child_tree_item_id = self.AppendItem(
parent_tree_item_id,
text=label,
image=self.get_image_id_by_node(child_fs_node),
data=wx.TreeItemData(child_fs_node))
self._fs_node_to_tree_item_id[child_fs_node] = child_tree_item_id
if self._add_children(child_tree_item_id):
self.SetItemHasChildren(child_tree_item_id, True)
return child_tree_item_id
except Exception, e:
log.error('failed to add child: %s', child_fs_node.uuid)
print e
raise
def create_layout(self):
self.main_grid = wx.BoxSizer(wx.HORIZONTAL)
tree_ctrl_size = wx.Size(220, -1)
style = wx.TR_DEFAULT_STYLE | wx.TR_HIDE_ROOT | wx.TR_TWIST_BUTTONS | wx.TR_NO_LINES
# style = wx.TR_HAS_BUTTONS | wx.TR_SINGLE | wx.TR_HIDE_ROOT
tree_ctrl_id = id_renew('settings.tree', update=True)
tree_ctrl = wx.TreeCtrl(self, id=tree_ctrl_id, style=style)
tree_ctrl.SetMinSize(tree_ctrl_size)
root_key = MODULE_KEY.join(['settings', 'tree', 'root'])
root_node = tree_ctrl.AddRoot(translate_key(root_key))
for item, value in self.categories.iteritems():
item_key = MODULE_KEY.join(['settings', item])
item_data = wx.TreeItemData()
item_data.SetData(item_key)
item_node = tree_ctrl.AppendItem(root_node,
translate_key(item_key),
data=item_data)
for f_item, f_value in value.iteritems():
if not f_item == item:
f_item_key = MODULE_KEY.join([item_key, f_item])
f_item_data = wx.TreeItemData()
f_item_data.SetData(f_item_key)
tree_ctrl.AppendItem(item_node,
translate_key(f_item),
data=f_item_data)
tree_ctrl.ExpandAll()
self.tree_ctrl = tree_ctrl
self.Bind(wx.EVT_TREE_SEL_CHANGED,
self.tree_ctrl_changed,
id=tree_ctrl_id)
self.main_grid.Add(self.tree_ctrl, 0, wx.EXPAND | wx.ALL, 7)
content_page_id = id_renew(MODULE_KEY.join(['settings', 'content']))
self.content_page = wx.Panel(self, id=content_page_id)
self.main_grid.Add(self.content_page, 1, wx.EXPAND)
self.main_grid.Layout()
self.SetSizer(self.main_grid)
tree_ctrl.SelectItem(tree_ctrl.GetFirstChild(root_node)[0])
def OnUp(self, event): # pylint: disable=W0613
selection = self._GetSelection()
prev = self._templateList.GetPrevSibling(selection)
prev = self._templateList.GetPrevSibling(prev)
task = self._templateList.GetItemData(selection).GetData()
self._templateList.Delete(selection)
if prev.IsOk():
item = self._templateList.InsertItem(self._root,
prev,
task.subject(),
data=wx.TreeItemData(task))
else:
item = self._templateList.PrependItem(self._root,
task.subject(),
data=wx.TreeItemData(task))
for child in task.children():
self.appendTemplate(item, child)
index = self._templates.tasks().index(task)
self._templates.swapTemplates(index - 1, index)
self._templateList.SelectItem(item)
def build_tree(self, parent, obj):
if DEBUG: print "building", obj.__class__.__name__
child = self.tree.AppendItem(parent, obj.name)
self.tree.SetItemText(child, obj.__class__.__name__, 1)
if obj._meta.name in self.images_map:
self.tree.SetItemImage(child, self.images_map[obj._meta.name])
self.tree.SetItemData(child, wx.TreeItemData(obj))
#self.tree.SetItemImage(child, fldropenidx, which = wx.TreeItemIcon_Expanded)
for ctrl in obj:
self.build_tree(child, ctrl)
self.tree.Expand(child)
def voi_added(self, msg):
voi = msg.data
data = wx.TreeItemData()
data.SetData(voi)
item = self.AppendItem(self.structure_node, voi.get_name(), data=data)
img = self.image_list.Add(
pytripgui.guihelper.get_empty_bitmap(self.icon_size[0],
self.icon_size[1],
voi.get_color()))
voi.set_icon(img)
self.SetItemImage(item, img, wx.TreeItemIcon_Normal)
def plan_voi_added(self, msg):
plan = msg.data["plan"]
voi = msg.data["voi"]
node = self.get_child_from_data(self.plans_node, plan)
item = self.get_or_create_child(node, "Structures", plan.get_vois())
data = wx.TreeItemData()
data.SetData(voi)
i2 = self.AppendItem(item, voi.get_name(), data=data)
self.SetItemImage(i2, voi.get_voi().get_icon(), wx.TreeItemIcon_Normal)
self.Expand(item)
self.Expand(self.GetItemParent(item))
def addNode(self, parentNode, forum, objID, type):
msgs, new = self.getMsgsNumber(objID, forum)
spec = gdata.mailboxSpec[type, forum]
text = "%s (%d / %d)" % (_(spec[0]), new, msgs)
dataObj = wx.TreeItemData((forum, objID, type))
item = self.tree.AppendItem(parentNode, text, data=dataObj)
self.tree.SetItemBold(item, new > 0)
if self.selected != None and self.selected[
0] == forum and self.selected[1] == objID:
self.selectedItem = item
return item
def _populateTree(self):
dataNode = self.contentProvider.getRootNode()
(nodeText, nodeImgIdx, nodeSelImgIdx,
nodeBoldFlag) = self._getTreeItemParams(dataNode)
treeItemId = self.AddRoot(nodeText, nodeImgIdx, nodeSelImgIdx,
wx.TreeItemData(dataNode))
if nodeBoldFlag:
self.SetItemBold(treeItemId, True)
self._populateChildren(dataNode, treeItemId)
self.hasData = True
def CreateRoot(self, node):
itemId = self.AddRoot(
node.GetLabel(),
node.imageIndex,
-1,
wx.TreeItemData(node)
)
self.visibleNodes[node] = itemId
self.SetItemHasChildren(itemId, True)
self.Expand(itemId)
return itemId
def addContext(self, context):
root = self.tree.GetRootItem()
image = self.imageIndices[
LCONTEXT] if context == pvscomm.PVSCommandManager(
).pvsContext else self.imageIndices[LINACTIVECONTEXT]
self.tree.AppendItem(
root, context, image, -1,
wx.TreeItemData({
LCONTEXT: context,
KIND: LCONTEXT
}))
def __init__(self, parent, id, root):
wx.TreeCtrl.__init__(self, parent, id)
self.root = self.AddRoot(root.getname(), -1, -1, wx.TreeItemData(root))
if root.gethead() != None:
self.SetItemHasChildren(self.root, True)
self.Bind(wx.EVT_TREE_ITEM_EXPANDING, self.OnItemExpanding, self)
self.Bind(wx.EVT_TREE_ITEM_COLLAPSED, self.OnItemCollapsed, self)
self.Bind(wx.EVT_TREE_SEL_CHANGED, self.OnSelChanged, self)
self.output = None
self.SelectionChangedCallback = None
def __init__(self, parent, filepath, **kwargs):
super(AbinitEventsPanel, self).__init__(parent, -1, **kwargs)
self.filepath = os.path.abspath(filepath)
parser = EventsParser()
self.events = events = parser.parse(self.filepath)
main_sizer = wx.BoxSizer(wx.VERTICAL)
vbox = wx.BoxSizer(wx.VERTICAL)
panel1 = awx.Panel(self, -1)
panel2 = awx.Panel(self, -1)
self.tree = tree = wx.TreeCtrl(panel1, 1, wx.DefaultPosition, (-1, -1), wx.TR_HIDE_ROOT | wx.TR_HAS_BUTTONS)
root = self.tree.AddRoot('Events')
err_tree = tree.AppendItem(root, "%d Errors" % events.num_errors)
warn_tree = tree.AppendItem(root, "%d Warnings" % events.num_warnings)
com_tree = tree.AppendItem(root, "%d Comments" % events.num_comments)
for e in self.events.errors:
tree.AppendItem(err_tree, "line: " + str(e.lineno), data=wx.TreeItemData(e.message))
for w in self.events.warnings:
tree.AppendItem(warn_tree, "line: " + str(w.lineno), data=wx.TreeItemData(w.message))
for c in self.events.comments:
tree.AppendItem(com_tree, "line: " + str(c.lineno), data=wx.TreeItemData(c.message))
tree.Bind(wx.EVT_TREE_SEL_CHANGED, self.OnSelChanged, id=1)
self.display = wx.StaticText(panel2, -1, '', (10, 10), style=wx.ALIGN_LEFT)
vbox.Add(self.tree, 1, wx.EXPAND)
main_sizer.Add(panel1, 1, wx.EXPAND)
main_sizer.Add(panel2, 1, wx.EXPAND)
panel1.SetSizerAndFit(vbox)
self.SetSizerAndFit(main_sizer)
self.Centre()
def BuildTree(self, elementList, fExpand, fSort):
root = self.GetRootItem()
for e in elementList:
if e.level == 1:
parent = self.AppendItem(root,
e.label,
data=wx.TreeItemData(e))
self.AddAsciiChildren(elementList, e, parent, fExpand, fSort)
fSort(parent)
fExpand(parent)
fSort(root)
fExpand(root)
def OnTreeItemExpanding(evt):
treeItem = evt.GetItem()
treeItemData = treeCtrl.GetPyData(treeItem)
children = treeItemData.GetChildren()
for childName, childData in children:
data = PyData(childName, childData)
child = treeCtrl.AppendItem(treeItem,
childName,
data=wx.TreeItemData(data))
if data.HasChildren():
treeCtrl.SetItemHasChildren(child, True)
evt.Skip()
def _build_tree(branches, branch):
"""Build the variable tree.
"""
for key in branches.keys():
data = wx.TreeItemData()
if isinstance(branches[key], string_types):
data.SetData(branches[key])
subbranch = self.tree.AppendItem(branch, key, data=data)
else:
data.SetData('')
subbranch = self.tree.AppendItem(branch, key, data=data)
_build_tree(branches[key], subbranch) # Recursion
def appendDirTreeItem(self, parentItem, name, data):
itemData = wx.TreeItemData(data)
if parentItem is not None:
newItemId = self.snippetsTree.AppendItem(parentItem,
name,
self._dirImageId,
data=itemData)
else:
newItemId = self.snippetsTree.AddRoot(name,
self._dirImageId,
data=itemData)
return newItemId
def add(self, Model):
modelEntity = Entity()
object = TransformObject()
modelEntity.Transform.append(object)
object.node = "RootNode"
object.name = "RootNode"
Model.node = object.name
modelEntity.Graphic.append(Model)
self.AppendItem(self.GetRootItem(),
Model.name,
data=wx.TreeItemData(obj=modelEntity))
def add_model(self, PODModel_tuple):
"""Adds the model PODModel to the tree"""
PODModel_name = PODModel_tuple[0]
PODModel = PODModel_tuple[1]()
module_logger.info("Adding POD Model {0} {1} to tree.".format(PODModel_name, PODModel))
PODModel.configure()
newmodel_branch = self.AppendItem(self.root, PODModel_name, data=wx.TreeItemData(PODModel))
newinputdata_branch = self.AppendItem(newmodel_branch, self.inputdata_lbl)
for inputdataname, inputdata in sorted(PODModel.inputdata.iteritems()):
self.AppendItem(newinputdata_branch, text=inputdataname,
data=wx.TreeItemData(inputdata))
newparameter_branch = self.AppendItem(newmodel_branch, self.parameters_lbl)
for parametername, parameter in sorted(PODModel.params.iteritems()):
self.AppendItem(newparameter_branch, text=parametername,
data=wx.TreeItemData(parameter))
newsetting_branch = self.AppendItem(newmodel_branch, self.settings_lbl)
for settingname, setting in sorted(PODModel.settings.iteritems()):
self.AppendItem(newsetting_branch, text=settingname,
data=wx.TreeItemData(setting))
self.ExpandAllChildren(newmodel_branch)
return newmodel_branch
def __init__(self, parent, session):
super(NavigationPanel, self).__init__(parent)
#enable the scroll bars on the scrolled window
self.SetScrollRate(2, 2)
self._rclick_menu = RightClickMenu(self)
self.v_sizer = wx.BoxSizer(wx.VERTICAL)
#note that we need a try except block for agwStyle because it
#changed names between wx versions from style to agwstyle
try:
self.tree = customtreectrl.CustomTreeCtrl(
self,
wx.ID_ANY,
agwStyle=(customtreectrl.TR_HIDE_ROOT
| customtreectrl.TR_HAS_BUTTONS))
except:
self.tree = customtreectrl.CustomTreeCtrl(
self,
wx.ID_ANY,
style=(customtreectrl.TR_HIDE_ROOT
| customtreectrl.TR_HAS_BUTTONS))
#disable the scroll bars which come with the tree control (otherwise
#you end up with two sets sometimes!)
self.tree.EnableScrolling(False, False)
self.SetScrollbars(0, 0, 0, 0)
self.v_sizer.Add(self.tree, 1, wx.EXPAND)
self.__current_selection_id = None
#add the session element as the root node
root = self.tree.AddRoot(session.get_name(),
data=wx.TreeItemData(session))
self.__el_id_mapping = {session.get_avoplot_id(): root}
#bind avoplot events
core.EVT_AVOPLOT_ELEM_SELECT(self, self.on_element_select)
core.EVT_AVOPLOT_ELEM_DELETE(self, self.on_element_delete)
core.EVT_AVOPLOT_ELEM_ADD(self, self.on_element_add)
core.EVT_AVOPLOT_ELEM_RENAME(self, self.on_element_rename)
#bind wx events
wx.EVT_TREE_SEL_CHANGED(self, self.tree.GetId(),
self.on_tree_select_el)
wx.EVT_TREE_ITEM_MENU(self, self.tree.GetId(), self.on_tree_el_menu)
#do the layout
self.SetSizer(self.v_sizer)
self.v_sizer.Fit(self)
self.SetAutoLayout(True)
def __init__(self, *args, **kwargs):
super(BrushTreeCtrl, self).__init__(*args, **kwargs)
self.boss = core.Boss("Boss")
self.bossItem = self.AddRoot(unicode(self.boss),
data=wx.TreeItemData(self.boss))
self.boss.item = self.bossItem
for phoneManager in self.boss.phoneManagers.values():
pmItem = self.AppendItem(self.bossItem,
unicode(phoneManager),
data=wx.TreeItemData(phoneManager))
phoneManager.item = pmItem
for phone in phoneManager.phones.values():
phoneItem = self.AppendItem(pmItem,
unicode(phone),
data=wx.TreeItemData(phone))
phone.item = phoneItem
for app in phone.apps:
appItem = self.AppendItem(phoneItem,
unicode(app),
data=wx.TreeItemData(app))
app.item = appItem
def CreateToolbox(self):
tree = wx.TreeCtrl(self, -1, wx.Point(0,0), wx.Size(150,250), wx.TR_DEFAULT_STYLE | wx.NO_BORDER | wx.TR_HIDE_ROOT)
root = tree.AddRoot("Blocks")
blockSource = BlockSource(Config.systemBlockPath)
for root_name in blockSource.get_roots():
root_id = tree.AppendItem(root, root_name, data=None)
for block in blockSource.get_blocks(root_name):
child_id = tree.AppendItem(root_id, block['name'], data=wx.TreeItemData(block))
tree.SetItemPyData(child_id, block)
tree.Expand(root_id)
return tree
def expand_sublists(self, item):
if self.IsExpanded(item):
# This event can happen twice in the self.Expand call
return
obj = self.GetPyData(item)
node = obj.gethead()
fileserver = servers.get_file_server()
self.libidx = self.image_list.Add(
wx.Bitmap(fileserver.manglepath("outgui:images/tools/new.bmp"),
wx.BITMAP_TYPE_ANY))
while node != None:
obj = pynebula.lookup(node.getfullname())
new_item = self.AppendItem(item, obj.getname(), -1, -1,
wx.TreeItemData(obj))
if self.is_library(new_item):
self.SetItemImage(new_item, self.libidx,
wx.TreeItemIcon_Normal)
self.SetItemImage(new_item, self.libidx,
wx.TreeItemIcon_Selected)
self.SetItemImage(new_item, self.libidx,
wx.TreeItemIcon_Expanded)
elif self.GetItemText(
self.get_root_library(new_item)
) == 'natives' and servers.get_kernel_server().isclassnative(
str(self.GetItemText(new_item))):
self.SetItemImage(new_item, self.fldridxnative,
wx.TreeItemIcon_Normal)
self.SetItemImage(new_item, self.fldropenidxnative,
wx.TreeItemIcon_Selected)
self.SetItemImage(new_item, self.fldropenidxnative,
wx.TreeItemIcon_Expanded)
elif self.GetItemText(
self.get_root_library(new_item)
) == 'natives' and not servers.get_kernel_server().isclassnative(
str(self.GetItemText(new_item))):
self.SetItemImage(new_item, self.fldridxuser,
wx.TreeItemIcon_Normal)
self.SetItemImage(new_item, self.fldropenidxuser,
wx.TreeItemIcon_Selected)
self.SetItemImage(new_item, self.fldropenidxuser,
wx.TreeItemIcon_Expanded)
else:
self.SetItemImage(new_item, self.fldridxnormal,
wx.TreeItemIcon_Normal)
self.SetItemImage(new_item, self.fldropenidxnormal,
wx.TreeItemIcon_Selected)
self.SetItemImage(new_item, self.fldropenidxnormal,
wx.TreeItemIcon_Expanded)
if obj.gethead() != None:
self.SetItemHasChildren(new_item, True)
node = obj.getsucc()
self.SortChildren(item)
def __init__(self, fs, hide_dotfiles=False):
wx.Frame.__init__(self, None, size=(1000, 600))
self.fs = fs
self.hide_dotfiles = hide_dotfiles
self.SetTitle("FS Browser - " + str(fs))
self.tree = wx.gizmos.TreeListCtrl(self,
-1,
style=wx.TR_DEFAULT_STYLE
| wx.TR_HIDE_ROOT)
self.tree.AddColumn("File System")
self.tree.AddColumn("Description")
self.tree.AddColumn("Size")
self.tree.AddColumn("Created")
self.tree.SetColumnWidth(0, 300)
self.tree.SetColumnWidth(1, 250)
self.tree.SetColumnWidth(2, 150)
self.tree.SetColumnWidth(3, 250)
self.root_id = self.tree.AddRoot('root',
data=wx.TreeItemData({
'path': "/",
'expanded': False
}))
rid = self.tree.GetItemData(self.root_id)
isz = (16, 16)
il = wx.ImageList(isz[0], isz[1])
self.fldridx = il.Add(
wx.ArtProvider_GetBitmap(wx.ART_FOLDER, wx.ART_OTHER, isz))
self.fldropenidx = il.Add(
wx.ArtProvider_GetBitmap(wx.ART_FILE_OPEN, wx.ART_OTHER, isz))
self.fileidx = il.Add(
wx.ArtProvider_GetBitmap(wx.ART_NORMAL_FILE, wx.ART_OTHER, isz))
self.tree.SetImageList(il)
self.il = il
self.tree.SetItemImage(self.root_id, self.fldridx,
wx.TreeItemIcon_Normal)
self.tree.SetItemImage(self.root_id, self.fldropenidx,
wx.TreeItemIcon_Expanded)
self.Bind(wx.EVT_TREE_ITEM_EXPANDING, self.OnItemExpanding)
self.Bind(wx.EVT_TREE_ITEM_ACTIVATED, self.OnItemActivated)
wx.CallAfter(self.OnInit)
