| author | sylvain.thenault@logilab.fr |
| Mon, 16 Feb 2009 19:50:10 +0100 | |
| branch | tls-sprint |
| changeset 633 | 087e3f1e87c8 |
| parent 632 | 3a394a90b702 |
| child 635 | 305da8d6aa2d |
| permissions | -rw-r--r-- |
| 0 | 1 |
"""abstract views and templates classes for CubicWeb web client |
2 |
||
3 |
||
4 |
:organization: Logilab |
|
|
497
68d4211518c5
refactor table views to share more code and to avoid empty filter table in some case
sylvain.thenault@logilab.fr
parents:
472
diff
changeset
|
5 |
:copyright: 2001-2009 LOGILAB S.A. (Paris, FRANCE), all rights reserved. |
| 0 | 6 |
:contact: http://www.logilab.fr/ -- mailto:contact@logilab.fr |
7 |
""" |
|
8 |
__docformat__ = "restructuredtext en" |
|
9 |
||
10 |
from cStringIO import StringIO |
|
| 633 | 11 |
from warnings import warn |
| 0 | 12 |
|
13 |
from logilab.mtconverter import html_escape |
|
14 |
||
15 |
from cubicweb import NotAnEntity, NoSelectableObject |
|
16 |
from cubicweb.common.registerers import accepts_registerer, priority_registerer |
|
| 633 | 17 |
from cubicweb.common.selectors import (yes, match_user_groups, implements, |
18 |
nonempty_rset, none_rset) |
|
| 0 | 19 |
from cubicweb.common.appobject import AppRsetObject, ComponentMixIn |
20 |
from cubicweb.common.utils import UStringIO, HTMLStream |
|
21 |
||
22 |
_ = unicode |
|
23 |
||
| 633 | 24 |
|
25 |
def require_group_compat(registered): |
|
26 |
def plug_selector(cls, vreg): |
|
27 |
cls = registered(cls, vreg) |
|
28 |
if getattr(cls, 'require_groups', None): |
|
29 |
warn('use "use match_user_groups(group1, group2)" instead of using require_groups', |
|
30 |
DeprecationWarning) |
|
31 |
cls.__selectors__ += (match_user_groups(cls.require_groups),) |
|
32 |
return cls |
|
33 |
return classmethod(plug_selector) |
|
34 |
||
35 |
def accepts_compat(registered): |
|
36 |
def plug_selector(cls, vreg): |
|
37 |
cls = registered(cls, vreg) |
|
38 |
if getattr(cls, 'accepts', None): |
|
39 |
warn('use "use match_user_groups(group1, group2)" instead of using require_groups', |
|
40 |
DeprecationWarning) |
|
41 |
cls.__selectors__ += (implements(*cls.accepts),) |
|
42 |
return cls |
|
43 |
return classmethod(plug_selector) |
|
44 |
||
45 |
||
| 0 | 46 |
# robots control |
47 |
NOINDEX = u'<meta name="ROBOTS" content="NOINDEX" />' |
|
48 |
NOFOLLOW = u'<meta name="ROBOTS" content="NOFOLLOW" />' |
|
49 |
||
50 |
CW_XHTML_EXTENSIONS = '''[ |
|
51 |
<!ATTLIST html xmlns:cubicweb CDATA #FIXED \'http://www.logilab.org/2008/cubicweb\' > |
|
52 |
||
53 |
<!ENTITY % coreattrs |
|
|
522
385ce5e0b30b
cubicweb__loadurl -> cubicweb:lazyloadurl
sylvain.thenault@logilab.fr
parents:
497
diff
changeset
|
54 |
"id ID #IMPLIED |
|
385ce5e0b30b
cubicweb__loadurl -> cubicweb:lazyloadurl
sylvain.thenault@logilab.fr
parents:
497
diff
changeset
|
55 |
class CDATA #IMPLIED |
|
385ce5e0b30b
cubicweb__loadurl -> cubicweb:lazyloadurl
sylvain.thenault@logilab.fr
parents:
497
diff
changeset
|
56 |
style CDATA #IMPLIED |
| 0 | 57 |
title CDATA #IMPLIED |
58 |
||
59 |
cubicweb:sortvalue CDATA #IMPLIED |
|
60 |
cubicweb:target CDATA #IMPLIED |
|
61 |
cubicweb:limit CDATA #IMPLIED |
|
62 |
cubicweb:type CDATA #IMPLIED |
|
63 |
cubicweb:loadtype CDATA #IMPLIED |
|
64 |
cubicweb:wdgtype CDATA #IMPLIED |
|
65 |
cubicweb:initfunc CDATA #IMPLIED |
|
66 |
cubicweb:inputid CDATA #IMPLIED |
|
67 |
cubicweb:tindex CDATA #IMPLIED |
|
68 |
cubicweb:inputname CDATA #IMPLIED |
|
69 |
cubicweb:value CDATA #IMPLIED |
|
70 |
cubicweb:required CDATA #IMPLIED |
|
71 |
cubicweb:accesskey CDATA #IMPLIED |
|
72 |
cubicweb:maxlength CDATA #IMPLIED |
|
73 |
cubicweb:variables CDATA #IMPLIED |
|
74 |
cubicweb:displayactions CDATA #IMPLIED |
|
75 |
cubicweb:fallbackvid CDATA #IMPLIED |
|
76 |
cubicweb:vid CDATA #IMPLIED |
|
77 |
cubicweb:rql CDATA #IMPLIED |
|
78 |
cubicweb:actualrql CDATA #IMPLIED |
|
|
543
c0f2b6378f70
simplification of lazy tabs mechanism
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
522
diff
changeset
|
79 |
cubicweb:rooteid CDATA #IMPLIED |
| 0 | 80 |
cubicweb:dataurl CDATA #IMPLIED |
|
543
c0f2b6378f70
simplification of lazy tabs mechanism
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
522
diff
changeset
|
81 |
cubicweb:size CDATA #IMPLIED |
| 0 | 82 |
cubicweb:tlunit CDATA #IMPLIED |
83 |
cubicweb:loadurl CDATA #IMPLIED |
|
84 |
cubicweb:uselabel CDATA #IMPLIED |
|
| 472 | 85 |
cubicweb:facetargs CDATA #IMPLIED |
86 |
cubicweb:facetName CDATA #IMPLIED |
|
| 0 | 87 |
"> ] ''' |
88 |
||
89 |
TRANSITIONAL_DOCTYPE = u'<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd" %s>\n' |
|
90 |
||
91 |
STRICT_DOCTYPE = u'<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd" %s>\n' |
|
92 |
||
93 |
class View(AppRsetObject): |
|
94 |
"""abstract view class, used as base for every renderable object such |
|
95 |
as views, templates, some components...web |
|
96 |
||
97 |
A view is instantiated to render a [part of a] result set. View |
|
98 |
subclasses may be parametred using the following class attributes: |
|
|
543
c0f2b6378f70
simplification of lazy tabs mechanism
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
522
diff
changeset
|
99 |
|
| 0 | 100 |
* `templatable` indicates if the view may be embeded in a main |
101 |
template or if it has to be rendered standalone (i.e. XML for |
|
102 |
instance) |
|
103 |
* if the view is not templatable, it should set the `content_type` class |
|
104 |
attribute to the correct MIME type (text/xhtml by default) |
|
105 |
* the `category` attribute may be used in the interface to regroup related |
|
106 |
objects together |
|
107 |
||
108 |
At instantiation time, the standard `req`, `rset`, and `cursor` |
|
109 |
attributes are added and the `w` attribute will be set at rendering |
|
110 |
time to a write function to use. |
|
111 |
""" |
|
| 632 | 112 |
__registerer__ = priority_registerer |
| 0 | 113 |
__registry__ = 'views' |
|
543
c0f2b6378f70
simplification of lazy tabs mechanism
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
522
diff
changeset
|
114 |
|
| 0 | 115 |
templatable = True |
116 |
need_navigation = True |
|
117 |
# content_type = 'application/xhtml+xml' # text/xhtml' |
|
118 |
binary = False |
|
119 |
add_to_breadcrumbs = True |
|
120 |
category = 'view' |
|
|
543
c0f2b6378f70
simplification of lazy tabs mechanism
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
522
diff
changeset
|
121 |
|
| 0 | 122 |
def __init__(self, req, rset): |
123 |
super(View, self).__init__(req, rset) |
|
124 |
self.w = None |
|
125 |
||
126 |
@property |
|
127 |
def content_type(self): |
|
128 |
if self.req.xhtml_browser(): |
|
129 |
return 'application/xhtml+xml' |
|
130 |
return 'text/html' |
|
|
543
c0f2b6378f70
simplification of lazy tabs mechanism
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
522
diff
changeset
|
131 |
|
| 0 | 132 |
def set_stream(self, w=None): |
133 |
if self.w is not None: |
|
134 |
return |
|
135 |
if w is None: |
|
136 |
if self.binary: |
|
137 |
self._stream = stream = StringIO() |
|
138 |
else: |
|
139 |
self._stream = stream = UStringIO() |
|
140 |
w = stream.write |
|
141 |
else: |
|
142 |
stream = None |
|
143 |
self.w = w |
|
144 |
return stream |
|
145 |
||
146 |
# main view interface ##################################################### |
|
|
543
c0f2b6378f70
simplification of lazy tabs mechanism
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
522
diff
changeset
|
147 |
|
| 0 | 148 |
def dispatch(self, w=None, **context): |
149 |
"""called to render a view object for a result set. |
|
150 |
||
151 |
This method is a dispatched to an actual method selected |
|
152 |
according to optional row and col parameters, which are locating |
|
153 |
a particular row or cell in the result set: |
|
|
543
c0f2b6378f70
simplification of lazy tabs mechanism
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
522
diff
changeset
|
154 |
|
| 0 | 155 |
* if row [and col] are specified, `cell_call` is called |
156 |
* if none of them is supplied, the view is considered to apply on |
|
157 |
the whole result set (which may be None in this case), `call` is |
|
158 |
called |
|
159 |
""" |
|
160 |
row, col = context.get('row'), context.get('col') |
|
161 |
if row is not None: |
|
162 |
context.setdefault('col', 0) |
|
163 |
view_func = self.cell_call |
|
164 |
else: |
|
165 |
view_func = self.call |
|
166 |
stream = self.set_stream(w) |
|
167 |
# stream = self.set_stream(context) |
|
168 |
view_func(**context) |
|
169 |
# return stream content if we have created it |
|
170 |
if stream is not None: |
|
171 |
return self._stream.getvalue() |
|
172 |
||
173 |
# should default .call() method add a <div classs="section"> around each |
|
174 |
# rset item |
|
175 |
add_div_section = True |
|
|
543
c0f2b6378f70
simplification of lazy tabs mechanism
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
522
diff
changeset
|
176 |
|
| 0 | 177 |
def call(self, **kwargs): |
178 |
"""the view is called for an entire result set, by default loop |
|
179 |
other rows of the result set and call the same view on the |
|
180 |
particular row |
|
181 |
||
182 |
Views applicable on None result sets have to override this method |
|
183 |
""" |
|
184 |
rset = self.rset |
|
185 |
if rset is None: |
|
186 |
raise NotImplementedError, self |
|
187 |
wrap = self.templatable and len(rset) > 1 and self.add_div_section |
|
188 |
for i in xrange(len(rset)): |
|
189 |
if wrap: |
|
190 |
self.w(u'<div class="section">') |
|
191 |
self.wview(self.id, rset, row=i, **kwargs) |
|
192 |
if wrap: |
|
193 |
self.w(u"</div>") |
|
194 |
||
195 |
def cell_call(self, row, col, **kwargs): |
|
196 |
"""the view is called for a particular result set cell""" |
|
197 |
raise NotImplementedError, self |
|
|
543
c0f2b6378f70
simplification of lazy tabs mechanism
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
522
diff
changeset
|
198 |
|
| 0 | 199 |
def linkable(self): |
200 |
"""return True if the view may be linked in a menu |
|
|
543
c0f2b6378f70
simplification of lazy tabs mechanism
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
522
diff
changeset
|
201 |
|
| 0 | 202 |
by default views without title are not meant to be displayed |
203 |
""" |
|
204 |
if not getattr(self, 'title', None): |
|
205 |
return False |
|
206 |
return True |
|
207 |
||
208 |
def is_primary(self): |
|
209 |
return self.id == 'primary' |
|
|
543
c0f2b6378f70
simplification of lazy tabs mechanism
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
522
diff
changeset
|
210 |
|
| 0 | 211 |
def url(self): |
212 |
"""return the url associated with this view. Should not be |
|
213 |
necessary for non linkable views, but a default implementation |
|
214 |
is provided anyway. |
|
215 |
""" |
|
216 |
try: |
|
217 |
return self.build_url(vid=self.id, rql=self.req.form['rql']) |
|
218 |
except KeyError: |
|
219 |
return self.build_url(vid=self.id) |
|
220 |
||
221 |
def set_request_content_type(self): |
|
222 |
"""set the content type returned by this view""" |
|
223 |
self.req.set_content_type(self.content_type) |
|
224 |
||
225 |
# view utilities ########################################################## |
|
|
543
c0f2b6378f70
simplification of lazy tabs mechanism
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
522
diff
changeset
|
226 |
|
| 0 | 227 |
def view(self, __vid, rset, __fallback_vid=None, **kwargs): |
228 |
"""shortcut to self.vreg.render method avoiding to pass self.req""" |
|
229 |
try: |
|
230 |
view = self.vreg.select_view(__vid, self.req, rset, **kwargs) |
|
231 |
except NoSelectableObject: |
|
232 |
if __fallback_vid is None: |
|
233 |
raise |
|
234 |
view = self.vreg.select_view(__fallback_vid, self.req, rset, **kwargs) |
|
|
355
89ad20af9e4c
oops, these were committed unintentionnally
Aurelien Campeas <aurelien.campeas@logilab.fr>
parents:
354
diff
changeset
|
235 |
return view.dispatch(**kwargs) |
|
543
c0f2b6378f70
simplification of lazy tabs mechanism
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
522
diff
changeset
|
236 |
|
| 0 | 237 |
def wview(self, __vid, rset, __fallback_vid=None, **kwargs): |
238 |
"""shortcut to self.view method automatically passing self.w as argument |
|
239 |
""" |
|
240 |
self.view(__vid, rset, __fallback_vid, w=self.w, **kwargs) |
|
241 |
||
242 |
def whead(self, data): |
|
243 |
self.req.html_headers.write(data) |
|
244 |
||
245 |
def wdata(self, data): |
|
246 |
"""simple helper that escapes `data` and writes into `self.w`""" |
|
247 |
self.w(html_escape(data)) |
|
248 |
||
249 |
def action(self, actionid, row=0): |
|
250 |
"""shortcut to get action object with id `actionid`""" |
|
251 |
return self.vreg.select_action(actionid, self.req, self.rset, |
|
252 |
row=row) |
|
253 |
||
254 |
def action_url(self, actionid, label=None, row=0): |
|
255 |
"""simple method to be able to display `actionid` as a link anywhere |
|
256 |
""" |
|
257 |
action = self.vreg.select_action(actionid, self.req, self.rset, |
|
258 |
row=row) |
|
259 |
if action: |
|
260 |
label = label or self.req._(action.title) |
|
261 |
return u'<a href="%s">%s</a>' % (html_escape(action.url()), label) |
|
262 |
return u'' |
|
|
543
c0f2b6378f70
simplification of lazy tabs mechanism
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
522
diff
changeset
|
263 |
|
| 0 | 264 |
def html_headers(self): |
265 |
"""return a list of html headers (eg something to be inserted between |
|
266 |
<head> and </head> of the returned page |
|
267 |
||
268 |
by default return a meta tag to disable robot indexation of the page |
|
269 |
""" |
|
270 |
return [NOINDEX] |
|
|
543
c0f2b6378f70
simplification of lazy tabs mechanism
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
522
diff
changeset
|
271 |
|
| 0 | 272 |
def page_title(self): |
273 |
"""returns a title according to the result set - used for the |
|
274 |
title in the HTML header |
|
275 |
""" |
|
276 |
vtitle = self.req.form.get('vtitle') |
|
277 |
if vtitle: |
|
278 |
return self.req._(vtitle) |
|
279 |
# class defined title will only be used if the resulting title doesn't |
|
280 |
# seem clear enough |
|
281 |
vtitle = getattr(self, 'title', None) or u'' |
|
282 |
if vtitle: |
|
283 |
vtitle = self.req._(vtitle) |
|
284 |
rset = self.rset |
|
285 |
if rset and rset.rowcount: |
|
286 |
if rset.rowcount == 1: |
|
287 |
try: |
|
288 |
entity = self.complete_entity(0) |
|
289 |
# use long_title to get context information if any |
|
290 |
clabel = entity.dc_long_title() |
|
291 |
except NotAnEntity: |
|
292 |
clabel = display_name(self.req, rset.description[0][0]) |
|
293 |
clabel = u'%s (%s)' % (clabel, vtitle) |
|
294 |
else : |
|
295 |
etypes = rset.column_types(0) |
|
296 |
if len(etypes) == 1: |
|
297 |
etype = iter(etypes).next() |
|
298 |
clabel = display_name(self.req, etype, 'plural') |
|
299 |
else : |
|
300 |
clabel = u'#[*] (%s)' % vtitle |
|
301 |
else: |
|
302 |
clabel = vtitle |
|
303 |
return u'%s (%s)' % (clabel, self.req.property_value('ui.site-title')) |
|
304 |
||
305 |
def output_url_builder( self, name, url, args ): |
|
306 |
self.w(u'<script language="JavaScript"><!--\n' \ |
|
307 |
u'function %s( %s ) {\n' % (name, ','.join(args) ) ) |
|
308 |
url_parts = url.split("%s") |
|
309 |
self.w(u' url="%s"' % url_parts[0] ) |
|
310 |
for arg, part in zip(args, url_parts[1:]): |
|
311 |
self.w(u'+str(%s)' % arg ) |
|
312 |
if part: |
|
313 |
self.w(u'+"%s"' % part) |
|
314 |
self.w('\n document.window.href=url;\n') |
|
315 |
self.w('}\n-->\n</script>\n') |
|
316 |
||
317 |
def create_url(self, etype, **kwargs): |
|
318 |
""" return the url of the entity creation form for a given entity type""" |
|
319 |
return self.req.build_url('add/%s'%etype, **kwargs) |
|
320 |
||
|
543
c0f2b6378f70
simplification of lazy tabs mechanism
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
522
diff
changeset
|
321 |
|
| 0 | 322 |
# concrete views base classes ################################################# |
323 |
||
324 |
class EntityView(View): |
|
325 |
"""base class for views applying on an entity (i.e. uniform result set) |
|
326 |
""" |
|
327 |
__registerer__ = accepts_registerer |
|
| 633 | 328 |
__selectors__ = (implements('Any'),) |
329 |
registered = accepts_compat(View.registered.im_func) |
|
330 |
||
| 0 | 331 |
category = 'entityview' |
| 633 | 332 |
|
| 0 | 333 |
def field(self, label, value, row=True, show_label=True, w=None, tr=True): |
334 |
""" read-only field """ |
|
335 |
if w is None: |
|
336 |
w = self.w |
|
337 |
if row: |
|
338 |
w(u'<div class="row">') |
|
339 |
if show_label: |
|
340 |
if tr: |
|
341 |
label = display_name(self.req, label) |
|
342 |
w(u'<span class="label">%s</span>' % label) |
|
343 |
w(u'<div class="field">%s</div>' % value) |
|
344 |
if row: |
|
345 |
w(u'</div>') |
|
346 |
||
|
543
c0f2b6378f70
simplification of lazy tabs mechanism
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
522
diff
changeset
|
347 |
|
| 0 | 348 |
class StartupView(View): |
349 |
"""base class for views which doesn't need a particular result set |
|
350 |
to be displayed (so they can always be displayed !) |
|
351 |
""" |
|
352 |
__registerer__ = priority_registerer |
|
| 633 | 353 |
__selectors__ = (none_rset,) |
354 |
registered = require_group_compat(View.registered.im_func) |
|
355 |
||
| 0 | 356 |
category = 'startupview' |
| 633 | 357 |
|
| 0 | 358 |
def url(self): |
359 |
"""return the url associated with this view. We can omit rql here""" |
|
360 |
return self.build_url('view', vid=self.id) |
|
361 |
||
362 |
def html_headers(self): |
|
363 |
"""return a list of html headers (eg something to be inserted between |
|
364 |
<head> and </head> of the returned page |
|
365 |
||
366 |
by default startup views are indexed |
|
367 |
""" |
|
368 |
return [] |
|
369 |
||
370 |
||
371 |
class EntityStartupView(EntityView): |
|
372 |
"""base class for entity views which may also be applied to None |
|
373 |
result set (usually a default rql is provided by the view class) |
|
374 |
""" |
|
375 |
__registerer__ = accepts_registerer |
|
| 633 | 376 |
__selectors__ = ((none_rset | implements('Any')),) |
|
543
c0f2b6378f70
simplification of lazy tabs mechanism
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
522
diff
changeset
|
377 |
|
| 0 | 378 |
default_rql = None |
|
543
c0f2b6378f70
simplification of lazy tabs mechanism
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
522
diff
changeset
|
379 |
|
| 0 | 380 |
def __init__(self, req, rset): |
381 |
super(EntityStartupView, self).__init__(req, rset) |
|
382 |
if rset is None: |
|
383 |
# this instance is not in the "entityview" category |
|
384 |
self.category = 'startupview' |
|
385 |
||
386 |
def startup_rql(self): |
|
387 |
"""return some rql to be executedif the result set is None""" |
|
388 |
return self.default_rql |
|
|
543
c0f2b6378f70
simplification of lazy tabs mechanism
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
522
diff
changeset
|
389 |
|
| 0 | 390 |
def call(self, **kwargs): |
391 |
"""override call to execute rql returned by the .startup_rql |
|
392 |
method if necessary |
|
393 |
""" |
|
394 |
if self.rset is None: |
|
395 |
self.rset = self.req.execute(self.startup_rql()) |
|
396 |
rset = self.rset |
|
397 |
for i in xrange(len(rset)): |
|
398 |
self.wview(self.id, rset, row=i, **kwargs) |
|
399 |
||
400 |
def url(self): |
|
401 |
"""return the url associated with this view. We can omit rql if we |
|
402 |
are on a result set on which we do not apply. |
|
403 |
""" |
|
404 |
if not self.__select__(self.req, self.rset): |
|
405 |
return self.build_url(vid=self.id) |
|
406 |
return super(EntityStartupView, self).url() |
|
407 |
||
|
543
c0f2b6378f70
simplification of lazy tabs mechanism
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
522
diff
changeset
|
408 |
|
| 0 | 409 |
class AnyRsetView(View): |
410 |
"""base class for views applying on any non empty result sets""" |
|
411 |
__registerer__ = priority_registerer |
|
|
237
3df2e0ae2eba
begin selector renaming (work in progress)
Sylvain Thenault <sylvain.thenault@logilab.fr>
parents:
0
diff
changeset
|
412 |
__selectors__ = (nonempty_rset,) |
|
543
c0f2b6378f70
simplification of lazy tabs mechanism
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
522
diff
changeset
|
413 |
|
| 0 | 414 |
category = 'anyrsetview' |
|
543
c0f2b6378f70
simplification of lazy tabs mechanism
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
522
diff
changeset
|
415 |
|
|
370
7e76f651314b
fix rset xml view
Sylvain Thenault <sylvain.thenault@logilab.fr>
parents:
369
diff
changeset
|
416 |
def columns_labels(self, tr=True): |
|
7e76f651314b
fix rset xml view
Sylvain Thenault <sylvain.thenault@logilab.fr>
parents:
369
diff
changeset
|
417 |
if tr: |
|
7e76f651314b
fix rset xml view
Sylvain Thenault <sylvain.thenault@logilab.fr>
parents:
369
diff
changeset
|
418 |
translate = display_name |
|
7e76f651314b
fix rset xml view
Sylvain Thenault <sylvain.thenault@logilab.fr>
parents:
369
diff
changeset
|
419 |
else: |
|
7e76f651314b
fix rset xml view
Sylvain Thenault <sylvain.thenault@logilab.fr>
parents:
369
diff
changeset
|
420 |
translate = lambda req, val: val |
|
369
c8a6edc224bb
new rsetxml view, reusing most code from csvexport view
Sylvain Thenault <sylvain.thenault@logilab.fr>
parents:
361
diff
changeset
|
421 |
rqlstdescr = self.rset.syntax_tree().get_description()[0] # XXX missing Union support |
|
c8a6edc224bb
new rsetxml view, reusing most code from csvexport view
Sylvain Thenault <sylvain.thenault@logilab.fr>
parents:
361
diff
changeset
|
422 |
labels = [] |
|
c8a6edc224bb
new rsetxml view, reusing most code from csvexport view
Sylvain Thenault <sylvain.thenault@logilab.fr>
parents:
361
diff
changeset
|
423 |
for colindex, attr in enumerate(rqlstdescr): |
|
c8a6edc224bb
new rsetxml view, reusing most code from csvexport view
Sylvain Thenault <sylvain.thenault@logilab.fr>
parents:
361
diff
changeset
|
424 |
# compute column header |
|
c8a6edc224bb
new rsetxml view, reusing most code from csvexport view
Sylvain Thenault <sylvain.thenault@logilab.fr>
parents:
361
diff
changeset
|
425 |
if colindex == 0 or attr == 'Any': # find a better label |
|
370
7e76f651314b
fix rset xml view
Sylvain Thenault <sylvain.thenault@logilab.fr>
parents:
369
diff
changeset
|
426 |
label = ','.join(translate(self.req, et) |
|
369
c8a6edc224bb
new rsetxml view, reusing most code from csvexport view
Sylvain Thenault <sylvain.thenault@logilab.fr>
parents:
361
diff
changeset
|
427 |
for et in self.rset.column_types(colindex)) |
|
c8a6edc224bb
new rsetxml view, reusing most code from csvexport view
Sylvain Thenault <sylvain.thenault@logilab.fr>
parents:
361
diff
changeset
|
428 |
else: |
|
370
7e76f651314b
fix rset xml view
Sylvain Thenault <sylvain.thenault@logilab.fr>
parents:
369
diff
changeset
|
429 |
label = translate(self.req, attr) |
|
369
c8a6edc224bb
new rsetxml view, reusing most code from csvexport view
Sylvain Thenault <sylvain.thenault@logilab.fr>
parents:
361
diff
changeset
|
430 |
labels.append(label) |
|
c8a6edc224bb
new rsetxml view, reusing most code from csvexport view
Sylvain Thenault <sylvain.thenault@logilab.fr>
parents:
361
diff
changeset
|
431 |
return labels |
|
543
c0f2b6378f70
simplification of lazy tabs mechanism
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
522
diff
changeset
|
432 |
|
| 633 | 433 |
|
| 0 | 434 |
# concrete template base classes ############################################## |
435 |
||
436 |
class Template(View): |
|
437 |
"""a template is almost like a view, except that by default a template |
|
438 |
is only used globally (i.e. no result set adaptation) |
|
439 |
""" |
|
440 |
__registry__ = 'templates' |
|
441 |
__registerer__ = priority_registerer |
|
| 633 | 442 |
__selectors__ = (yes,) |
| 0 | 443 |
|
| 633 | 444 |
registered = require_group_compat(View.registered.im_func) |
|
543
c0f2b6378f70
simplification of lazy tabs mechanism
Adrien Di Mascio <Adrien.DiMascio@logilab.fr>
parents:
522
diff
changeset
|
445 |
|
| 0 | 446 |
def template(self, oid, **kwargs): |
447 |
"""shortcut to self.registry.render method on the templates registry""" |
|
448 |
w = kwargs.pop('w', self.w) |
|
449 |
self.vreg.render('templates', oid, self.req, w=w, **kwargs) |
|
450 |
||
451 |
||
452 |
class MainTemplate(Template): |
|
453 |
"""main template are primary access point to render a full HTML page. |
|
454 |
There is usually at least a regular main template and a simple fallback |
|
455 |
one to display error if the first one failed |
|
456 |
""" |
|
457 |
base_doctype = STRICT_DOCTYPE |
|
458 |
||
459 |
@property |
|
460 |
def doctype(self): |
|
461 |
if self.req.xhtml_browser(): |
|
462 |
return self.base_doctype % CW_XHTML_EXTENSIONS |
|
463 |
return self.base_doctype % '' |
|
464 |
||
465 |
def set_stream(self, w=None, templatable=True): |
|
466 |
if templatable and self.w is not None: |
|
467 |
return |
|
468 |
||
469 |
if w is None: |
|
470 |
if self.binary: |
|
471 |
self._stream = stream = StringIO() |
|
472 |
elif not templatable: |
|
473 |
# not templatable means we're using a non-html view, we don't |
|
474 |
# want the HTMLStream stuff to interfere during data generation |
|
475 |
self._stream = stream = UStringIO() |
|
476 |
else: |
|
477 |
self._stream = stream = HTMLStream(self.req) |
|
478 |
w = stream.write |
|
479 |
else: |
|
480 |
stream = None |
|
481 |
self.w = w |
|
482 |
return stream |
|
483 |
||
484 |
def write_doctype(self, xmldecl=True): |
|
485 |
assert isinstance(self._stream, HTMLStream) |
|
486 |
self._stream.doctype = self.doctype |
|
487 |
if not xmldecl: |
|
488 |
self._stream.xmldecl = u'' |
|
489 |
||
490 |
# viewable components base classes ############################################ |
|
491 |
||
492 |
class VComponent(ComponentMixIn, View): |
|
493 |
"""base class for displayable components""" |
|
494 |
property_defs = { |
|
495 |
'visible': dict(type='Boolean', default=True, |
|
496 |
help=_('display the component or not')),} |
|
497 |
||
498 |
class SingletonVComponent(VComponent): |
|
499 |
"""base class for displayable unique components""" |
|
500 |
__registerer__ = priority_registerer |