← 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

Merge from new-dispatch.

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
23
22
 
24
23
import genshi.template
25
24
 
28
27
from ivle.webapp.base.views import BaseView
29
28
from ivle.webapp.base.plugins import ViewPlugin, OverlayPlugin
30
29
from ivle.webapp.errors import HTTPError, Unauthorized
31
 
from ivle.webapp.publisher import NoPath
32
 
from ivle.webapp.breadcrumbs import Breadcrumber
 
30
import ivle.conf
 
31
import ivle.util
33
32
 
34
33
class XHTMLView(BaseView):
35
34
    """
39
38
    """
40
39
 
41
40
    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
 
41
    plugin_scripts = {}
 
42
    plugin_styles = {}
 
43
    overlay_blacklist = []
 
44
 
 
45
    def __init__(self, req, **kwargs):
 
46
        for key in kwargs:
 
47
            setattr(self, key, kwargs[key])
62
48
 
63
49
    def render(self, req):
64
50
        req.content_type = 'text/html' # TODO: Detect application/xhtml+xml
71
57
        # view.
72
58
        app_template = os.path.join(os.path.dirname(
73
59
                        inspect.getmodule(self).__file__), self.template) 
 
60
        req.write_html_head_foot = False
74
61
        loader = genshi.template.TemplateLoader(".", auto_reload=True)
75
62
        tmpl = loader.load(app_template)
76
 
        app = self.filter(tmpl.generate(viewctx), viewctx)
 
63
        app = tmpl.generate(viewctx)
77
64
 
78
 
        view_scripts = []
79
65
        for plugin in self.plugin_scripts:
80
66
            for path in self.plugin_scripts[plugin]:
81
 
                view_scripts.append(media_url(req, plugin, path))
 
67
                req.scripts.append(media_url(req, plugin, path))
82
68
 
83
 
        view_styles = []
84
69
        for plugin in self.plugin_styles:
85
70
            for path in self.plugin_styles[plugin]:
86
 
                view_styles.append(media_url(req, plugin, path))
 
71
                req.styles.append(media_url(req, plugin, path))
87
72
 
88
73
        # Global template
89
74
        ctx = genshi.template.Context()
90
 
 
91
 
        overlay_bits = self.render_overlays(req) if req.user else [[]]*4
92
 
        ctx['overlays'] = overlay_bits[0]
 
75
        # XXX: Leave this here!! (Before req.styles is read)
 
76
        ctx['overlays'] = self.render_overlays(req)
93
77
 
94
78
        ctx['styles'] = [media_url(req, CorePlugin, 'ivle.css')]
95
 
        ctx['styles'] += view_styles
96
 
        ctx['styles'] += overlay_bits[1]
 
79
        ctx['styles'] += req.styles
97
80
 
98
81
        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]
 
82
                           ('util.js', 'json2.js', 'md5.js', 'tos.js')]
 
83
        ctx['scripts'] += req.scripts
103
84
 
104
 
        ctx['scripts_init'] = self.scripts_init + overlay_bits[3]
 
85
        ctx['scripts_init'] = req.scripts_init
105
86
        ctx['app_template'] = app
106
 
        ctx['title_img'] = media_url(req, CorePlugin,
107
 
                                     "images/chrome/root-breadcrumb.png")
108
 
        try:
109
 
            ctx['ancestry'] = self.get_context_ancestry(req)
110
 
        except NoPath:
111
 
            ctx['ancestry'] = []
112
 
 
113
 
        # If the view has specified text for a breadcrumb, add one.
114
 
        if self.breadcrumb_text:
115
 
            ctx['extra_breadcrumbs'] = [ViewBreadcrumb(req, self)]
116
 
        else:
117
 
            ctx['extra_breadcrumbs'] = []
118
 
 
119
 
        # Allow the view to add its own fake breadcrumbs.
120
 
        ctx['extra_breadcrumbs'] += self.extra_breadcrumbs
121
 
 
122
 
        ctx['crumb'] = Breadcrumber(req).crumb
123
87
        self.populate_headings(req, ctx)
124
88
        tmpl = loader.load(os.path.join(os.path.dirname(__file__), 
125
89
                                                        'ivle-headings.html'))
130
94
 
131
95
    def populate_headings(self, req, ctx):
132
96
        ctx['favicon'] = None
133
 
        ctx['root_dir'] = req.config['urls']['root']
134
 
        ctx['public_host'] = req.config['urls']['public_host']
135
 
        ctx['svn_base'] = req.config['urls']['svn_addr']
 
97
        ctx['root_dir'] = ivle.conf.root_dir
 
98
        ctx['public_host'] = ivle.conf.public_host
136
99
        ctx['write_javascript_settings'] = req.write_javascript_settings
137
100
        if req.user:
138
101
            ctx['login'] = req.user.login
146
109
            ctx['help_path'] = self.help
147
110
 
148
111
        ctx['apps_in_tabs'] = []
149
 
        for plugin in req.config.plugin_index[ViewPlugin]:
 
112
        for plugin in req.plugin_index[ViewPlugin]:
150
113
            if not hasattr(plugin, 'tabs'):
151
114
                continue
152
115
 
153
116
            for tab in plugin.tabs:
154
117
                # tab is a tuple: name, title, desc, icon, path
155
118
                new_app = {}
156
 
                new_app['this_app'] = hasattr(self, 'tab') \
157
 
                                      and tab[0] == self.tab
 
119
                new_app['this_app'] = hasattr(self, 'appname') \
 
120
                                      and tab[0] == self.appname
158
121
 
159
122
                # Icon name
160
123
                if tab[3] is not None:
165
128
                        ctx['favicon'] = icon_url
166
129
                else:
167
130
                    new_app['has_icon'] = False
168
 
                new_app['path'] = req.make_path(tab[4])
 
131
                new_app['path'] = ivle.util.make_path(tab[4])
169
132
                new_app['desc'] = tab[2]
170
133
                new_app['name'] = tab[1]
171
134
                new_app['weight'] = tab[5]
180
143
        scripts_init.
181
144
        """
182
145
        overlays = []
183
 
        styles = []
184
 
        scripts = []
185
 
        scripts_init = []
186
 
        if not self.allow_overlays:
187
 
            return (overlays, styles, scripts, scripts_init)
188
 
 
189
 
        for plugin in req.config.plugin_index[OverlayPlugin]:
 
146
        for plugin in req.plugin_index[OverlayPlugin]:
190
147
            for overclass in plugin.overlays:
191
148
                if overclass in self.overlay_blacklist:
192
149
                    continue
194
151
                #TODO: Re-factor this to look nicer
195
152
                for mplugin in overlay.plugin_scripts:
196
153
                    for path in overlay.plugin_scripts[mplugin]:
197
 
                        scripts.append(media_url(req, mplugin, path))
 
154
                        req.scripts.append(media_url(req, mplugin, path))
198
155
 
199
156
                for mplugin in overlay.plugin_styles:
200
157
                    for path in overlay.plugin_styles[mplugin]:
201
 
                        styles.append(media_url(req, mplugin, path))
 
158
                        req.styles.append(media_url(req, mplugin, path))
202
159
 
203
 
                scripts_init += overlay.plugin_scripts_init
 
160
                req.scripts_init += overlay.plugin_scripts_init
204
161
 
205
162
                overlays.append(overlay.render(req))
206
 
        return (overlays, styles, scripts, scripts_init)
 
163
        return overlays
207
164
 
208
165
    @classmethod
209
166
    def get_error_view(cls, e):
216
173
class XHTMLErrorView(XHTMLView):
217
174
    template = 'xhtmlerror.html'
218
175
 
219
 
    def __init__(self, req, context, lastobj):
220
 
        super(XHTMLErrorView, self).__init__(req, context)
221
 
        self.lastobj = lastobj
222
 
 
223
 
    def get_context_ancestry(self, req):
224
 
        return req.publisher.get_ancestors(self.lastobj)
 
176
    def __init__(self, req, exception):
 
177
        self.context = exception
225
178
 
226
179
    def populate(self, req, ctx):
227
 
        ctx['req'] = req
228
180
        ctx['exception'] = self.context
229
181
 
230
182
class XHTMLUnauthorizedView(XHTMLErrorView):
231
183
    template = 'xhtmlunauthorized.html'
232
184
 
233
 
    def __init__(self, req, exception, lastobj):
234
 
        super(XHTMLUnauthorizedView, self).__init__(req, exception, lastobj)
235
 
 
236
 
        if not req.publicmode and req.user is None:
 
185
    def __init__(self, req, exception):
 
186
        super(XHTMLUnauthorizedView, self).__init__(req, exception)
 
187
        if req.user is None:
237
188
            # Not logged in. Redirect to login page.
238
 
            if req.uri == '/':
239
 
                query_string = ''
240
 
            else:
241
 
                query_string = '?url=' + urllib.quote(req.uri, safe="/~")
242
 
            req.throw_redirect('/+login' + query_string)
 
189
            req.throw_redirect('/') # XXX: Need proper URL.
243
190
 
244
191
        req.status = 403
245
 
 
246
 
class ViewBreadcrumb(object):
247
 
    def __init__(self, req, context):
248
 
        self.req = req
249
 
        self.context = context
250
 
 
251
 
    @property
252
 
    def text(self):
253
 
        return self.context.breadcrumb_text