コード例 #1
0
    def test_put_cache_complex(self):
        """Test if put_cache() works for a more complex, practical scenario:

           As 'source' we just use some random integer as count value.

           The 'rendered representation' of it is just the word "spam" repeated
           count times, which we cache.

           The cache key calculation (for the 'non-guessable' keys) is also
           rather simple.

           In real world, source would be likely some big image, rendered
           representation of it a thumbnail / preview of it. Or some LaTeX
           source and its rendered representation as png image.
           Key calculation could be some MAC or some other hard to guess and
           unique string.
        """
        import random
        request = self.request
        render = lambda data: "spam" * data
        secret = 4223
        keycalc = lambda data: str(data * secret)

        source = random.randint(1, 100)
        rendered1 = render(source)
        key1 = keycalc(source)

        cache.put(request, key1, rendered1)
        url1 = cache.url(request, key1)
        assert 'key=%s' % key1 in url1

        data_cache = caching.CacheEntry(request,
                                        arena=cache.cache_arena,
                                        scope=cache.cache_scope,
                                        key=key1+'.data')
        cached1 = data_cache.content()

        assert render(source) == cached1
        # if that succeeds, we have stored the rendered representation of source in the cache under key1

        # now we use some different source, render it and store it in the cache
        source = source * 2
        rendered2 = render(source)
        key2 = keycalc(source)

        cache.put(request, key2, rendered2)
        url2 = cache.url(request, key2)
        assert 'key=%s' % key2 in url2

        data_cache = caching.CacheEntry(request,
                                        arena=cache.cache_arena,
                                        scope=cache.cache_scope,
                                        key=key2+'.data')
        cached2 = data_cache.content()

        assert render(source) == cached2
        # if that succeeds, we have stored the rendered representation of updated source in the cache under key2

        assert url2 != url1  # URLs must be different for different source (implies different keys)
コード例 #2
0
ファイル: test_cache.py プロジェクト: execgit/gwiki-with-moin
    def test_put_cache_complex(self):
        """Test if put_cache() works for a more complex, practical scenario:

           As 'source' we just use some random integer as count value.

           The 'rendered representation' of it is just the word "spam" repeated
           count times, which we cache.

           The cache key calculation (for the 'non-guessable' keys) is also
           rather simple.

           In real world, source would be likely some big image, rendered
           representation of it a thumbnail / preview of it. Or some LaTeX
           source and its rendered representation as png image.
           Key calculation could be some MAC or some other hard to guess and
           unique string.
        """
        import random
        request = self.request
        render = lambda data: "spam" * data
        secret = 4223
        keycalc = lambda data: str(data * secret)

        source = random.randint(1, 100)
        rendered1 = render(source)
        key1 = keycalc(source)

        cache.put(request, key1, rendered1)
        url1 = cache.url(request, key1)
        assert 'key=%s' % key1 in url1

        data_cache = caching.CacheEntry(request,
                                        arena=cache.cache_arena,
                                        scope=cache.cache_scope,
                                        key=key1 + '.data')
        cached1 = data_cache.content()

        assert render(source) == cached1
        # if that succeeds, we have stored the rendered representation of source in the cache under key1

        # now we use some different source, render it and store it in the cache
        source = source * 2
        rendered2 = render(source)
        key2 = keycalc(source)

        cache.put(request, key2, rendered2)
        url2 = cache.url(request, key2)
        assert 'key=%s' % key2 in url2

        data_cache = caching.CacheEntry(request,
                                        arena=cache.cache_arena,
                                        scope=cache.cache_scope,
                                        key=key2 + '.data')
        cached2 = data_cache.content()

        assert render(source) == cached2
        # if that succeeds, we have stored the rendered representation of updated source in the cache under key2

        assert url2 != url1  # URLs must be different for different source (implies different keys)
コード例 #3
0
ファイル: test_cache.py プロジェクト: execgit/gwiki-with-moin
    def test_put_cache_file_like_data(self):
        """Test if put_cache() works when we give it a file like object for the content"""
        request = self.request
        key = 'nooneknowsit'
        filename = "test.png"
        data = "dontcareatall"
        data_file = StringIO.StringIO(data)
        cache.put(request, key, data_file)
        url = cache.url(request, key)

        assert key in url
        meta_cache = caching.CacheEntry(request,
                                        arena=cache.cache_arena,
                                        scope=cache.cache_scope,
                                        key=key + '.meta',
                                        use_pickle=True)
        meta = meta_cache.content()
        assert meta['httpdate_last_modified'].endswith(
            ' GMT'
        )  # only a very rough check, it has used cache mtime as last_modified
        assert ("Content-Type", "application/octet-stream") in meta['headers']
        assert ("Content-Length", len(data)) in meta['headers']

        data_cache = caching.CacheEntry(request,
                                        arena=cache.cache_arena,
                                        scope=cache.cache_scope,
                                        key=key + '.data')
        cached = data_cache.content()
        assert data == cached
コード例 #4
0
ファイル: text_x_mathtran.py プロジェクト: mathrho/moinWiki
    def render(self, formatter):
        """ renders formular  """

        _ = self._

        # checks if initializing of all attributes in __init__ was done
        if not self.init_settings:
            return

        text = """%(mathtran_server)s?;D=%(scale_factor)s;tex=%(formular)s""" % {
                                                                                 "mathtran_server": self.mathtran_server,
                                                                                 "formular": wikiutil.url_quote(self.raw),
                                                                                 "scale_factor": self.scale_factor,
                                                                                }
        key = cache.key(self.request, itemname=self.pagename, content=text)
        if not cache.exists(self.request, key) and urllib:
            # ToDo add a timeout
            image = urllib.urlopen(text)
            cache.put(self.request, key, image.read(),
                      content_type="image/png")
        if cache.exists(self.request, key):
            credits = """<a href="http://www.mathtran.org/" title="MoinMoin uses the Mathtran Online translation of mathematical content software.">MathTran Powered</a>"""
            if not credits in self.request.cfg.page_credits:
                self.request.cfg.page_credits.append(credits)
                # ToDo show the credits only on pages using the parser extension
        return formatter.image(src=cache.url(self.request, key), alt=self.raw)
コード例 #5
0
    def test_put_cache_file_like_data(self):
        """Test if put_cache() works when we give it a file like object for the content"""
        request = self.request
        key = 'nooneknowsit'
        filename = "test.png"
        data = "dontcareatall"
        data_file = StringIO.StringIO(data)
        cache.put(request, key, data_file)
        url = cache.url(request, key)

        assert key in url
        meta_cache = caching.CacheEntry(request,
                                        arena=cache.cache_arena,
                                        scope=cache.cache_scope,
                                        key=key+'.meta', use_pickle=True)
        meta = meta_cache.content()
        assert meta['httpdate_last_modified'].endswith(' GMT') # only a very rough check, it has used cache mtime as last_modified
        assert ("Content-Type", "application/octet-stream") in meta['headers']
        assert ("Content-Length", len(data)) in meta['headers']

        data_cache = caching.CacheEntry(request,
                                        arena=cache.cache_arena,
                                        scope=cache.cache_scope,
                                        key=key+'.data')
        cached = data_cache.content()
        assert data == cached
コード例 #6
0
def execute(macro, args):
    formatter = macro.formatter
    macro.request.page.formatter = formatter
    request = macro.request
    _ = request.getText

    if not args:
        args = request.page.page_name

    key = cache_key(request, (macro.name, args, latest_edit(request)))

    map_text = 'usemap="#%s" ' % (key)

    if not cache_exists(request, key):
        succ, data, mappi = draw_topology(request, args, key)
        if not succ:
            return mappi

        mappi = encode_page(mappi)
        cache.put(request, key, data, content_type='image/png')
        cache.put(request, key + '-map', mappi, content_type='text/html')
    else:
        mappifile = cache._get_datafile(request, key + '-map')
        mappi = mappifile.read()
        mappifile.close()

    div = u'<div class="ClarifiedTopology">\n' + \
        u'<img %ssrc="%s" alt="%s">\n</div>\n' % \
        (map_text, cache.url(request, key), _('topology'))

    map = u'<map id="%s" name="%s">\n' % (key, key)
    map += decode_page(mappi)
    map += u'</map>\n'

    return div + map
コード例 #7
0
    def render(self, formatter):
        """text to image conversion"""
        key = 'aafigure_%s' % (cache.key(self.request,
                                         itemname=self.pagename,
                                         content="%s%s" %
                                         (self.raw, self.args)), )
        if not cache.exists(self.request, key) or not cache.exists(
                self.request, key + '_size'):
            # not in cache, regenerate image
            options = dict(format='svg')
            for arg in self.args.split():
                try:
                    k, v = arg.split('=', 1)
                except ValueError:  # when splitting fails
                    k = arg
                    v = None
                if k == 'aspect':
                    options['aspect'] = float(v)
                elif k == 'scale':
                    options['scale'] = float(v)
                elif k == 'textual':
                    options['textual'] = True
                elif k == 'proportional':
                    options['proportional'] = True
                elif k == 'linewidth':
                    options['linewidth'] = float(v)
                elif k == 'foreground':
                    options['foreground'] = sanitizte_color(v)
                elif k == 'fill':
                    options['fill'] = sanitizte_color(v)
                # no 'background' as SVG backend ignores that
                # no generic options
                # XXX unknown options are ignored with no message

            visitor, output = aafigure.render(self.raw, None, options)
            cache.put(self.request,
                      key,
                      output.getvalue(),
                      content_type="image/svg+xml")
            # need to store the size attributes too
            cache.put(self.request,
                      key + '_size',
                      visitor.get_size_attrs(),
                      content_type="text/plain")

        # get the information from the cache
        #~ return formatter.image(src=cache.url(self.request, key), alt=xxx)
        # XXX this currently only works for HTML, obviously...
        return formatter.rawHTML(
            '<object type="image/svg+xml" data="%s" %s></object>' % (
                cache.url(self.request, key),
                cache._get_datafile(
                    self.request,
                    key + '_size').read()  # XXX no way to directly read cache?
            ))
コード例 #8
0
    def render(self, formatter):
        from MoinMoin.action import cache

        # checks if initializing of all attributes in __init__ was done
        if not self.init_settings:
            return

        # check if diagram on this page has been rendered before
        key = cache.key(self.request, itemname=self.pagename, content=self.raw)
        if not cache.exists(self.request, key):
            image = urllib.urlopen(createYumlUrl(self.raw), proxies=proxies)
            cache.put(self.request, key, image.read(), content_type="image/png")

        return formatter.image(src=cache.url(self.request, key), alt=self.raw)
コード例 #9
0
    def test_put_cache_minimal(self):
        """Test if put_cache() works"""
        request = self.request
        key = 'nooneknowsit'
        data = "dontcare"
        cache.put(request, key, data)
        url = cache.url(request, key)

        assert key in url
        meta_cache = caching.CacheEntry(request,
                                        arena=cache.cache_arena,
                                        scope=cache.cache_scope,
                                        key=key+'.meta', use_pickle=True)
        meta = meta_cache.content()
        assert meta['httpdate_last_modified'].endswith(' GMT') # only a very rough check, it has used cache mtime as last_modified
        assert ("Content-Type", "application/octet-stream") in meta['headers']
        assert ("Content-Length", len(data)) in meta['headers']
コード例 #10
0
    def test_put_cache_guess_ct_give_lm(self):
        """Test if put_cache() works, when we give filename (so it guesses content_type) and last_modified"""
        request = self.request
        key = 'nooneknowsit'
        filename = "test.png"
        data = "dontcare"
        cache.put(request, key, data, filename=filename, last_modified=1)
        url = cache.url(request, key)
        assert key in url

        meta_cache = caching.CacheEntry(request,
                                        arena=cache.cache_arena,
                                        scope=cache.cache_scope,
                                        key=key+'.meta', use_pickle=True)
        meta = meta_cache.content()
        assert meta['httpdate_last_modified'] == 'Thu, 01 Jan 1970 00:00:01 GMT'
        assert ("Content-Type", "image/png") in meta['headers']
        assert ("Content-Length", len(data)) in meta['headers']
コード例 #11
0
ファイル: aafig.py プロジェクト: aquavitae/aafigure
    def render(self, formatter):
        """text to image conversion"""
        key = 'aafigure_%s' % (cache.key(self.request, itemname=self.pagename, content="%s%s" % (self.raw, self.args)),)
        if not cache.exists(self.request, key) or not cache.exists(self.request, key+'_size'):
            # not in cache, regenerate image
            options = dict(format='svg')
            for arg in self.args.split():
                try:
                    k, v = arg.split('=', 1)
                except ValueError:  # when splitting fails
                    k = arg
                    v = None
                if k == 'aspect':
                    options['aspect'] = float(v)
                elif k == 'scale':
                    options['scale'] = float(v)
                elif k == 'textual':
                    options['textual'] = True
                elif k == 'proportional':
                    options['proportional'] = True
                elif k == 'linewidth':
                    options['linewidth'] = float(v)
                elif k == 'foreground':
                    options['foreground'] = sanitizte_color(v)
                elif k == 'fill':
                    options['fill'] = sanitizte_color(v)
                # no 'background' as SVG backend ignores that
                # no generic options
                # XXX unknown options are ignored with no message

            visitor, output = aafigure.render(self.raw, None, options)
            cache.put(self.request, key, output.getvalue(), content_type="image/svg+xml")
            # need to store the size attributes too
            cache.put(self.request, key+'_size', visitor.get_size_attrs(), content_type="text/plain")

        # get the information from the cache
        #~ return formatter.image(src=cache.url(self.request, key), alt=xxx)
        # XXX this currently only works for HTML, obviously...
        return formatter.rawHTML('<object type="image/svg+xml" data="%s" %s></object>' % (
            cache.url(self.request, key),
            cache._get_datafile(self.request, key+'_size').read() # XXX no way to directly read cache?
        ))
コード例 #12
0
ファイル: test_cache.py プロジェクト: execgit/gwiki-with-moin
    def test_put_cache_guess_ct_give_lm(self):
        """Test if put_cache() works, when we give filename (so it guesses content_type) and last_modified"""
        request = self.request
        key = 'nooneknowsit'
        filename = "test.png"
        data = "dontcare"
        cache.put(request, key, data, filename=filename, last_modified=1)
        url = cache.url(request, key)
        assert key in url

        meta_cache = caching.CacheEntry(request,
                                        arena=cache.cache_arena,
                                        scope=cache.cache_scope,
                                        key=key + '.meta',
                                        use_pickle=True)
        meta = meta_cache.content()
        assert meta[
            'httpdate_last_modified'] == 'Thu, 01 Jan 1970 00:00:01 GMT'
        assert ("Content-Type", "image/png") in meta['headers']
        assert ("Content-Length", len(data)) in meta['headers']
コード例 #13
0
ファイル: test_cache.py プロジェクト: execgit/gwiki-with-moin
    def test_put_cache_minimal(self):
        """Test if put_cache() works"""
        request = self.request
        key = 'nooneknowsit'
        data = "dontcare"
        cache.put(request, key, data)
        url = cache.url(request, key)

        assert key in url
        meta_cache = caching.CacheEntry(request,
                                        arena=cache.cache_arena,
                                        scope=cache.cache_scope,
                                        key=key + '.meta',
                                        use_pickle=True)
        meta = meta_cache.content()
        assert meta['httpdate_last_modified'].endswith(
            ' GMT'
        )  # only a very rough check, it has used cache mtime as last_modified
        assert ("Content-Type", "application/octet-stream") in meta['headers']
        assert ("Content-Length", len(data)) in meta['headers']
コード例 #14
0
ファイル: ST.py プロジェクト: graphingwiki/gwiki-with-moin
def execute(macro, args):
    request = macro.request

    # Handle GET arguments
    level = '4'
    level_text = '7'

    if not args:
        args = ''

    arglist = [x.strip() for x in args.split(',') if x]

    if not have_cairo():
        return "Cairo not found."

    key = cache_key(request, (macro.name, arglist))

    if not cache_exists(request, key):
        law = None
        if len(arglist) == 1:
            level = args[0]
        elif len(arglist):
            level = args[0]
            if arglist[1].isdigit():
                level_text = ','.join(arglist[1:])
            else:
                level_text = ''
                law = ','.join(arglist[1:])

        data = plot_tll(level, level_text, law)
        cache.put(request, key, data, content_type='image/png')

    f = macro.formatter

    divfmt = {"class": "ST"}

    result = f.div(1, **divfmt)
    result += f.image(src=cache.url(request, key), alt=LAW.format(level_text))
    result += f.div(0)
    return result
コード例 #15
0
ファイル: ST.py プロジェクト: execgit/gwiki-with-moin
def execute(macro, args):
    request = macro.request

    # Handle GET arguments
    level = '4'
    level_text = '7'

    if not args:
        args = ''

    arglist = [x.strip() for x in args.split(',') if x]

    if not cairo_found:
        return "Cairo not found."

    key = cache_key(request, (macro.name, arglist))

    if not cache_exists(request, key):
        law = None
        if len(arglist) == 1:
            level = args[0]
        elif len(arglist):
            level = args[0]
            if arglist[1].isdigit():
                level_text = ','.join(arglist[1:])
            else:
                level_text = ''
                law = ','.join(arglist[1:])

        data = plot_tll(level, level_text, law)
        cache.put(request, key, data, content_type='image/png')

    f = macro.formatter

    divfmt = {"class": "ST"}

    result = f.div(1, **divfmt)
    result += f.image(src=cache.url(request, key), alt=LAW.format(level_text))
    result += f.div(0)
    return result
コード例 #16
0
ファイル: CM.py プロジェクト: execgit/graphingwiki
def execute(macro, args):
    request = macro.request

    if not cairo_found:
        return "Cairo not found."

    if not args:
        key = DEFAULT
    elif not hasattr(request.cfg, 'gwiki_markings'):
        return "No gwiki_markings in configuration."
    else:
        try:
            val = request.cfg['gwiki_markings'][args]
            key = list()
            for line in val:
                if not isinstance(line, unicode):
                    return ("Marking misconfiguration " +
                            "(not a tuple of unicode strings)")
                key.append((line, CAIRO_BOLD))
        except KeyError:
            return "Marking not in gwiki_markings."

    level_text = ' '.join(x[0] for x in key)
    ckey = cache_key(request, (macro.name, key))

    if not cache_exists(request, ckey):
        data = plot_box(key)
        cache.put(request, ckey, data, content_type='image/png')

    f = macro.formatter

    divfmt = {"class": "CM"}

    result = f.div(1, **divfmt)
    result += f.image(src=cache.url(request, ckey), alt=level_text)
    result += f.div(0)
    return result
コード例 #17
0
ファイル: ViewDot.py プロジェクト: execgit/graphingwiki
    def execute(self):
        request = self.request
        _ = request.getText

        pagename = request.page.page_name
        if not request.user.may.read(pagename):
            fault = _(u'Can not read page') + u'\n'
            if self.inline:
                request.write(request.formatter.text(fault))
                return
            request.content_type = 'text/plain'
            request.write(fault)
            return

        form = values_to_form(request.values)
        self.formargs(form)

        if self.help or not self.attachment:
            enter_page(request, pagename, 'View .gv attachment')

            self.sendForm()

            if self.help:
                # This is the URL addition to the nodes that have graph data
                self.urladd = url_parameters(form)
                self.urladd = self.urladd.replace('&help=Inline', '')
                request.write('&lt;&lt;ViewDot(' + self.urladd + ')&gt;&gt;')

            exit_page(request, pagename)
            return

        if not self.attachment[:10].lower() == 'attachment':
            fault = _(u'No attachment defined') + u'\n'
            if self.inline:
                request.write(request.formatter.text(fault))
                return
            request.content_type = 'text/plain'
            request.write(fault)
            return

        self.attachment = self.attachment[11:]

        pagename, filename = AttachFile.absoluteName(self.attachment,
                                                     self.pagename)
        if not request.user.may.read(pagename):
            fault = _(u'Can not read attachment page') + u'\n'
            if self.inline:
                request.write(request.formatter.text(fault))
                return
            request.content_type = 'text/plain'
            request.write(fault)
            return

        fname = wikiutil.taintfilename(filename)
        fpath = AttachFile.getFilename(request, pagename, fname)

        try:
            data = file(fpath, 'r').read()
        except IOError:
            fault = _(u'Can not read attachment') + u'\n'
            if self.inline:
                request.write(request.formatter.text(fault))
                return
            request.content_type = 'text/plain'
            request.write(fault)
            return

        if not gv_found:
            fault = _(u"ERROR: Graphviz Python extensions not installed. " +\
                      u"Not performing layout.")
            if self.inline:
                request.write(request.formatter.text(fault))
                return
            request.content_type = 'text/plain'
            request.write(fault)
            return

        self.cache_key = cache_key(self.request,
                                   [data, self.graphengine, self.format])
        key = "%s-%s" % (self.cache_key, self.format)

        if self.format in ['zgr', 'svg']:
            formatcontent = 'svg+xml'
        else:
            formatcontent = self.format

        if not cache_exists(request, key):
            graphviz = Graphviz(engine=self.graphengine, string=data)
            data = self.getLayoutInFormat(graphviz, self.format)

            cache.put(self.request, key, data, content_type=formatcontent)

        if self.format in ['zgr', 'svg']:
            # Display zgr graphs as applets
            if self.format == 'zgr':
                image_p = lambda url, text: \
                    '<applet code="net.claribole.zgrviewer.ZGRApplet.class"'+ \
                    ' archive="%s/gwikicommon/zgrviewer/zvtm.jar,' % \
                    (self.request.cfg.url_prefix_static) + \
                    '%s/gwikicommon/zgrviewer/zgrviewer.jar" ' % \
                    (self.request.cfg.url_prefix_static) + \
                    'width="%s" height="%s">' % (form_escape(self.width), form_escape(self.height))+\
                    '<param name="type" ' + \
                    'value="application/x-java-applet;version=1.4" />' + \
                    '<param name="scriptable" value="false" />' + \
                    '<param name="svgURL" value="%s" />' % (url) + \
                    '<param name="title" value="ZGRViewer - Applet" />'+ \
                    '<param name="appletBackgroundColor" value="#DDD" />' + \
                    '<param name="graphBackgroundColor" value="#DDD" />' + \
                    '<param name="highlightColor" value="red" />' + \
                    ' </applet><br>\n'
            else:
                image_p = lambda url, text: \
                    '<object data="%s" alt="%s" ' % (url, text) + \
                    'type="image/svg+xml">\n' + \
                    '<embed src="%s" alt="%s" ' % (url, text) + \
                    'type="image/svg+xml"/>\n</object>'
        else:
            image_p = lambda url, text: \
                '<img src="%s" alt="%s">\n' % (url, text)

        image_uri = cache.url(self.request, key)

        if not self.inline:
            if self.format == 'zgr':
                request.write('<html><body>')

        request.write(image_p(image_uri, _('visualisation')))

        if not self.inline and self.format == 'zgr':
            request.write('</html></body>')
        else:
            pass  # No footer
コード例 #18
0
    def execute(self):
        request = self.request
        _ = request.getText

        pagename = request.page.page_name
        if not request.user.may.read(pagename):
            fault = _(u'Can not read page') + u'\n'
            if self.inline:
                request.write(request.formatter.text(fault))
                return
            request.content_type = 'text/plain'
            request.write(fault)
            return

        form = values_to_form(request.values)
        self.formargs(form)

        if self.help or not self.attachment:
            enter_page(request, pagename, 'View .gv attachment')

            self.sendForm()

            if self.help:
                # This is the URL addition to the nodes that have graph data
                self.urladd = url_parameters(form)
                self.urladd = self.urladd.replace('&help=Inline', '')
                request.write('&lt;&lt;ViewDot(' + self.urladd + ')&gt;&gt;')

            exit_page(request, pagename)
            return

        if not self.attachment[:10].lower() == 'attachment':
            fault = _(u'No attachment defined') + u'\n'
            if self.inline:
                request.write(request.formatter.text(fault))
                return
            request.content_type = 'text/plain'
            request.write(fault)
            return

        self.attachment = self.attachment[11:]

        pagename, filename = AttachFile.absoluteName(self.attachment,
                                                     self.pagename)
        if not request.user.may.read(pagename):
            fault = _(u'Can not read attachment page') + u'\n'
            if self.inline:
                request.write(request.formatter.text(fault))
                return
            request.content_type = 'text/plain'
            request.write(fault)
            return

        fname = wikiutil.taintfilename(filename)
        fpath = AttachFile.getFilename(request, pagename, fname)

        try:
            data = file(fpath, 'r').read()
        except IOError:
            fault = _(u'Can not read attachment') + u'\n'
            if self.inline:
                request.write(request.formatter.text(fault))
                return
            request.content_type = 'text/plain'
            request.write(fault)
            return

        if not have_gv():
            fault = _(u"ERROR: Graphviz Python extensions not installed. " +\
                      u"Not performing layout.")
            if self.inline:
                request.write(request.formatter.text(fault))
                return
            request.content_type = 'text/plain'
            request.write(fault)
            return

        self.cache_key = cache_key(self.request,
                                   [data, self.graphengine, self.format])
        key = "%s-%s" % (self.cache_key, self.format)

        if self.format in ['zgr', 'svg']:
            formatcontent = 'svg+xml'
        else:
            formatcontent = self.format

        if not cache_exists(request, key):
            graphviz = Graphviz(engine=self.graphengine, string=data)
            data = self.getLayoutInFormat(graphviz, self.format)

            cache.put(self.request, key, data, content_type=formatcontent)

        if self.format in ['zgr', 'svg']:
            # Display zgr graphs as applets
            if self.format == 'zgr':
                image_p = lambda url, text: \
                    '<applet code="net.claribole.zgrviewer.ZGRApplet.class"'+ \
                    ' archive="%s/gwikicommon/zgrviewer/zvtm.jar,' % \
                    (self.request.cfg.url_prefix_static) + \
                    '%s/gwikicommon/zgrviewer/zgrviewer.jar" ' % \
                    (self.request.cfg.url_prefix_static) + \
                    'width="%s" height="%s">' % (form_escape(self.width), form_escape(self.height))+\
                    '<param name="type" ' + \
                    'value="application/x-java-applet;version=1.4" />' + \
                    '<param name="scriptable" value="false" />' + \
                    '<param name="svgURL" value="%s" />' % (url) + \
                    '<param name="title" value="ZGRViewer - Applet" />'+ \
                    '<param name="appletBackgroundColor" value="#DDD" />' + \
                    '<param name="graphBackgroundColor" value="#DDD" />' + \
                    '<param name="highlightColor" value="red" />' + \
                    ' </applet><br>\n'
            else:
                image_p = lambda url, text: \
                    '<object data="%s" alt="%s" ' % (url, text) + \
                    'type="image/svg+xml">\n' + \
                    '<embed src="%s" alt="%s" ' % (url, text) + \
                    'type="image/svg+xml"/>\n</object>'
        else:
            image_p = lambda url, text: \
                '<img src="%s" alt="%s">\n' % (url, text)

        image_uri = cache.url(self.request, key)

        if not self.inline:
            if self.format == 'zgr':
                request.write('<html><body>')

        request.write(image_p(image_uri, _('visualisation')))

        if not self.inline and self.format == 'zgr':
            request.write('</html></body>')
        else:
            pass # No footer