X-Git-Url: http://git.ithinksw.org/philo.git/blobdiff_plain/26c548c5fe8c7cc7227b5f38cd27e0278442dd76..2b21f17548ca9c2b1be8c3047ad86370c95fcb9e:/contrib/shipherd/templatetags/shipherd.py diff --git a/contrib/shipherd/templatetags/shipherd.py b/contrib/shipherd/templatetags/shipherd.py index 019d240..af7f05f 100644 --- a/contrib/shipherd/templatetags/shipherd.py +++ b/contrib/shipherd/templatetags/shipherd.py @@ -3,29 +3,72 @@ from django.conf import settings from django.utils.safestring import mark_safe from philo.contrib.shipherd.models import Navigation from philo.models import Node -from mptt.templatetags.mptt_tags import RecurseTreeNode, cache_tree_children +from django.utils.translation import ugettext as _ register = template.Library() -class RecurseNavigationNode(RecurseTreeNode): - def __init__(self, template_nodes, instance_var): +class RecurseNavigationMarker(object): + pass + + +class RecurseNavigationNode(template.Node): + def __init__(self, template_nodes, instance_var, key): self.template_nodes = template_nodes self.instance_var = instance_var + self.key = key - def _render_node(self, context, node, request): - bits = [] + def _render_items(self, items, context, request): + if not items: + return '' + + if 'navloop' in context: + parentloop = context['navloop'] + else: + parentloop = {} context.push() - for child in node.get_children(): - context['navigation'] = child - bits.append(self._render_node(context, child, request)) - context['navigation'] = node - context['children'] = mark_safe(u''.join(bits)) - context['active'] = node.is_active(request) - rendered = self.template_nodes.render(context) + + depth = items[0].get_level() + len_items = len(items) + + loop_dict = context['navloop'] = { + 'parentloop': parentloop, + 'depth': depth + 1, + 'depth0': depth + } + + bits = [] + + for i, item in enumerate(items): + # First set context variables. + loop_dict['counter0'] = i + loop_dict['counter'] = i + 1 + loop_dict['revcounter'] = len_items - i + loop_dict['revcounter0'] = len_items - i - 1 + loop_dict['first'] = (i == 0) + loop_dict['last'] = (i == len_items - 1) + + # Set on loop_dict and context for backwards-compatibility. + # Eventually only allow access through the loop_dict. + loop_dict['item'] = context['item'] = item + loop_dict['active'] = context['active'] = item.is_active(request) + loop_dict['active_descendants'] = context['active_descendants'] = item.has_active_descendants(request) + + # Then render the nodelist bit by bit. + for node in self.template_nodes: + if isinstance(node, RecurseNavigationMarker): + # Then recurse! + children = items.get_children() + bits.append(self._render_items(children, context, request)) + elif isinstance(node, template.VariableNode) and node.filter_expression.var.lookups == (u'children',): + # Then recurse! This is here for backwards-compatibility only. + children = items.get_children() + bits.append(self._render_items(children, context, request)) + else: + bits.append(node.render(context)) context.pop() - return rendered + return ''.join(bits) def render(self, context): try: @@ -35,35 +78,33 @@ class RecurseNavigationNode(RecurseTreeNode): instance = self.instance_var.resolve(context) - if isinstance(instance, Node): - qs = Navigation.objects.closest_navigation(instance) - elif hasattr(instance, '__iter__'): - # Is this the right way to check? - qs = instance - else: + try: + items = instance.navigation[self.key] + except: return settings.TEMPLATE_STRING_IF_INVALID - roots = cache_tree_children(qs) - bits = [self._render_node(context, node, request) for node in roots] - return ''.join(bits) + return self._render_items(items, context, request) @register.tag def recursenavigation(parser, token): """ - Based on django-mptt's recursetree templatetag. In addition to {{ navigation }} and {{ children }}, - sets {{ active }} in the context. + Based on django-mptt's recursetree templatetag. In addition to {{ item }} and {{ children }}, + sets {{ active }}, {{ active_descendants }}, {{ navloop.counter }}, {{ navloop.counter0 }}, + {{ navloop.revcounter }}, {{ navloop.revcounter0 }}, {{ navloop.first }}, {{ navloop.last }}, + and {{ navloop.parentloop }} in the context. - Note that the tag takes one variable, which is a Node instance. + Note that the tag takes two variables: a Node instance and the key of the navigation to + be recursed. Usage: