← Back to branch summary

~azzar1/unity/add-show-desktop-key

« back to all changes in this revision

Viewing changes to ivle/webapp/base/xhtml.py

  • Committer: William Grant
  • Date: 2010-01-30 01:49:18 UTC
  • mfrom: (1465.1.2 exercise-breadcrumbs)
  • Revision ID: grantw@unimelb.edu.au-20100130014918-bn9i82pp30hin59r
Add an 'Exercises' breadcrumb before the exercise name.

Show diffs side-by-side

added added

removed removed

Lines of Context:
ivle/webapp/base/xhtml.py
19
19
 
20
20
import inspect
21
21
import os.path
 
22
import urllib
22
23
 
23
24
import genshi.template
24
25
 
 
26
from ivle.webapp.media import media_url
 
27
from ivle.webapp.core import Plugin as CorePlugin
25
28
from ivle.webapp.base.views import BaseView
26
 
import ivle.conf
27
 
import ivle.util
 
29
from ivle.webapp.base.plugins import ViewPlugin, OverlayPlugin
 
30
from ivle.webapp.errors import HTTPError, Unauthorized
 
31
from ivle.webapp.publisher import NoPath
 
32
from ivle.webapp.breadcrumbs import Breadcrumber
28
33
 
29
34
class XHTMLView(BaseView):
30
35
    """
32
37
    It is expected that apps which use this view will be written using Genshi
33
38
    templates.
34
39
    """
35
 
    def __init__(self, req, **kwargs):
36
 
        for key in kwargs:
37
 
          setattr(self, key, kwargs[key])
 
40
 
 
41
    template = 'template.html'
 
42
    allow_overlays = True
 
43
    breadcrumb_text = None
 
44
 
 
45
    def __init__(self, *args, **kwargs):
 
46
        super(XHTMLView, self).__init__(*args, **kwargs)
 
47
 
 
48
        self.overlay_blacklist = []
 
49
 
 
50
        self.plugin_scripts = {}
 
51
        self.plugin_styles = {}
 
52
        self.scripts_init = []
 
53
 
 
54
        self.extra_breadcrumbs = []
 
55
        self.overlay_blacklist = []
 
56
 
 
57
    def get_context_ancestry(self, req):
 
58
        return req.publisher.get_ancestors(self.context)
 
59
 
 
60
    def filter(self, stream, ctx):
 
61
        return stream
38
62
 
39
63
    def render(self, req):
40
64
        req.content_type = 'text/html' # TODO: Detect application/xhtml+xml
47
71
        # view.
48
72
        app_template = os.path.join(os.path.dirname(
49
73
                        inspect.getmodule(self).__file__), self.template) 
50
 
        req.write_html_head_foot = False
51
74
        loader = genshi.template.TemplateLoader(".", auto_reload=True)
52
75
        tmpl = loader.load(app_template)
53
 
        app = tmpl.generate(viewctx)
 
76
        app = self.filter(tmpl.generate(viewctx), viewctx)
 
77
 
 
78
        view_scripts = []
 
79
        for plugin in self.plugin_scripts:
 
80
            for path in self.plugin_scripts[plugin]:
 
81
                view_scripts.append(media_url(req, plugin, path))
 
82
 
 
83
        view_styles = []
 
84
        for plugin in self.plugin_styles:
 
85
            for path in self.plugin_styles[plugin]:
 
86
                view_styles.append(media_url(req, plugin, path))
54
87
 
55
88
        # Global template
56
89
        ctx = genshi.template.Context()
57
 
        ctx['app_styles'] = req.styles
58
 
        ctx['scripts'] = req.scripts
59
 
        ctx['scripts_init'] = req.scripts_init
 
90
 
 
91
        overlay_bits = self.render_overlays(req) if req.user else [[]]*4
 
92
        ctx['overlays'] = overlay_bits[0]
 
93
 
 
94
        ctx['styles'] = [media_url(req, CorePlugin, 'ivle.css')]
 
95
        ctx['styles'] += view_styles
 
96
        ctx['styles'] += overlay_bits[1]
 
97
 
 
98
        ctx['scripts'] = [media_url(req, CorePlugin, path) for path in
 
99
                           ('util.js', 'json2.js', 'md5.js')]
 
100
        ctx['scripts'].append(media_url(req, '+external/jquery', 'jquery.js'))
 
101
        ctx['scripts'] += view_scripts
 
102
        ctx['scripts'] += overlay_bits[2]
 
103
 
 
104
        ctx['scripts_init'] = self.scripts_init + overlay_bits[3]
60
105
        ctx['app_template'] = app
 
106
        ctx['title_img'] = media_url(req, CorePlugin,
 
107
                                     "images/chrome/root-breadcrumb.png")
 
108
        try:
 
109
            ancestry = self.get_context_ancestry(req)
 
110
        except NoPath:
 
111
            ancestry = []
 
112
 
 
113
        crumber = Breadcrumber(req)
 
114
 
 
115
        ctx['breadcrumbs'] = []
 
116
        for ancestor in ancestry:
 
117
            crumb = crumber.crumb(ancestor)
 
118
            if crumb is None:
 
119
                continue
 
120
 
 
121
            if hasattr(crumb, 'extra_breadcrumbs_before'):
 
122
                ctx['breadcrumbs'].extend(crumb.extra_breadcrumbs_before)
 
123
            ctx['breadcrumbs'].append(crumb)
 
124
            if hasattr(crumb, 'extra_breadcrumbs_after'):
 
125
                ctx['breadcrumbs'].extend(crumb.extra_breadcrumbs_after)
 
126
 
 
127
        # If the view has specified text for a breadcrumb, add one.
 
128
        if self.breadcrumb_text:
 
129
            ctx['breadcrumbs'].append(ViewBreadcrumb(req, self))
 
130
 
 
131
        # Allow the view to add its own fake breadcrumbs.
 
132
        ctx['breadcrumbs'].extend(self.extra_breadcrumbs)
 
133
 
61
134
        self.populate_headings(req, ctx)
62
135
        tmpl = loader.load(os.path.join(os.path.dirname(__file__), 
63
136
                                                        'ivle-headings.html'))
64
137
        req.write(tmpl.generate(ctx).render('xhtml', doctype='xhtml'))
 
138
        
 
139
    def populate(self, req, ctx):
 
140
        raise NotImplementedError()
65
141
 
66
142
    def populate_headings(self, req, ctx):
67
143
        ctx['favicon'] = None
68
 
        ctx['root_dir'] = ivle.conf.root_dir
69
 
        ctx['public_host'] = ivle.conf.public_host
 
144
        ctx['root_dir'] = req.config['urls']['root']
 
145
        ctx['public_host'] = req.config['urls']['public_host']
 
146
        ctx['svn_base'] = req.config['urls']['svn_addr']
70
147
        ctx['write_javascript_settings'] = req.write_javascript_settings
71
148
        if req.user:
72
149
            ctx['login'] = req.user.login
74
151
            ctx['nick'] = req.user.nick
75
152
        else:
76
153
            ctx['login'] = None
 
154
            ctx['logged_in'] = False
77
155
        ctx['publicmode'] = req.publicmode
 
156
        if hasattr(self, 'help'):
 
157
            ctx['help_path'] = self.help
 
158
 
78
159
        ctx['apps_in_tabs'] = []
79
 
        for urlname in ivle.conf.apps.apps_in_tabs:
80
 
            new_app = {}
81
 
            app = ivle.conf.apps.app_url[urlname]
82
 
            new_app['this_app'] = hasattr(self, 'appname') \
83
 
                                  and urlname == self.appname
84
 
            if app.icon:
85
 
                new_app['has_icon'] = True
86
 
                icon_dir = ivle.conf.apps.app_icon_dir
87
 
                icon_url = ivle.util.make_path(os.path.join(icon_dir, app.icon))
88
 
                new_app['icon_url'] = icon_url
89
 
                if new_app['this_app']:
90
 
                    ctx['favicon'] = icon_url
 
160
        for plugin in req.config.plugin_index[ViewPlugin]:
 
161
            if not hasattr(plugin, 'tabs'):
 
162
                continue
 
163
 
 
164
            for tab in plugin.tabs:
 
165
                # tab is a tuple: name, title, desc, icon, path
 
166
                new_app = {}
 
167
                new_app['this_app'] = hasattr(self, 'tab') \
 
168
                                      and tab[0] == self.tab
 
169
 
 
170
                # Icon name
 
171
                if tab[3] is not None:
 
172
                    new_app['has_icon'] = True
 
173
                    icon_url = media_url(req, plugin, tab[3])
 
174
                    new_app['icon_url'] = icon_url
 
175
                    if new_app['this_app']:
 
176
                        ctx['favicon'] = icon_url
 
177
                else:
 
178
                    new_app['has_icon'] = False
 
179
                new_app['path'] = req.make_path(tab[4])
 
180
                new_app['desc'] = tab[2]
 
181
                new_app['name'] = tab[1]
 
182
                new_app['weight'] = tab[5]
 
183
                ctx['apps_in_tabs'].append(new_app)
 
184
 
 
185
        ctx['apps_in_tabs'].sort(key=lambda tab: tab['weight'])
 
186
 
 
187
    def render_overlays(self, req):
 
188
        """Generate XML streams for the overlays.
 
189
        
 
190
        Returns a list of streams. Populates the scripts, styles, and 
 
191
        scripts_init.
 
192
        """
 
193
        overlays = []
 
194
        styles = []
 
195
        scripts = []
 
196
        scripts_init = []
 
197
        if not self.allow_overlays:
 
198
            return (overlays, styles, scripts, scripts_init)
 
199
 
 
200
        for plugin in req.config.plugin_index[OverlayPlugin]:
 
201
            for overclass in plugin.overlays:
 
202
                if overclass in self.overlay_blacklist:
 
203
                    continue
 
204
                overlay = overclass(req)
 
205
                #TODO: Re-factor this to look nicer
 
206
                for mplugin in overlay.plugin_scripts:
 
207
                    for path in overlay.plugin_scripts[mplugin]:
 
208
                        scripts.append(media_url(req, mplugin, path))
 
209
 
 
210
                for mplugin in overlay.plugin_styles:
 
211
                    for path in overlay.plugin_styles[mplugin]:
 
212
                        styles.append(media_url(req, mplugin, path))
 
213
 
 
214
                scripts_init += overlay.plugin_scripts_init
 
215
 
 
216
                overlays.append(overlay.render(req))
 
217
        return (overlays, styles, scripts, scripts_init)
 
218
 
 
219
    @classmethod
 
220
    def get_error_view(cls, e):
 
221
        view_map = {HTTPError:    XHTMLErrorView,
 
222
                    Unauthorized: XHTMLUnauthorizedView}
 
223
        for exccls in inspect.getmro(type(e)):
 
224
            if exccls in view_map:
 
225
                return view_map[exccls]
 
226
 
 
227
class XHTMLErrorView(XHTMLView):
 
228
    template = 'xhtmlerror.html'
 
229
 
 
230
    def __init__(self, req, context, lastobj):
 
231
        super(XHTMLErrorView, self).__init__(req, context)
 
232
        self.lastobj = lastobj
 
233
 
 
234
    def get_context_ancestry(self, req):
 
235
        return req.publisher.get_ancestors(self.lastobj)
 
236
 
 
237
    def populate(self, req, ctx):
 
238
        ctx['req'] = req
 
239
        ctx['exception'] = self.context
 
240
 
 
241
class XHTMLUnauthorizedView(XHTMLErrorView):
 
242
    template = 'xhtmlunauthorized.html'
 
243
 
 
244
    def __init__(self, req, exception, lastobj):
 
245
        super(XHTMLUnauthorizedView, self).__init__(req, exception, lastobj)
 
246
 
 
247
        if not req.publicmode and req.user is None:
 
248
            # Not logged in. Redirect to login page.
 
249
            if req.uri == '/':
 
250
                query_string = ''
91
251
            else:
92
 
                new_app['has_icon'] = False
93
 
            new_app['path'] = ivle.util.make_path(urlname)
94
 
            new_app['desc'] = app.desc
95
 
            new_app['name'] = app.name
96
 
            ctx['apps_in_tabs'].append(new_app)
 
252
                query_string = '?url=' + urllib.quote(req.uri, safe="/~")
 
253
            req.throw_redirect('/+login' + query_string)
 
254
 
 
255
        req.status = 403
 
256
 
 
257
class ViewBreadcrumb(object):
 
258
    def __init__(self, req, context):
 
259
        self.req = req
 
260
        self.context = context
 
261
 
 
262
    @property
 
263
    def text(self):
 
264
        return self.context.breadcrumb_text