'''
Tree View
=========
.. image:: images/treeview.png
:align: right
.. versionadded:: 1.0.4
:class:`TreeView` is a widget used to represent a tree structure. It is
currently very basic, supporting a minimal feature set.
Introduction
------------
A :class:`TreeView` is populated with :class:`TreeViewNode` instances, but you
cannot use a :class:`TreeViewNode` directly. You must combine it with another
widget, such as :class:`~kivy.uix.label.Label`,
:class:`~kivy.uix.button.Button` or even your own widget. The TreeView
always creates a default root node, based on :class:`TreeViewLabel`.
:class:`TreeViewNode` is a class object containing needed properties for
serving as a tree node. Extend :class:`TreeViewNode` to create custom node
types for use with a :class:`TreeView`.
For constructing your own subclass, follow the pattern of TreeViewLabel which
combines a Label and a TreeViewNode, producing a :class:`TreeViewLabel` for
direct use in a TreeView instance.
To use the TreeViewLabel class, you could create two nodes directly attached
to root::
tv = TreeView()
tv.add_node(TreeViewLabel(text='My first item'))
tv.add_node(TreeViewLabel(text='My second item'))
Or, create two nodes attached to a first::
tv = TreeView()
n1 = tv.add_node(TreeViewLabel(text='Item 1'))
tv.add_node(TreeViewLabel(text='SubItem 1'), n1)
tv.add_node(TreeViewLabel(text='SubItem 2'), n1)
If you have a large tree structure, perhaps you would need a utility function
to populate the tree view::
def populate_tree_view(tree_view, parent, node):
if parent is None:
tree_node = tree_view.add_node(TreeViewLabel(text=node['node_id'],
is_open=True))
else:
tree_node = tree_view.add_node(TreeViewLabel(text=node['node_id'],
is_open=True), parent)
for child_node in node['children']:
populate_tree_view(tree_view, tree_node, child_node)
tree = {'node_id': '1',
'children': [{'node_id': '1.1',
'children': [{'node_id': '1.1.1',
'children': [{'node_id': '1.1.1.1',
'children': []}]},
{'node_id': '1.1.2',
'children': []},
{'node_id': '1.1.3',
'children': []}]},
{'node_id': '1.2',
'children': []}]}
class TreeWidget(FloatLayout):
def __init__(self, **kwargs):
super(TreeWidget, self).__init__(**kwargs)
tv = TreeView(root_options=dict(text='Tree One'),
hide_root=False,
indent_level=4)
populate_tree_view(tv, None, tree)
self.add_widget(tv)
The root widget in the tree view is opened by default and has text set as
'Root'. If you want to change that, you can use the
:attr:`TreeView.root_options`
property. This will pass options to the root widget::
tv = TreeView(root_options=dict(text='My root label'))
Creating Your Own Node Widget
-----------------------------
For a button node type, combine a :class:`~kivy.uix.button.Button` and a
:class:`TreeViewNode` as follows::
class TreeViewButton(Button, TreeViewNode):
pass
You must know that, for a given node, only the
:attr:`~kivy.uix.widget.Widget.size_hint_x` will be honored. The allocated
width for the node will depend of the current width of the TreeView and the
level of the node. For example, if a node is at level 4, the width
allocated will be:
treeview.width - treeview.indent_start - treeview.indent_level * node.level
You might have some trouble with that. It is the developer's responsibility to
correctly handle adapting the graphical representation nodes, if needed.
'''
from kivy.clock import Clock
from kivy.uix.label import Label
from kivy.uix.widget import Widget
from kivy.properties import BooleanProperty, ListProperty, ObjectProperty, \
AliasProperty, NumericProperty, ReferenceListProperty
[docs]class TreeViewException(Exception):
'''Exception for errors in the :class:`TreeView`.
'''
pass
[docs]class TreeViewNode(object):
'''TreeViewNode class, used to build a node class for a TreeView object.
'''
def __init__(self, **kwargs):
if self.__class__ is TreeViewNode:
raise TreeViewException('You cannot use directly TreeViewNode.')
super(TreeViewNode, self).__init__(**kwargs)
is_leaf = BooleanProperty(True)
'''Boolean to indicate whether this node is a leaf or not. Used to adjust
the graphical representation.
:attr:`is_leaf` is a :class:`~kivy.properties.BooleanProperty` and defaults
to True. It is automatically set to False when child is added.
'''
is_open = BooleanProperty(False)
'''Boolean to indicate whether this node is opened or not, in case there
are child nodes. This is used to adjust the graphical representation.
.. warning::
This property is automatically set by the :class:`TreeView`. You can
read but not write it.
:attr:`is_open` is a :class:`~kivy.properties.BooleanProperty` and defaults
to False.
'''
is_loaded = BooleanProperty(False)
'''Boolean to indicate whether this node is already loaded or not. This
property is used only if the :class:`TreeView` uses asynchronous loading.
:attr:`is_loaded` is a :class:`~kivy.properties.BooleanProperty` and
defaults to False.
'''
is_selected = BooleanProperty(False)
'''Boolean to indicate whether this node is selected or not. This is used
adjust the graphical representation.
.. warning::
This property is automatically set by the :class:`TreeView`. You can
read but not write it.
:attr:`is_selected` is a :class:`~kivy.properties.BooleanProperty` and
defaults to False.
'''
no_selection = BooleanProperty(False)
'''Boolean used to indicate whether selection of the node is allowed or
not.
:attr:`no_selection` is a :class:`~kivy.properties.BooleanProperty` and
defaults to False.
'''
nodes = ListProperty([])
'''List of nodes. The nodes list is different than the children list. A
node in the nodes list represents a node on the tree. An item in the
children list represents the widget associated with the node.
.. warning::
This property is automatically set by the :class:`TreeView`. You can
read but not write it.
:attr:`nodes` is a :class:`~kivy.properties.ListProperty` and defaults to
[].
'''
parent_node = ObjectProperty(None, allownone=True)
'''Parent node. This attribute is needed because the :attr:`parent` can be
None when the node is not displayed.
.. versionadded:: 1.0.7
:attr:`parent_node` is an :class:`~kivy.properties.ObjectProperty` and
defaults to None.
'''
level = NumericProperty(-1)
'''Level of the node.
:attr:`level` is a :class:`~kivy.properties.NumericProperty` and defaults
to -1.
'''
color_selected = ListProperty([.3, .3, .3, 1.])
'''Background color of the node when the node is selected.
:attr:`color_selected` is a :class:`~kivy.properties.ListProperty` and
defaults to [.1, .1, .1, 1].
'''
odd = BooleanProperty(False)
'''
This property is set by the TreeView widget automatically and is read-only.
:attr:`odd` is a :class:`~kivy.properties.BooleanProperty` and defaults to
False.
'''
odd_color = ListProperty([1., 1., 1., .0])
'''Background color of odd nodes when the node is not selected.
:attr:`odd_color` is a :class:`~kivy.properties.ListProperty` and defaults
to [1., 1., 1., 0.].
'''
even_color = ListProperty([0.5, 0.5, 0.5, 0.1])
'''Background color of even nodes when the node is not selected.
:attr:`bg_color` is a :class:`~kivy.properties.ListProperty` ans defaults
to [.5, .5, .5, .1].
'''
[docs]class TreeViewLabel(Label, TreeViewNode):
'''Combines a :class:`~kivy.uix.label.Label` and a :class:`TreeViewNode` to
create a :class:`TreeViewLabel` that can be used as a text node in the
tree.
See module documentation for more information.
'''
[docs]class TreeView(Widget):
'''TreeView class. See module documentation for more information.
:Events:
`on_node_expand`: (node, )
Fired when a node is being expanded
`on_node_collapse`: (node, )
Fired when a node is being collapsed
'''
__events__ = ('on_node_expand', 'on_node_collapse')
def __init__(self, **kwargs):
self._trigger_layout = Clock.create_trigger(self._do_layout, -1)
super(TreeView, self).__init__(**kwargs)
tvlabel = TreeViewLabel(text='Root', is_open=True, level=0)
for key, value in self.root_options.items():
setattr(tvlabel, key, value)
self._root = self.add_node(tvlabel, None)
trigger = self._trigger_layout
fbind = self.fbind
fbind('pos', trigger)
fbind('size', trigger)
fbind('indent_level', trigger)
fbind('indent_start', trigger)
trigger()
[docs] def add_node(self, node, parent=None):
'''Add a new node to the tree.
:Parameters:
`node`: instance of a :class:`TreeViewNode`
Node to add into the tree
`parent`: instance of a :class:`TreeViewNode`, defaults to None
Parent node to attach the new node. If `None`, it is added to
the :attr:`root` node.
:returns:
the node `node`.
'''
# check if the widget is "ok" for a node
if not isinstance(node, TreeViewNode):
raise TreeViewException(
'The node must be a subclass of TreeViewNode')
# create node
if parent is None and self._root:
parent = self._root
if parent:
parent.is_leaf = False
parent.nodes.append(node)
node.parent_node = parent
node.level = parent.level + 1
node.fbind('size', self._trigger_layout)
self._trigger_layout()
return node
[docs] def remove_node(self, node):
'''Removes a node from the tree.
.. versionadded:: 1.0.7
:Parameters:
`node`: instance of a :class:`TreeViewNode`
Node to remove from the tree. If `node` is :attr:`root`, it is
not removed.
'''
# check if the widget is "ok" for a node
if not isinstance(node, TreeViewNode):
raise TreeViewException(
'The node must be a subclass of TreeViewNode')
parent = node.parent_node
if parent is not None:
if node == self._selected_node:
node.is_selected = False
self._selected_node = None
nodes = parent.nodes
if node in nodes:
nodes.remove(node)
parent.is_leaf = not bool(len(nodes))
node.parent_node = None
node.funbind('size', self._trigger_layout)
self._trigger_layout()
def on_node_expand(self, node):
pass
def on_node_collapse(self, node):
pass
[docs] def select_node(self, node):
'''Select a node in the tree.
'''
if node.no_selection:
return
if self._selected_node:
self._selected_node.is_selected = False
node.is_selected = True
self._selected_node = node
[docs] def deselect_node(self, *args):
'''Deselect any selected node.
.. versionadded:: 1.10.0
'''
if self._selected_node:
self._selected_node.is_selected = False
self._selected_node = None
[docs] def toggle_node(self, node):
'''Toggle the state of the node (open/collapsed).
'''
node.is_open = not node.is_open
if node.is_open:
if self.load_func and not node.is_loaded:
self._do_node_load(node)
self.dispatch('on_node_expand', node)
else:
self.dispatch('on_node_collapse', node)
self._trigger_layout()
[docs] def get_node_at_pos(self, pos):
'''Get the node at the position (x, y).
'''
x, y = pos
for node in self.iterate_open_nodes(self.root):
if self.x <= x <= self.right and \
node.y <= y <= node.top:
return node
[docs] def iterate_open_nodes(self, node=None):
'''Generator to iterate over all the expended nodes starting from
`node` and down. If `node` is `None`, the generator start with
:attr:`root`.
To get all the open nodes::
treeview = TreeView()
# ... add nodes ...
for node in treeview.iterate_open_nodes():
print(node)
'''
if not node:
node = self.root
if self.hide_root and node is self.root:
pass
else:
yield node
if not node.is_open:
return
f = self.iterate_open_nodes
for cnode in node.nodes:
for ynode in f(cnode):
yield ynode
[docs] def iterate_all_nodes(self, node=None):
'''Generator to iterate over all nodes from `node` and down whether
expanded or not. If `node` is `None`, the generator start with
:attr:`root`.
'''
if not node:
node = self.root
yield node
f = self.iterate_all_nodes
for cnode in node.nodes:
for ynode in f(cnode):
yield ynode
#
# Private
#
def on_load_func(self, instance, value):
if value:
Clock.schedule_once(self._do_initial_load)
def _do_initial_load(self, *largs):
if not self.load_func:
return
self._do_node_load(None)
def _do_node_load(self, node):
gen = self.load_func(self, node)
if node:
node.is_loaded = True
if not gen:
return
for cnode in gen:
self.add_node(cnode, node)
def on_root_options(self, instance, value):
if not self.root:
return
for key, value in value.items():
setattr(self.root, key, value)
def _do_layout(self, *largs):
self.clear_widgets()
# display only the one who are is_open
self._do_open_node(self.root)
# now do layout
self._do_layout_node(self.root, 0, self.top)
# now iterate for calculating minimum size
min_width = min_height = 0
for count, node in enumerate(self.iterate_open_nodes(self.root)):
node.odd = False if count % 2 else True
min_width = max(min_width, node.right - self.x)
min_height += node.height
self.minimum_size = (min_width, min_height)
def _do_open_node(self, node):
if self.hide_root and node is self.root:
height = 0
else:
self.add_widget(node)
height = node.height
if not node.is_open:
return height
for cnode in node.nodes:
height += self._do_open_node(cnode)
return height
def _do_layout_node(self, node, level, y):
if self.hide_root and node is self.root:
level -= 1
else:
node.x = self.x + self.indent_start + level * self.indent_level
node.top = y
if node.size_hint_x:
node.width = (self.width - (node.x - self.x)) \
* node.size_hint_x
y -= node.height
if not node.is_open:
return y
for cnode in node.nodes:
y = self._do_layout_node(cnode, level + 1, y)
return y
[docs] def on_touch_down(self, touch):
node = self.get_node_at_pos(touch.pos)
if not node:
return
if node.disabled:
return
# toggle node or selection ?
if node.x - self.indent_start <= touch.x < node.x:
self.toggle_node(node)
elif node.x <= touch.x:
self.select_node(node)
node.dispatch('on_touch_down', touch)
return True
#
# Private properties
#
_root = ObjectProperty(None)
_selected_node = ObjectProperty(None, allownone=True)
#
# Properties
#
minimum_width = NumericProperty(0)
'''Minimum width needed to contain all children.
.. versionadded:: 1.0.9
:attr:`minimum_width` is a :class:`~kivy.properties.NumericProperty` and
defaults to 0.
'''
minimum_height = NumericProperty(0)
'''Minimum height needed to contain all children.
.. versionadded:: 1.0.9
:attr:`minimum_height` is a :class:`~kivy.properties.NumericProperty` and
defaults to 0.
'''
minimum_size = ReferenceListProperty(minimum_width, minimum_height)
'''Minimum size needed to contain all children.
.. versionadded:: 1.0.9
:attr:`minimum_size` is a :class:`~kivy.properties.ReferenceListProperty`
of (:attr:`minimum_width`, :attr:`minimum_height`) properties.
'''
indent_level = NumericProperty('16dp')
'''Width used for the indentation of each level except the first level.
Computation of indent for each level of the tree is::
indent = indent_start + level * indent_level
:attr:`indent_level` is a :class:`~kivy.properties.NumericProperty` and
defaults to 16.
'''
indent_start = NumericProperty('24dp')
'''Indentation width of the level 0 / root node. This is mostly the initial
size to accommodate a tree icon (collapsed / expanded). See
:attr:`indent_level` for more information about the computation of level
indentation.
:attr:`indent_start` is a :class:`~kivy.properties.NumericProperty` and
defaults to 24.
'''
hide_root = BooleanProperty(False)
'''Use this property to show/hide the initial root node. If True, the root
node will be appear as a closed node.
:attr:`hide_root` is a :class:`~kivy.properties.BooleanProperty` and
defaults to False.
'''
def get_selected_node(self):
return self._selected_node
selected_node = AliasProperty(get_selected_node, None,
bind=('_selected_node', ))
'''Node selected by :meth:`TreeView.select_node` or by touch.
:attr:`selected_node` is a :class:`~kivy.properties.AliasProperty` and
defaults to None. It is read-only.
'''
def get_root(self):
return self._root
root = AliasProperty(get_root, None, bind=('_root', ))
'''Root node.
By default, the root node widget is a :class:`TreeViewLabel` with text
'Root'. If you want to change the default options passed to the widget
creation, use the :attr:`root_options` property::
treeview = TreeView(root_options={
'text': 'Root directory',
'font_size': 15})
:attr:`root_options` will change the properties of the
:class:`TreeViewLabel` instance. However, you cannot change the class used
for root node yet.
:attr:`root` is an :class:`~kivy.properties.AliasProperty` and defaults to
None. It is read-only. However, the content of the widget can be changed.
'''
root_options = ObjectProperty({})
'''Default root options to pass for root widget. See :attr:`root` property
for more information about the usage of root_options.
:attr:`root_options` is an :class:`~kivy.properties.ObjectProperty` and
defaults to {}.
'''
load_func = ObjectProperty(None)
'''Callback to use for asynchronous loading. If set, asynchronous loading
will be automatically done. The callback must act as a Python generator
function, using yield to send data back to the treeview.
The callback should be in the format::
def callback(treeview, node):
for name in ('Item 1', 'Item 2'):
yield TreeViewLabel(text=name)
:attr:`load_func` is a :class:`~kivy.properties.ObjectProperty` and
defaults to None.
'''
if __name__ == '__main__':
from kivy.app import App
class TestApp(App):
def build(self):
tv = TreeView(hide_root=True)
add = tv.add_node
root = add(TreeViewLabel(text='Level 1, entry 1', is_open=True))
for x in range(5):
add(TreeViewLabel(text='Element %d' % x), root)
root2 = add(TreeViewLabel(text='Level 1, entry 2', is_open=False))
for x in range(24):
add(TreeViewLabel(text='Element %d' % x), root2)
for x in range(5):
add(TreeViewLabel(text='Element %d' % x), root)
root2 = add(TreeViewLabel(text='Element childs 2', is_open=False),
root)
for x in range(24):
add(TreeViewLabel(text='Element %d' % x), root2)
return tv
TestApp().run()
