def _add_groups_data(self, req, allow_manual=False):
        perms = sorted(PermissionSystem(self.env).get_all_permissions())
        autocomplete = AutoCompleteGroup(self.env)

        all_groups = set(Group.groupsBy(self.env))
        # TODO: we should remove the autocomplete plugin, at least
        # once userfield can handle "cc style" fields (e.g., multiple
        # users selected) and then I think userfieldplugin should take over ownership
        # of the "shown_groups" settings
        shown_groups = autocomplete.get_autocomplete_values('shown_groups')

        groups = {}
        for group_name in shown_groups:
            group = Group(self.env, group_name)
            groups[group_name] = { 'label': group.label }
            if not group.external_group:
                groups[group_name]['members'] = []
                for subject, permission in perms:
                    if permission == group_name and subject not in all_groups:
                        subject_data = {'id': subject}
                        session = DetachedSession(self.env, subject)
                        if 'name' in session:
                            subject_data['name'] = session['name']
                        groups[group_name]['members'].append(subject_data)

        add_script_data(req, {'userGroups': groups })

    def add_template_data(self, req, data, tickets):
        if isinstance(self.env, ProductEnvironment):
            super(ProductBatchModifyModule, self).add_template_data(req, data,
                                                                    tickets)
            return

        data['batch_modify'] = True
        data['query_href'] = req.session['query_href'] or req.href.query()

        tickets_by_product = {}
        for t in tickets:
            tickets_by_product.setdefault(t['product'], []).append(t)

        data['action_controls'] = []
        global_env = ProductEnvironment.lookup_global_env(self.env)
        cache = {}
        for k, v in tickets_by_product.iteritems():
            batch_module = cache.get(k or '')
            if batch_module is None:
                env = ProductEnvironment(global_env, k) if k else global_env
                cache[k] = batch_module = ProductBatchModifyModule(env)
            data['action_controls'] += batch_module._get_action_controls(req,
                                                                         v)
        batch_list_modes = [
            {'name': _("add"), 'value': "+"},
            {'name': _("remove"), 'value': "-"},
            {'name': _("add / remove"), 'value': "+-"},
            {'name': _("set to"), 'value': "="},
        ]
        add_script_data(req, batch_list_modes=batch_list_modes,
                        batch_list_properties=self._get_list_fields())

 def _make_graph(self, req, repos, info):
     # Generate graph data
     graph = {}
     threads, vertices, columns = \
         make_log_graph(repos, (item['rev'] for item in info))
     graph.update(threads=threads, vertices=vertices, columns=columns,
                  colors=self.graph_colors,
                  line_width=0.04, dot_radius=0.1)
     add_script(req, 'revisiongraph/js/excanvas.js')
     add_script(req, 'revisiongraph/js/log_graph.js')
     add_script_data(req, {'graph': graph})
     
     script = Markup("//<![CDATA[") + """
     jQuery(document).ready(function($) {
       $('th.trac-graph, td.trac-graph').show();
       var canvas = $('""" + Markup("<canvas>") + """').css({width: '%dem',
                                       height: '%dem'})
                                 .appendTo('td.trac-graph')[0];
       canvas.width = $(canvas).width();
       canvas.height = $(canvas).height();
       if (typeof(G_vmlCanvasManager) != 'undefined')
         canvas = G_vmlCanvasManager.initElement(canvas);
       $.paintLogGraph(graph, canvas);
     });
     """ % (graph['columns'] * 2, len(info) * 2) + Markup("//]]>")
     
     th = tag.th('Graph', class_='trac-graph')
     td = tag.td(class_='trac-graph', rowspan='%d' % len(info))
     
     script_filter = Transformer('//head').append(tag.script(script, type="text/javascript"))
     table_filter = Transformer('//table[@class="listing chglist"]').attr('class', 'listing chglist trac-graph')
     th_filter = Transformer('//table/thead/tr/th[@class="diff"]').before(th)
     td_filter = Transformer('//table/tbody/tr[1]/td[@class="diff"]').before(td)
     
     return [script_filter, table_filter, th_filter, td_filter]

    def filter_stream(self, req, method, filename, stream, data):
        selector = ['.user-field']
        page_map = {
            "ticket.html": ["#field-owner", "#field-reporter"],
            "query.html": ["#mods-filters input[name$='_" + field + "']"
                            for field in ("owner", "reporter")],
            "admin_components.html": ["input[name='owner']"],
            "taskboard.html": ["input[class='user-field']"]
        }

        page_map["hours_timeline.html"] = page_map["query.html"]

        def _template_filenames():
            for plugin in self.extra_templates:
                for filename in plugin.get_templates():
                    yield filename

        if filename in page_map:
            if filename == "ticket.html":
                selector.extend('#field-' + n for n in self._user_fields())
            if self.transform_owner_reporter:
                selector.extend(page_map[filename])

        if filename in page_map or filename in _template_filenames():
            self._add_groups_data(req)
            add_script_data(req, {'userfieldSelector': ','.join(selector) })
            add_script(req, 'userfield/js/userfield.js')

        return stream

    def post_process_request(self, req, template, data, content_type):
        """Do any post-processing the request might need; typically adding
        values to the template `data` dictionary, or changing template or
        mime type.
        
        `data` may be update in place.

        Always returns a tuple of (template, data, content_type), even if
        unchanged.

        Note that `template`, `data`, `content_type` will be `None` if:
         - called when processing an error page
         - the default request handler did not return any result

        (Since 0.11)
        """
        if template == 'ticket.html':
            add_stylesheet(req, '%s/css/autocomplete.css' % self.prefix)
            add_script(req, '%s/js/autocomplete.js' % self.prefix)
            if req.path_info.rstrip() == '/newticket':
                add_script_data(req, {'KEYWORDS_AC_PATH': 'ac-keywords'})
            else:
                add_script_data(req, {'KEYWORDS_AC_PATH': '../ac-keywords'})
            add_script(req, '%s/js/autocomplete_ticket_keywords.js' % self.prefix)
        return (template, data, content_type)

 def post_process_request(self, req, template, data, content_type):
     add_script(req, 'wikicomments/wikicomments.js')
     add_script_data(req,  {
         '_wikicomments_author': req.authname,
         '_wikicomments_base': "%s/chrome/wikicomments" % req.base_path 
     })
     return template, data, content_type        

    def post_process_request(self, req, template, data, content_type):
        if data is None:
            return

        js_data = {
            'comments_rest_url': req.href(CommentsREST.href),
            'formatting_help_url': req.href.wiki('WikiFormatting'),
            'delete_url': req.href(DeleteCommentForm.href),
            'preview_url': req.href(WikiPreview.href),
            'templates': self.templates_js_data(),
            'active_comment_id': req.args.get('codecomment'),
            'username': req.authname,
            'is_admin': 'TRAC_ADMIN' in req.perm,
        }

        original_return_value = template, data, content_type
        if req.path_info.startswith('/changeset/'):
            js_data.update(self.changeset_js_data(req, data))
        elif req.path_info.startswith('/browser'):
            js_data.update(self.browser_js_data(req, data))
        elif re.match(r'/attachment/ticket/\d+/.*', req.path_info):
            js_data.update(self.attachment_js_data(req, data))
        else:
            return original_return_value

        add_script(req, 'code-comments/json2.js')
        add_script(req, 'code-comments/underscore-min.js')
        add_script(req, 'code-comments/backbone-min.js')
        # jQuery UI includes: UI Core, Interactions, Button & Dialog Widgets, Core Effects, custom theme
        add_script(req, 'code-comments/jquery-ui/jquery-ui.js')
        add_stylesheet(req, 'code-comments/jquery-ui/trac-theme.css')
        add_script(req, 'code-comments/jquery.ba-throttle-debounce.min.js')
        add_script(req, 'code-comments/code-comments.js')
        add_script_data(req, {'CodeComments': js_data})
        return original_return_value

    def render_admin_panel(self, req, cat, page, path_info):
        req.perm.assert_permission('TRAC_ADMIN')
        if req.method == 'POST':
            self._parse_request(req)

        action, status = self._conf_to_inner_format(self.config)
        operations = self.operations
        permissions = self._get_permissions(req)
        add_stylesheet(req, 'tracworkflowadmin/themes/base/jquery-ui.css')
        add_stylesheet(req, 'tracworkflowadmin/css/tracworkflowadmin.css')
        add_stylesheet(req, 'tracworkflowadmin/css/jquery.multiselect.css')
        add_script(req, 'tracworkflowadmin/scripts/jquery-ui.js')
        add_script(req, 'tracworkflowadmin/scripts/jquery.json-2.2.js')
        add_script(req, 'tracworkflowadmin/scripts/jquery.multiselect.js')
        add_script(req, 'tracworkflowadmin/scripts/main.js')
        add_script_data(req, {'auto_update_interval': int(self.auto_update_interval)})
        if req.locale and str(req.locale) in self.msgjs_locales:
            add_script(req, 'tracworkflowadmin/scripts/messages/%s.js' % req.locale)
        data = {
            'actions': action,
            'status': status,
            'perms': permissions,
            'operations': operations,
            'editor_mode': req.args.get('editor_mode') or self.default_editor,
            'text': self._conf_to_str(self.config)
        }
        return 'tracworkflowadmin.html', data

    def post_process_request(self, req, template, data, content_type):
        mine = ["/newticket", "/ticket", "/simpleticket"]
        if self.use_milestone:
            mine.append("/milestone")
            mine.append("/admin/ticket/milestones")

        match = False
        for target in mine + self.match_req:
            if req.path_info.startswith(target):
                match = True
                break

        if match:
            format = {"dmy": "dd%smm%syy", "mdy": "mm%sdd%syy", "ymd": "yy%smm%sdd"}.get(
                self.date_format, "dd%smm%syy"
            ) % (self.date_sep, self.date_sep)
            add_script_data(
                req,
                {
                    "datefield": {
                        "calendar": req.href.chrome("common", "ics.png"),
                        "format": format,
                        "first_day": self.first_day,
                        "show_week": self.show_week,
                        "show_panel": self.show_panel,
                        "num_months": self.num_months,
                        "change_month": self.change_month,
                        "change_year": self.change_year,
                    }
                },
            )
            add_script(req, "datefield/js/jquery-ui-1.8.16.custom.min.js")
            add_script(req, "datefield/js/datefield.js")
            add_stylesheet(req, "datefield/css/jquery-ui-1.8.16.custom.css")
        return template, data, content_type

    def process_request(self, req):
        req.perm.assert_permission('TICKET_VIEW')
        req.send_header('X-UA-Compatible', 'IE=edge')

        if req.path_info == '/ticketcalendar-ticket':
            return self._process_ticket_detail(req)

        self._add_header_contents(req)

        calendar = TicketCalendar(self.env, req)
        query = calendar.get_query(calendar.get_constraints())
        data = calendar.template_data(req, query)
        data['query_form_filters'] = self._render_query_form_filters(req, data)
        properties = dict((name, dict((key, field[key])
                                      for key in ('type', 'label', 'options',
                                                  'optgroups')
                                      if key in field))
                          for name, field in data['fields'].iteritems())
        add_script_data(req, {'properties': properties,
                              'modes': self._get_modes(data)})
        redirect = 'update' in req.args

        if req.path_info == '/ticketcalendar-box':
            month = _parse_month_arg(req.args.get('_month'), req.tz)
            if redirect:
                req.redirect(calendar.get_box_href(query, month))
            return self._process_box(req, query, data, month)

        if req.path_info == '/ticketcalendar-list':
            start, period = _parse_duration_arg(req.args.getfirst('_duration'),
                                                req.tz)
            if redirect:
                req.redirect(calendar.get_list_href(query, start, period))
            return self._process_list(req, query, data, start, period)

 def filter_stream(self, req, method, filename, stream, data):
     if filename in [
                     'ticket.html',  # /ticket/{\d} or /newticket
                     ]:
         add_script(req, "contextchrome/js/ticketvalidatordecolator.js")
         status = 'ticket' in data and data['ticket'].values['status'] or 'sentinel'
         add_script_data(req, {"contextchrome_tracstatus": status})
     return stream

    def filter_stream(self, req, method, filename, stream, data):
        self.log.debug("ckintegration: template %s" % (filename))
        # Act only when enabled, and editor_source defined, and current template has wiki-textareas
        if self.editor_source and self._check_editor_type(filename):
            # Some javascript global variable to add to the response to assist to tracwiki plugin

            add_script_data(
                req,
                {
                    "ck_editor_type": self.editor_type,
                    "ck_code_styles": self.get_styles_list(),
                    "trac_base_url": req.href.base,
                    "ck_tracwiki_path": req.href.chrome("ckintegration"),
                    "ck_resource_realm": "wiki",
                    "ck_resource_id": "",
                    "form_token": req.form_token,
                },
            )
            # Load the needed scripts (CKEditor itself, and the tracwiki plugin
            add_script(req, self.editor_source)
            add_script(req, "ckintegration/tracwiki.js")
            add_script(req, "ckintegration/pastecode.js")
            # Inject a script that adds the tracwiki plugin as an external plugin to CKEditor
            # @todo: Perform init with a dedicated loader script
            # @todo: Use the init to modify the CKEditor toolbar
            ck_plugin_init = '<script type="text/javascript">CKEDITOR.plugins.addExternal("tracwiki", ck_tracwiki_path, "tracwiki.js");\n'
            ck_plugin_init += 'CKEDITOR.plugins.addExternal("pastecode", ck_tracwiki_path, "pastecode.js");</script>'
            stream |= Transformer(".//body").prepend(HTML(ck_plugin_init))
            # add_script(req, 'ckintegration/ckloader.js')
            # Replace all relevant textarea fields in the template with CKEditor instances
            for field_name in self.template_fields[lower(filename)]:
                self.log.debug('Replacing textarea "%s" with CKEditor instance' % (field_name))
                add_editor = """<script type="text/javascript">
                    CKEDITOR.replace("%s", { extraPlugins : "tracwiki,pastecode" });
                </script>""" % (
                    field_name
                )
                # self.log.debug ("add_editor is %s" % add_editor)
                stream |= Transformer('.//textarea[@name="%s"]' % (field_name)).after(HTML(add_editor))
            # Also replace custom textarea fields in the ticket template that have wiki format
            if "ticket.html" == lower(filename) and "fields" in data:
                for f in data["fields"]:
                    if (
                        f["skip"]
                        or not lower(f["type"]) == "textarea"
                        or not f.has_key("format")
                        or not "wiki" == lower(f["format"])
                    ):
                        continue
                    field_name = "field_%s" % f["name"]
                    self.log.debug('Replacing textarea "%s" with CKEditor instance' % (field_name))
                    add_editor = """<script type="text/javascript">
                        CKEDITOR.replace("%s", { extraPlugins : "tracwiki,pastecode" });
                    </script>""" % (
                        field_name
                    )
                    stream |= Transformer('.//textarea[@name="%s"]' % (field_name)).after(HTML(add_editor))
        return stream

    def post_process_request(self, req, template, data, content_type):
        """
        Add global javascript data on post-processing phase
        """
        # When processing template, add global javascript json into scripts
        if template:
            add_script_data(req, {'multiproject': self._get_published_data(req)})

        return template, data, content_type

    def post_process_request(self, req, template, data, content_type):
        if not req or not template or not isinstance(data, dict):
            return template, data, content_type

        model = None
        resource = None
        attachments = None

        if template in ('wiki_view.html', 'wiki_edit.html'):
            model = data.get('page')
        elif template == 'ticket.html':
            model = data.get('ticket')
        elif template in ('milestone_view.html', 'milestone_edit.html'):
            model = data.get('milestone')
        elif template == 'attachment.html':
            attachments = data.get('attachments')
            if attachments:
                resource = attachments['parent']

        if not resource and model and model.exists:
            resource = model.resource
        if not resource:
            return template, data, content_type
        if not attachments:
            attachments = data.get('attachments')
        if not attachments and model and resource:
            context = web_context(req, resource)
            attachments = AttachmentModule(self.env).attachment_data(context)
            data['attachments'] = attachments

        if template in ('wiki_edit.html', 'milestone_edit.html'):
            self._add_overlayview(req)
        add_stylesheet(req, 'tracdragdrop/tracdragdrop.css')
        if hasattr(req, 'locale'):
            locale = str(req.locale)
            if locale in self.messages_files:
                add_script(req, 'tracdragdrop/messages/%s.js' % locale)
        add_script(req, 'common/js/folding.js')
        add_script(req, 'tracdragdrop/tracdragdrop.js')
        script_data = {
            '_tracdragdrop': {
                'base_url': req.href().rstrip('/') + '/',
                'new_url': req.href('tracdragdrop', 'new', resource.realm,
                                    resource.id),
                'can_create': attachments.get('can_create') or False,
                'max_size': AttachmentModule(self.env).max_size,
            },
            'form_token': req.form_token,
        }
        if add_script_data:
            add_script_data(req, script_data)
        else:
            setattr(req, '_tracdragdrop_data', script_data)

        return template, data, content_type

 def post_process_request(self, req, template, data, content_type):
     # remove script (jquery aggiornato caricato via fanstatic)
     del_script(req, 'common/js/jquery.js')
     # fanstatic
     dashboard.need()
     add_script(req, 'por/por.js')
     field_descriptions = dict([(field['name'], field['descriptions']) \
         for field in TicketSystem(self.env).get_custom_fields() \
             if field.get('descriptions')])
     add_script_data(req, {'fielddescriptions': field_descriptions})
     return template, data, content_type

 def post_process_request(self, req, template, data, content_type):
     if template in ('timeline.html', 'wiki_view.html', 'ticket.html',
                     'milestone_view.html', 'attachment.html'):
         add_stylesheet(req, 'common/css/code.css')
         add_stylesheet(req, 'overlayview/base.css')
         add_script(req, 'common/js/folding.js')
         add_script(req, 'overlayview/jquery.colorbox.js')
         add_script(req, 'overlayview/base.js')
         script_data = {}
         script_data['baseurl'] = req.href().rstrip('/') + '/'
         add_script_data(req, {'overlayview': script_data})
     return template, data, content_type

 def post_process_request(self, req, template, data, content_type):
     if data and (not self.has_pretty_dateinfo or data.get('dateinfo')):
         add_script(req, 'tractimedeltaupdator/main.js')
         if self.has_pretty_dateinfo:
             dateinfo = req.session.get(
                 'dateinfo', Chrome(self.env).default_dateinfo_format)
             script_data = self._get_script_data(req, data, dateinfo)
             self._set_dateinfo_funcs(req, data, dateinfo)
         else:
             script_data = self._get_script_data(req, data, 'relative')
         add_script_data(req, {'tractimedeltaupdator': script_data})
     return template, data, content_type

    def post_process_request(self, req, template, data, content_type):
        if req.path_info.startswith('/browser'):
            # see if the user has seen the tortoise svn dialog before
            # we use this data in the javascript to tell if we should 
            # show a dialog which asks the user if they have TSVN installed
            if 'tortoise_svn_message' in req.session:
                add_script_data(req, {'tortoise_svn_message': True})
            else:
                add_script_data(req, {'tortoise_svn_message': False})
                add_script(req, 'contextmenu/js/tortoise-svn-message.js')

        return template, data, content_type

 def add_template_data(self, req, data, tickets):
     data['batch_modify'] = True
     data['query_href'] = req.session['query_href'] or req.href.query()
     data['action_controls'] = self._get_action_controls(req, tickets)
     batch_list_modes = [
         {'name': _("add"), 'value': "+"},
         {'name': _("remove"), 'value': "-"},
         {'name': _("add / remove"), 'value': "+-"},
         {'name': _("set to"), 'value': "="},
     ]
     add_script_data(req, batch_list_modes=batch_list_modes,
                     batch_list_properties=self._get_list_fields())

 def post_process_request(self, req, template, data, content_type):
     if (req.path_info.startswith('/wiki') or
         req.path_info.startswith('/ticket') or
         req.path_info.startswith('/newticket')):
         if req.method == 'GET' or req.method == 'POST':
             self.env.log.info('Injecting wikiautocomplete javascript')
             add_script_data(req, {
                 'wikiautocomplete_url': req.href('wikiautocomplete'),
                 })
             add_script(req, 'wikiautocomplete/js/jquery.textcomplete.min.js')
             add_script(req, 'wikiautocomplete/js/wikiautocomplete.js')
             add_stylesheet(req, 'wikiautocomplete/css/jquery.textcomplete.css')
     return (template, data, content_type)