cubicweb: comparison common/view.py

equal deleted inserted replaced

-:46d4ff5aa917
+:c0f2b6378f70
 cubicweb:displayactions    CDATA   #IMPLIED
 cubicweb:fallbackvid       CDATA   #IMPLIED
 cubicweb:vid               CDATA   #IMPLIED
 cubicweb:rql               CDATA   #IMPLIED
 cubicweb:actualrql         CDATA   #IMPLIED
 cubicweb:rooteid           CDATA   #IMPLIED
 cubicweb:dataurl           CDATA   #IMPLIED
 cubicweb:size              CDATA   #IMPLIED
 cubicweb:tlunit            CDATA   #IMPLIED
 cubicweb:loadurl           CDATA   #IMPLIED
-cubicweb:lazyloadurl       CDATA   #IMPLIED
 cubicweb:uselabel          CDATA   #IMPLIED
 cubicweb:facetargs         CDATA   #IMPLIED
 cubicweb:facetName         CDATA   #IMPLIED
 "> ] '''
 """abstract view class, used as base for every renderable object such
 as views, templates, some components...web
 A view is instantiated to render a [part of a] result set. View
 subclasses may be parametred using the following class attributes:
 * `templatable` indicates if the view may be embeded in a main
 template or if it has to be rendered standalone (i.e. XML for
 instance)
 * if the view is not templatable, it should set the `content_type` class
 attribute to the correct MIME type (text/xhtml by default)
 At instantiation time, the standard `req`, `rset`, and `cursor`
 attributes are added and the `w` attribute will be set at rendering
 time to a write function to use.
 """
 __registry__ = 'views'
 templatable = True
 need_navigation = True
 # content_type = 'application/xhtml+xml' # text/xhtml'
 binary = False
 add_to_breadcrumbs = True
 category = 'view'
 def __init__(self, req, rset):
 super(View, self).__init__(req, rset)
 self.w = None
 @property
 def content_type(self):
 if self.req.xhtml_browser():
 return 'application/xhtml+xml'
 return 'text/html'
 def set_stream(self, w=None):
 if self.w is not None:
 return
 if w is None:
 if self.binary:
 stream = None
 self.w = w
 return stream
 # main view interface #####################################################
 def dispatch(self, w=None, **context):
 """called to render a view object for a result set.
 This method is a dispatched to an actual method selected
 according to optional row and col parameters, which are locating
 a particular row or cell in the result set:
 * if row [and col] are specified, `cell_call` is called
 * if none of them is supplied, the view is considered to apply on
 the whole result set (which may be None in this case), `call` is
 called
 """
 return self._stream.getvalue()
 # should default .call() method add a <div classs="section"> around each
 # rset item
 add_div_section = True
 def call(self, **kwargs):
 """the view is called for an entire result set, by default loop
 other rows of the result set and call the same view on the
 particular row
 self.w(u"</div>")
 def cell_call(self, row, col, **kwargs):
 """the view is called for a particular result set cell"""
 raise NotImplementedError, self
 def linkable(self):
 """return True if the view may be linked in a menu
 by default views without title are not meant to be displayed
 """
 if not getattr(self, 'title', None):
 return False
 return True
 def is_primary(self):
 return self.id == 'primary'
 def url(self):
 """return the url associated with this view. Should not be
 necessary for non linkable views, but a default implementation
 is provided anyway.
 """
 def set_request_content_type(self):
 """set the content type returned by this view"""
 self.req.set_content_type(self.content_type)
 # view utilities ##########################################################
 def view(self, __vid, rset, __fallback_vid=None, **kwargs):
 """shortcut to self.vreg.render method avoiding to pass self.req"""
 try:
 view = self.vreg.select_view(__vid, self.req, rset, **kwargs)
 except NoSelectableObject:
 if __fallback_vid is None:
 raise
 view = self.vreg.select_view(__fallback_vid, self.req, rset, **kwargs)
 return view.dispatch(**kwargs)
 def wview(self, __vid, rset, __fallback_vid=None, **kwargs):
 """shortcut to self.view method automatically passing self.w as argument
 """
 self.view(__vid, rset, __fallback_vid, w=self.w, **kwargs)
 row=row)
 if action:
 label = label or self.req._(action.title)
 return u'<a href="%s">%s</a>' % (html_escape(action.url()), label)
 return u''
 def html_headers(self):
 """return a list of html headers (eg something to be inserted between
 <head> and </head> of the returned page
 by default return a meta tag to disable robot indexation of the page
 """
 return [NOINDEX]
 def page_title(self):
 """returns a title according to the result set - used for the
 title in the HTML header
 """
 vtitle = self.req.form.get('vtitle')
 def create_url(self, etype, **kwargs):
 """ return the url of the entity creation form for a given entity type"""
 return self.req.build_url('add/%s'%etype, **kwargs)
 # concrete views base classes #################################################
 class EntityView(View):
 """base class for views applying on an entity (i.e. uniform result set)
 """
 __registerer__ = accepts_registerer
 __selectors__ = (accept,)
 category = 'entityview'
 def field(self, label, value, row=True, show_label=True, w=None, tr=True):
 """ read-only field """
 if w is None:
 w = self.w
 if row:
 w(u'<span class="label">%s</span>' % label)
 w(u'<div class="field">%s</div>' % value)
 if row:
 w(u'</div>')
 class StartupView(View):
 """base class for views which doesn't need a particular result set
 to be displayed (so they can always be displayed !)
 """
 __registerer__ = priority_registerer
 __selectors__ = (match_user_group, none_rset)
 require_groups = ()
 category = 'startupview'
 def url(self):
 """return the url associated with this view. We can omit rql here"""
 return self.build_url('view', vid=self.id)
 def html_headers(self):
 """base class for entity views which may also be applied to None
 result set (usually a default rql is provided by the view class)
 """
 __registerer__ = accepts_registerer
 __selectors__ = (chainfirst(none_rset, accept),)
 default_rql = None
 def __init__(self, req, rset):
 super(EntityStartupView, self).__init__(req, rset)
 if rset is None:
 # this instance is not in the "entityview" category
 self.category = 'startupview'
 def startup_rql(self):
 """return some rql to be executedif the result set is None"""
 return self.default_rql
 def call(self, **kwargs):
 """override call to execute rql returned by the .startup_rql
 method if necessary
 """
 if self.rset is None:
 """
 if not self.__select__(self.req, self.rset):
 return self.build_url(vid=self.id)
 return super(EntityStartupView, self).url()
 class AnyRsetView(View):
 """base class for views applying on any non empty result sets"""
 __registerer__ = priority_registerer
 __selectors__ = (nonempty_rset,)
 category = 'anyrsetview'
 def columns_labels(self, tr=True):
 if tr:
 translate = display_name
 else:
 translate = lambda req, val: val
 for et in self.rset.column_types(colindex))
 else:
 label = translate(self.req, attr)
 labels.append(label)
 return labels
 class EmptyRsetView(View):
 """base class for views applying on any empty result sets"""
 __registerer__ = priority_registerer
 __selectors__ = (empty_rset,)
 __registry__ = 'templates'
 __registerer__ = priority_registerer
 __selectors__ = (match_user_group,)
 require_groups = ()
 def template(self, oid, **kwargs):
 """shortcut to self.registry.render method on the templates registry"""
 w = kwargs.pop('w', self.w)
 self.vreg.render('templates', oid, self.req, w=w, **kwargs)

changeset 543	c0f2b6378f70
parent 522	385ce5e0b30b
child 632	3a394a90b702
child 962	1cc3c240b2d5