root/apps/languages/templatetags/get_languages.py @ 1

# -*- encoding: utf-8 -*-

try:
    from django.template import Library, Node, NodeList, Template
    from django.template.context import Context
    register = Library()
except:
    from django.core.template import Node, NodeList, Template, Context
    from django.core import template
    from django.core.template import Context
    register = template.Library()

try:
    from ambidjangolib.apps.languages.models import Language
except:
    from django.models import languages


class LanguagesNode(Node):
    def __init__(self, varname):
        self.varname = varname

    def render(self, context):
        try:
            context[self.varname] = Language.objects.all()
        except:
            context[self.varname] = languages.get_list()
        return ''

def do_get_languages(parser, token):
    """
    {% get_languages as languages %}
    """
    print "do_get_languages"
    bits = token.contents.split()
    if len(bits) != 3:
        raise TemplateSyntaxError, \
              "'%s' tag takes two arguments" % bits[0]
    if bits[1] != 'as':
        raise TemplateSyntaxError, \
              "First argument to '%s' tag must be 'as'" % bits[0]
    return LanguagesNode(bits[2])

register.tag('get_languages', do_get_languages)


def do_url_in_another_language(url, language_code):
    """
    url in another language documentation here

    url must be /<language_code>/<path>
    """
    current_language, path = url.split('/', 2)[1:]
    return '/%s/%s' % (language_code, path)

register.filter('url_in_another_language', do_url_in_another_language)




class ForLanguagesNode(Node):
    def __init__(self, omit_current, nodelist_loop):
        self.omit_current  = omit_current
        self.nodelist_loop = nodelist_loop

    def __repr__(self):
        if self.omit_current: omit_current = ', omit current'
        else                : omit_current = ''
        return "<ForLanguages Node, tail_len: %d%s>" % \
            (len(self.nodelist_loop), omit_current)

    def __iter__(self):
        for node in self.nodelist_loop: yield node

    def get_nodes_by_type(self, nodetype):
        nodes = []
        if isinstance(self, nodetype): nodes.append(self)
        nodes.extend(self.nodelist_loop.get_nodes_by_type(nodetype))
        return nodes

    def render(self, context):
        nodelist = NodeList()
        if context.has_key('forloop'): parentloop = context['forloop']
        else                         : parentloop = {}
        context.push()
        criteria = {}
        try:
            Language.objects
            if self.omit_current: criteria['code'] = context['LANGUAGE_CODE']
            values = Language.objects.exclude(**criteria)
        except:
            if self.omit_current: criteria['code__ne'] = context['LANGUAGE_CODE']
            values = languages.get_list(**criteria)
        len_values = len(values)
        for i, language in enumerate(values):
            context['forloop'] = {
                # shortcuts for current loop iteration number
                'counter0': i,
                'counter': i+1,
                # reverse counter iteration numbers
                'revcounter': len_values - i,
                'revcounter0': len_values - i - 1,
                # boolean values designating first and last times through loop
                'first': (i == 0),
                'last': (i == len_values - 1),
                'parentloop': parentloop,
                # language specifics
                'language': language,
                'url': '/i18n/setlang?language=%s&next=%s' % \
                (language.code,
                 do_url_in_another_language(context['request_path'],
                                            language.code)),
            }
            for node in self.nodelist_loop:
                nodelist.append(node.render(context))
        context.pop()
        return nodelist.render(context)

#@register.tag(name="forlanguages")
def do_for_languages(parser, token):
    """
    
    Loop over available languages.

    For example, to display a list of athletes given ``athlete_list``::

        <ul>
        {% forlanguages omit_current %}
            <li>{{ forloop.language.code }}</li>
        {% endforlanguages %}
        </ul>

    You can also loop over a list in reverse by using
    ``{% for obj in list reversed %}``.

    The for loop sets a number of variables available within the loop:

        ==========================  ================================================
        Variable                    Description
        ==========================  ================================================
        ``forloop.counter``         The current iteration of the loop (1-indexed)
        ``forloop.counter0``        The current iteration of the loop (0-indexed)
        ``forloop.revcounter``      The number of iterations from the end of the
                                    loop (1-indexed)
        ``forloop.revcounter0``     The number of iterations from the end of the
                                    loop (0-indexed)
        ``forloop.first``           True if this is the first time through the loop
        ``forloop.last``            True if this is the last time through the loop
        ``forloop.parentloop``      For nested loops, this is the loop "above" the
                                    current one
        ``forloop.language``        The current language in the loop
        ``forloop.url``             The current URL for the current language
        ==========================  ================================================

    """
    bits = token.contents.split()
    if len(bits) == 2 and bits[1] != 'omit_current':
        raise TemplateSyntaxError, "'for' statements with two words should end in 'omit_current': %s" % token.contents
    if len(bits) not in (1, 2):
        raise TemplateSyntaxError, "'for' statements should have either one or two words: %s" % token.contents
    omit_current = (len(bits) == 2)
    nodelist_loop = parser.parse(('endforlanguages',))
    parser.delete_first_token()
    return ForLanguagesNode(omit_current, nodelist_loop)
do_for_languages = register.tag("forlanguages", do_for_languages)