__docformat__ = "restructuredtext en"

from logilab.mtconverter import html_escape

from cubicweb.web.uicfg import rdisplay

    rdisplay = rdisplay

    @classmethod

    def vreg_initialization_completed(cls):

        """set default category tags for relations where it's not yet defined in

        the category relation tags

        """

        for eschema in cls.schema.entities():

            for rschema, tschemas, role in eschema.relation_definitions(True):

                for tschema in tschemas:

                    if role == 'subject':

                        X, Y = eschema, tschema

                        card = rschema.rproperty(X, Y, 'cardinality')[0]

                        composed = rschema.rproperty(X, Y, 'composite') == 'object'

                    else:

                        X, Y = tschema, eschema

                        card = rschema.rproperty(X, Y, 'cardinality')[1]

                        composed = rschema.rproperty(X, Y, 'composite') == 'subject'

                    displayinfo = cls.rdisplay.get(rschema, role, X, Y)

                    if displayinfo is None:

                        if rschema.is_final():

                            if rschema.meta or tschema.type in ('Password', 'Bytes'):

                                where = None

                            else:

                                where = 'attributes'

                        elif card in '1+':

                            where = 'attributes'

                        elif composed:

                            where = 'relations'

                        else:

                            where = 'sideboxes'

                        displayinfo = {'where': where,

                                       'order': cls.rdisplay.get_timestamp()}

                        cls.rdisplay.tag_relation(displayinfo, (X, rschema, Y),

                                                  role)

                    displayinfo.setdefault('label', '%s_%s' % (rschema, role))

        self.maxrelated = self.req.property_value('navigation.related-limit')

        boxes = self._prepare_side_boxes(entity)

        if boxes or hasattr(self, 'render_side_related'):

        if boxes or hasattr(self, 'render_side_related'):

            if hasattr(self, 'render_side_related'):

                warn('render_side_related is deprecated')

                self.render_side_related(entity, [])

            self.render_side_boxes(boxes)

        """default implementation return dc_title"""

        return html_escape(entity.dc_title())

        for rschema, tschemas, role, displayinfo in self._iter_display(entity, 'attributes'):

            vid =  displayinfo.get('vid', 'reledit')

            if rschema.is_final():

                value = entity.view('reledit', rtype=rschema.type)

                vid =  displayinfo.get('vid', 'reledit')

                rset = self._relation_rset(entity, rschema, role, displayinfo)

                if rset:

                    value = self.view(rset, vid)

                else:

                    value = None

            self._render_attribute(rschema, value)

        for rschema, tschemas, role, displayinfo in self._iter_display(entity, 'relations'):

            rset = self._relation_rset(entity, rschema, role, displayinfo)

            if rset:

                self._render_relation(rset, displayinfo, 'autolimited',

                                      self.show_rel_label)

    def render_side_boxes(self, boxes):

        for box in boxes:

            if isinstance(box, tuple):

                label, rset, vid, _  = box

            else:

    def _prepare_side_boxes(self, entity):

        sideboxes = []

        for rschema, tschemas, role, displayinfo in self._iter_display(entity, 'sideboxes'):

            rset = self._relation_rset(entity, rschema, role, displayinfo)

            if not rset:

                continue

            label = display_name(self.req, rschema.type, role)

            vid = displayinfo.get('vid', 'autolimited')

            sideboxes.append((label, rset, vid, displayinfo.get('order')))

        sideboxes = sorted(sideboxes, key=lambda x: x[-1])

        sideboxes += list(self.vreg.possible_vobjects('boxes', self.req, self.rset,

                                                      row=self.row, view=self,

                                                      context='incontext'))

        return sideboxes

    def _iter_display(self, entity, where):

        eschema = entity.e_schema

        for rschema, tschemas, role in eschema.relation_definitions(True):

            matchtschemas = []

            for tschema in tschemas:

                displayinfo = self.rdisplay.etype_get(eschema, rschema, role,

                                                      tschema)

                assert displayinfo is not None, (str(rschema), role,

                                                 str(eschema), str(tschema))

                if displayinfo.get('where') == where:

                    matchtschemas.append(tschema)

            if matchtschemas:

                # XXX pick the latest displayinfo

                yield rschema, matchtschemas, role, displayinfo

    def _relation_rset(self, entity, rschema, role, displayinfo):

        try:

            if displayinfo.get('limit'):

                rset = entity.related(rschema.type, role,

                                      limit=self.maxrelated+1)

            else:

                rset = entity.related(rschema.type, role)

        except Unauthorized:

            return

        if 'filter' in displayinfo:

            rset = displayinfo['filter'](rset)

        return rset

    def _render_relation(self, rset, displayinfo, defaultvid, showlabel):

        self.w('<div class="section">')

        if showlabel:

            label = self.req._(displayinfo['label'])

            self.w('<h4>%s</h4>' % label)

        self.wview(displayinfo.get('vid', defaultvid), rset)

        self.w('</div>')

    def _render_attribute(self, rschema, value, role='subject'):

            show_label = self.show_rel_label

    def call(self, title=None, **kwargs):

        if title:

            self.w(u'<div class="title"><span>%s</span></div>' % title)

            self.rset.limit(maxrelated)