def render_publicationDiv(self, context, data):
     if self.query.order == 'publication_time':
         return tags.xml('<span class="selectedCriterium">'
                         'publication time</span>')
     else:
         return tags.xml("""<span class="unselectedCriterium"><a href="javascript: sortBy('publication_time');">"""
                         'publication time</a></span>')

 def render_popularityDiv(self, context, data):
     if self.query.order == 'popularity':
         return tags.xml('<span class="selectedCriterium">'
                         'popularity</span>')
     else:
         return tags.xml("""<span class="unselectedCriterium"><a href="javascript: sortBy('popularity');">"""
                         'popularity</a></span>')

 def render_relevanceDiv(self, context, data):
     if self.query.order == 'relevance':
         return tags.xml('<span class="selectedCriterium">'
                         'relevance</span>')
     else:
         return tags.xml("""<span class="unselectedCriterium"><a href="javascript: sortBy('relevance');">"""
                         'relevance</a></span>')

 def test_xml(self):
     """
     An L{xml} instance is flattened to the UTF-8 representation of itself.
     """
     self.assertStringEqual(self.flatten(xml("foo")), "foo")
     unich = u"\N{LATIN CAPITAL LETTER E WITH GRAVE}"
     self.assertStringEqual(self.flatten(xml(unich)), unich.encode('utf-8'))

 def cruftifyMultipleSpaces(text):
     """Replace multiple spaces with   such that they are rendered as we want."""
     if text.startswith(' '):
         yield tags.xml(' ')
         text = text[1:]
     chunks = text.split('  ')
     for i in SpacePreservingStringRenderer.intersperse(tags.xml('  '), chunks):
         yield i

def inlineJSSerializer(original, ctx):
    from nevow import livepage
    from nevow.tags import script, xml
    theJS = livepage.js(original.children)
    new = livepage.JavascriptContext(ctx, invisible[theJS])
    return serialize(script(type="text/javascript")[
        xml('\n//<![CDATA[\n'),
        serialize(theJS, new),
        xml('\n//]]>\n')], ctx)

    def head(self, request, website):
        def styleSheetLink(href):
            return tags.link(rel='stylesheet', type='text/css', href=href)

        root = website.cleartextRoot(request.getHeader('host'))
        styles = root.child('Eridanus').child('static').child('styles')

        yield styleSheetLink(styles.child('eridanus.css'))
        yield tags.xml(u'<!--[if IE 6]>'), styleSheetLink(styles.child('eridanus-ie6.css')), tags.xml(u'<![endif]-->')
        yield tags.xml(u'<!--[if IE 7]>'), styleSheetLink(styles.child('eridanus-ie7.css')), tags.xml(u'<![endif]-->')

 def render_next(self, context, data):
     """computes 'Next' link"""
     localCount, distantCount = self.querier.countResults(self.qid)
     if self.onlyDistant:
         resultsCount = distantCount
     elif self.onlyLocal:
         resultsCount = localCount
     else:
         resultsCount = localCount + distantCount
     offset = self.query.offset
     if (offset + 15) < resultsCount:
         return tags.xml('<a href="javascript: browseResults(%s);">Next</a>' % (offset + 15))
     return tags.xml('<span class="selectedCriterium">Next</span>')

    def head(self, request, website):
        def styleSheetLink(href):
            return tags.link(rel='stylesheet', type='text/css', href=href)

        root = website.rootURL(request)
        styles = root.child('static').child('Methanal').child('styles')

        yield styleSheetLink(styles.child('methanal.css'))
        yield (tags.xml(u'<!--[if IE 6]>'),
               styleSheetLink(styles.child('methanal-ie6.css')),
               tags.xml(u'<![endif]-->'))
        yield (tags.xml(u'<!--[if IE 7]>'),
               styleSheetLink(styles.child('methanal-ie7.css')),
               tags.xml(u'<![endif]-->'))

    def render_item_template_js(self, ctx, data):
        html = T.script(type="text/javascript", language="javascript" )

        js = """function getTemplates(plugin) {
                %(pluginTemplates)s
            }
            """

        fragment = """ if(plugin == "%(plugin)s") {
                return new Array(%(templates)s);
            }
            """

        fragments = []

        for plugin in self._typesList(ctx):
            templates = ','.join( ['["%s","%s"]'%(t[0],t[1]) for t in plugin.listTemplates])
            fragments.append(fragment%{'plugin':plugin.contentItemClass.__typename__,
                'templates':templates})

        fragments.append( """ { return new Array(); } """)

        pluginTemplates = ' else '.join(fragments)
        js = js%{'pluginTemplates': pluginTemplates}
        return html[T.xml(js)]

 def render_basket_item(self, ctx, basketItem):
     ctx.tag.fillSlots('code', basketItem.code or '')
     ctx.tag.fillSlots('description', T.xml(basketItem.description) or '')
     ctx.tag.fillSlots('quantity_ordered', basketItem.quantity_ordered)
     ctx.tag.fillSlots('unit_price', basketItem.unit_price)
     ctx.tag.fillSlots('total_price', basketItem.total_price)
     return ctx.tag

 def render_basket_item(self, ctx, basketItem): 
     #ctx.tag.fillSlots('thumbnail', T.img(src='/system/ecommerce/%s/mainImage?size=95x150&sharpen=1.0x0.5%%2b0.8%%2b0.1'%basketItem.original.product.id, class_='thumbnail'))
     ctx.tag.fillSlots('description', T.xml(basketItem.description))
     ctx.tag.fillSlots('unit_price', basketItem.unit_price)
     ctx.tag.fillSlots('quantity_ordered', basketItem.quantity_ordered)
     ctx.tag.fillSlots('total_price', basketItem.total_price)
     return ctx.tag

def flattenIText(orig, ctx):
    assert orig.dom.nodeType == orig.dom.ELEMENT_NODE
    assert orig.dom.namespaceURI == 'http://www.w3.org/1999/xhtml'
    assert orig.dom.nodeName == 'div'

    for node in orig.dom.childNodes:
        yield tags.xml(node.toxml())

 def render_comment(self, ctx, comment):
     tag = ctx.tag
     tag.fillSlots("id", comment.id)
     tag.fillSlots("posted", comment.posted)
     tag.fillSlots("authorName", comment.authorName)
     if comment.authorName == 'David Ward':
         tag.fillSlots("isOwner", 'owner')
     else:
         tag.fillSlots("isOwner", '')
     tag.fillSlots("authorEmail", comment.authorEmail)
     tag.fillSlots("comment", T.xml(markdown.markdown(comment.comment)))
     tag.fillSlots("relatesToCommentId",comment.relatesToCommentId)
     if hasattr(comment, 'relatesToComment') and comment.relatesToComment is not None:
         tag.fillSlots("relatesToCommentName",comment.relatesToComment.authorName)
     else:
         tag.fillSlots("relatesToCommentName",'main blog entry')
     if hasattr(comment,'followUpComments') and comment.followUpComments is not None:
         fTag = T.span(class_='followUps')
         for f in comment.followUpComments:
             fTag[ T.a(href="#comment-%s"%f.id,rel='inspires')[ f.authorName ],', ' ]
         tag.fillSlots("followUpComments",fTag)
     else:
         tag.fillSlots("followUpComments",'None')
         
     return tag

    def render_htmlizer(self, ctx, path):
        from twisted.python import htmlizer
        from StringIO import StringIO

        output = StringIO()
        htmlizer.filter(open(path), output, writer=htmlizer.SmallerHTMLWriter)
        return tags.xml(output.getvalue())

    def render_item(self, ctx, data):
        u = url.URL.fromContext(ctx)
        u = url.URL(u.scheme, u.netloc, self.page[0].split('/')[1:])
        ctx.tag.fillSlots('path', self.page[0])
        ctx.tag.fillSlots('href', u)
        ctx.tag.fillSlots('title', self.page[1])
        q = ctx.arg('q')
        if q.lower() in self.page[3].lower():
            highspan = 50
            lowspan = 180
            wrapper = '<strong>%s</strong>'
            offset = self.page[3].lower().find(q.lower())
    
            import re
            cre=re.compile(q,re.IGNORECASE)
            if offset-lowspan <0:
                lower = 0
            else:
                lower = offset-lowspan
            if offset+highspan > len(self.page[3]):
                higher = len(self.page[3])
            else:
                higher = offset+highspan
            out = cre.sub(wrapper%q,self.page[3][lower:higher])
            ctx.tag.fillSlots('summary', T.xml(out))
        else:
            ctx.tag.fillSlots('summary', self.page[2])

        return ctx.tag

def fillReply(ctx, d):
    ctx.tag.fillSlots('id', d.get('pid'))
    ctx.tag.fillSlots('edit', '/edit.xhtml')
    ctx.tag.fillSlots('title', d.get('ttitle'))
    ctx.tag.fillSlots('body', t.xml(d.get('pparsed_body')))
    ctx.tag.fillSlots('userpref', url.root.clear().child('user').child(str(d.get('ulogin'))))
    ctx.tag.fillSlots('owner', d.get('powner'))
    ctx.tag.fillSlots('when', pptime(d.get('pmodification')))

 def block(context, data):
     client = IClientHandle(context)
     if identifier is None:
         iden = client.events.nextId()
     else:
         iden = identifier
     client.events.subscribe(iden, callit)
     return tags.xml(ctsTemplate % (iden, argstr, postlude ))

    def renderHTTP(self, ctx):

        self.setup()

        #ensure that we are delivered with the correct content type header
        inevow.IRequest(ctx).setHeader("Content-Type",
            "application/vnd.mozilla.xul+xml; charset=%s" % (self.charset,))

        #Do something a bit magical.. glue css/js stuff into the window before
        #any other widgets so they get read first.
        if self.css is not None:
            self.window.children.insert(0,
                htmlns.style(type="text/css")[self.css])
        self.css = None

        for css in self.cssIncludes:
            self.window.children.insert(0,
                htmlns.style(type="text/css", src=css))
        self.cssIncludes = []

        if self.js is not None:
            self.window.children.insert(0,
                htmlns.script(type="text/javascript")[self.js])
        self.js = None

        for js in self.jsIncludes:
            self.window.children.insert(0,
                htmlns.script(type="text/javascript", src=js))
        self.jsIncludes = []

        #We want to have javascript included in this order:
        #   preLiveglue.js
        #   liveglue.js
        #   postLiveglue.ps

        if not self.glueInstalled:

            self.window.children.insert(0, htmlns.script(
                type="text/javascript", src=url.here.child(
                    'javascript').child('postLiveglue.js')))

            self.window.children.insert(0, T.invisible(
                render=T.directive('liveglue')))

            self.window.children.insert(0, htmlns.script(
                type="text/javascript", src=url.here.child(
                    'javascript').child('preLiveglue.js')))

            self.glueInstalled = True

        #.. end magical

        #make sure our XUL tree is loaded and our correct doc type is set
        self.docFactory = loaders.stan([
            T.xml("""<?xml version="1.0"?><?xml-stylesheet href="chrome://global/skin/" type="text/css"?>"""),
            self.window])
        #return our XUL
        return athena.LivePage.renderHTTP(self, ctx)

 def renderImmutable(self, ctx, key, args, errors):
     value = iformal.IStringConvertible(self.original).fromType(args.get(key))
     if value:
         value=T.xml(value)
     else:
         value=''
     return T.div(id=key, class_="readonly-textarea-container") [
         T.div(class_='readonly-textarea readonly')[value]
     ]