def node_n_children(self, node_id=None, recursive=False):
""" Return quantity of children of node_id.
If node_id is None, use the root node.
Every instance of node has the same children"""
if not self.__ft:
self.__ft = FilteredTree(self.__maintree,
self.__fbank,
refresh=True)
return self.__ft.node_n_children(node_id, recursive)
def setUp(self):
self.added_nodes = 0
self.deleted_nodes = 0
self.tree = MainTree()
self.filtersbank = FiltersBank(self.tree)
self.filtered_tree = FilteredTree(self.tree, self.filtersbank)
self.tree.add_node(_Node(node_id="apple"))
self.tree.add_node(_Node(node_id="google"))
self.filtered_tree.set_callback('deleted', self.deleted)
self.filtered_tree.set_callback('added', self.added)
def get_nodes(self, withfilters=[]):
""" Returns displayed nodes in this tree
@withfilters => Additional filters are applied before counting,
i.e. the currently applied filters are also taken into account
"""
if not self.__ft:
self.__ft = FilteredTree(self.__maintree,
self.__fbank,
refresh=True)
return self.__ft.get_nodes(withfilters=withfilters)
def __init__(self,
maininterface,
maintree,
filters_bank,
name=None,
refresh=True,
static=False):
"""
A ViewTree is the interface that should be used to display Tree(s).
In static mode, FilteredTree layer is not created. (There is no need)
We connect to MainTree or FilteredTree to get informed about changes.
If FilteredTree is used, it is connected to MainTree to handle changes
and then send id to ViewTree if it applies.
:maintree: a Tree object, cointaining all the nodes
:filters_bank: a FiltersBank object. Filters can be added dynamically
to that.
:refresh: if True, this ViewTree is automatically refreshed after
applying a filter.
:static: if True, this is the view of the complete maintree.
Filters cannot be added to such a view.
"""
self.maininterface = maininterface
self.__maintree = maintree
self.__cllbcks = {}
self.__fbank = filters_bank
self.static = static
if self.static:
self._tree = self.__maintree
self.__ft = None
self.__maintree.register_callback('node-added', \
functools.partial(self.__emit, 'node-added'))
self.__maintree.register_callback('node-deleted', \
functools.partial(self.__emit, 'node-deleted'))
self.__maintree.register_callback('node-modified', \
functools.partial(self.__emit, 'node-modified'))
else:
self.__ft = FilteredTree(maintree,
filters_bank,
name=name,
refresh=refresh)
self._tree = self.__ft
self.__ft.set_callback('added', \
functools.partial(self.__emit, 'node-added-inview'))
self.__ft.set_callback('deleted', \
functools.partial(self.__emit, 'node-deleted-inview'))
self.__ft.set_callback('modified', \
functools.partial(self.__emit, 'node-modified-inview'))
self.__ft.set_callback('reordered', \
functools.partial(self.__emit, 'node-children-reordered'))
def get_n_nodes(self, withfilters=[], include_transparent=True):
""" Returns quantity of displayed nodes in this tree
@withfilters => Additional filters are applied before counting,
i.e. the currently applied filters are also taken into account
@inclde_transparent => if it is False, filters which don't have
the transparent parameters are skipped, not takend into account
"""
if not self.__ft:
self.__ft = FilteredTree(self.__maintree,
self.__fbank,
refresh=True)
return self.__ft.get_n_nodes(withfilters=withfilters,\
include_transparent=include_transparent)
