← 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: 2009-12-15 05:08:05 UTC
  • mto: This revision was merged to the branch mainline in revision 1433.
  • Revision ID: me@williamgrant.id.au-20091215050805-ohqhdj8w48afks2n
Apply the function input changes to the stdin input, and add a linebreak after the 'Description' label.

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
            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
61
123
        self.populate_headings(req, ctx)
62
124
        tmpl = loader.load(os.path.join(os.path.dirname(__file__), 
63
125
                                                        'ivle-headings.html'))
64
126
        req.write(tmpl.generate(ctx).render('xhtml', doctype='xhtml'))
 
127
        
 
128
    def populate(self, req, ctx):
 
129
        raise NotImplementedError()
65
130
 
66
131
    def populate_headings(self, req, ctx):
67
132
        ctx['favicon'] = None
68
 
        ctx['root_dir'] = ivle.conf.root_dir
69
 
        ctx['public_host'] = ivle.conf.public_host
 
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']
70
136
        ctx['write_javascript_settings'] = req.write_javascript_settings
71
137
        if req.user:
72
138
            ctx['login'] = req.user.login
74
140
            ctx['nick'] = req.user.nick
75
141
        else:
76
142
            ctx['login'] = None
 
143
            ctx['logged_in'] = False
77
144
        ctx['publicmode'] = req.publicmode
 
145
        if hasattr(self, 'help'):
 
146
            ctx['help_path'] = self.help
 
147
 
78
148
        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
 
149
        for plugin in req.config.plugin_index[ViewPlugin]:
 
150
            if not hasattr(plugin, 'tabs'):
 
151
                continue
 
152
 
 
153
            for tab in plugin.tabs:
 
154
                # tab is a tuple: name, title, desc, icon, path
 
155
                new_app = {}
 
156
                new_app['this_app'] = hasattr(self, 'tab') \
 
157
                                      and tab[0] == self.tab
 
158
 
 
159
                # Icon name
 
160
                if tab[3] is not None:
 
161
                    new_app['has_icon'] = True
 
162
                    icon_url = media_url(req, plugin, tab[3])
 
163
                    new_app['icon_url'] = icon_url
 
164
                    if new_app['this_app']:
 
165
                        ctx['favicon'] = icon_url
 
166
                else:
 
167
                    new_app['has_icon'] = False
 
168
                new_app['path'] = req.make_path(tab[4])
 
169
                new_app['desc'] = tab[2]
 
170
                new_app['name'] = tab[1]
 
171
                new_app['weight'] = tab[5]
 
172
                ctx['apps_in_tabs'].append(new_app)
 
173
 
 
174
        ctx['apps_in_tabs'].sort(key=lambda tab: tab['weight'])
 
175
 
 
176
    def render_overlays(self, req):
 
177
        """Generate XML streams for the overlays.
 
178
        
 
179
        Returns a list of streams. Populates the scripts, styles, and 
 
180
        scripts_init.
 
181
        """
 
182
        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]:
 
190
            for overclass in plugin.overlays:
 
191
                if overclass in self.overlay_blacklist:
 
192
                    continue
 
193
                overlay = overclass(req)
 
194
                #TODO: Re-factor this to look nicer
 
195
                for mplugin in overlay.plugin_scripts:
 
196
                    for path in overlay.plugin_scripts[mplugin]:
 
197
                        scripts.append(media_url(req, mplugin, path))
 
198
 
 
199
                for mplugin in overlay.plugin_styles:
 
200
                    for path in overlay.plugin_styles[mplugin]:
 
201
                        styles.append(media_url(req, mplugin, path))
 
202
 
 
203
                scripts_init += overlay.plugin_scripts_init
 
204
 
 
205
                overlays.append(overlay.render(req))
 
206
        return (overlays, styles, scripts, scripts_init)
 
207
 
 
208
    @classmethod
 
209
    def get_error_view(cls, e):
 
210
        view_map = {HTTPError:    XHTMLErrorView,
 
211
                    Unauthorized: XHTMLUnauthorizedView}
 
212
        for exccls in inspect.getmro(type(e)):
 
213
            if exccls in view_map:
 
214
                return view_map[exccls]
 
215
 
 
216
class XHTMLErrorView(XHTMLView):
 
217
    template = 'xhtmlerror.html'
 
218
 
 
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)
 
225
 
 
226
    def populate(self, req, ctx):
 
227
        ctx['req'] = req
 
228
        ctx['exception'] = self.context
 
229
 
 
230
class XHTMLUnauthorizedView(XHTMLErrorView):
 
231
    template = 'xhtmlunauthorized.html'
 
232
 
 
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:
 
237
            # Not logged in. Redirect to login page.
 
238
            if req.uri == '/':
 
239
                query_string = ''
91
240
            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)
 
241
                query_string = '?url=' + urllib.quote(req.uri, safe="/~")
 
242
            req.throw_redirect('/+login' + query_string)
 
243
 
 
244
        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