def render_content_provider(econtext, name):
    name = name.strip()

    context = econtext.get("context")
    request = econtext.get("request")
    view = econtext.get("view")

    cp = zope.component.queryMultiAdapter(
        (context, request, view), IContentProvider, name=name
    )

    # provide a useful error message, if the provider was not found.
    # Be sure to provide the objects in addition to the name so
    # debugging ZCML registrations is possible
    if cp is None:
        raise ContentProviderLookupError(name, (context, request, view))

    # add the __name__ attribute if it implements ILocation
    if ILocation.providedBy(cp):
        cp.__name__ = name

    # Insert the data gotten from the context
    addTALNamespaceData(cp, econtext)

    # Stage 1: Do the state update.
    zope.event.notify(BeforeUpdateEvent(cp, request))
    cp.update()

    # Stage 2: Render the HTML content.
    return cp.render()

    def test_factory_location(self):
        # Given an object that is a location,
        # it is not proxied
        @interface.implementer(ILocation)
        class LocatedTarget(Target):
            __name__ = None
            __parent__ = None

        getAnnotation = factory(LocatedTarget)

        context = Context()
        target = getAnnotation(context)

        key = 'zope.annotation.tests.test_factory.LocatedTarget'
        self.assertEqual([key],
                         list(context))

        # Second, a target object is stored at that location.
        self.assertEqual(type(context[key]), LocatedTarget)

        # Third, the returned object is an ILocation, rooted at the
        # parent and having the given name.
        self.assertTrue(ILocation.providedBy(target))
        self.assertIs(target.__parent__, context)
        self.assertEqual(target.__name__, key)

        # And it's not a proxy.
        self.assertEqual(type(target), LocatedTarget)
        self.assertTrue(ITarget.providedBy(target))
        self.assertIs(target, context[key])

    def update(self):
        """See zope.contentprovider.interfaces.IContentProvider"""
        #--=mpj17=-- Stolen from zope.viewlet.manager
        self.__updated = True
        # Find all content providers for the region
        viewlets = getAdapters(
            (self.context, self.request, self.__parent__, self),
            interfaces.IViewlet)
        viewlets = self.filter_out_no_shows(viewlets)

        # --=mpj17=-- This is the main change to the standard viewlet
        #       manager: the viewlets are sorted according to the
        #       "weight" attribute
        viewlets.sort(key=lambda v: int(v[1].weight))

        self.viewlets = []
        for name, viewlet in viewlets:
            if ILocation.providedBy(viewlet):
                viewlet.__name__ = name
            self.viewlets.append(viewlet)
            # --=mpj17=-- Don't call _updateViewlets, because it does
            #       not exist in Zope 2.10
            if zope213:
                notify(BeforeUpdateEvent(viewlet, self.request))
            viewlet.update()

    def __init__(self, context):
        perms = []
        # first get object permissionsmap
        supp = IObjectPermissionsMaps(context, None)
        if supp is not None:
            perms.extend(supp.get())

        for name, permissions in getAdapters((context,), IPermissionsMap):
        # then get adapted permissionsmap
            perms.append(permissions)

        self.perms = perms

        # collect parents permissionsmaps
        parent_perms = []
        if hasattr(context, '__parent__'):
            parent_context = context.__parent__
        else:
            parent_context = None
        while ILocation.providedBy(parent_context) and parent_context is not None:
            for name, permissions in getAdapters((parent_context,), IPermissionsMap):
                if permissions not in parent_perms:
                    parent_perms.append(permissions)
            parent_context = parent_context.__parent__

        self.parent_perms = parent_perms #tuple(reversed(parent_perms)) # Permissions are propagated in 'child -> parent' direction

    def update(self):
        """
        Update the viewlet manager for rendering.

        This method is part of the protocol of a content provider, called before
        :meth:`render`. This implementation will use it to:

        1. Find the total set of available viewlets by querying for viewlet adapters.
        2. Filter the total set down to the active set by using :meth:`filter`.
        3. Sort the active set using :meth:`sort`.
        4. Provide viewlets that implement :class:`~zope.location.interfaces.ILocation`
           with a name.
        5. Set :attr:`viewlets` to the found set of active viewlets.
        6. Fire :class:`.BeforeUpdateEvent` for each active viewlet before calling ``update()``
           on it.

        ..  seealso:: :class:`zope.contentprovider.interfaces.IContentProvider`
        """
        self.__updated = True

        # Find all content providers for the region
        viewlets = zope.component.getAdapters(
            (self.context, self.request, self.__parent__, self),
            interfaces.IViewlet)

        viewlets = self.filter(viewlets)
        viewlets = self.sort(viewlets)
        # Just use the viewlets from now on
        self.viewlets = []
        for name, viewlet in viewlets:
            if ILocation.providedBy(viewlet):
                viewlet.__name__ = name
            self.viewlets.append(viewlet)
        self._updateViewlets()

def get_title_from_context(context):
    title = None
    if IAlchemistContent.providedBy(context):
        if IDCDescriptiveProperties.providedBy(context):
            title = context.title
        else:
            props = IDCDescriptiveProperties(context, None)
            if props is not None:
                title = props.title
            else:
                title = context.short_name
    elif IAlchemistContainer.providedBy(context):
        domain_model = context._class 
        try:
            descriptor = queryModelDescriptor(domain_model)
        except:
            descriptor = None
            name = ""
        if descriptor:
            name = getattr(descriptor, 'container_name', None)
            if name is None:
                name = getattr(descriptor, 'display_name', None)
        if not name:
            name = getattr(context, '__name__', None)
        title = name
    elif ILocation.providedBy(context) and \
         IDCDescriptiveProperties.providedBy(context):
        title = context.title
    return title

def contained(obj, parent=None, name=None):
    """An implementation of zope.app.container.contained.contained
    that doesn't generate events, for internal use.

    copied from SQLOS / z3c.zalchemy
    """
    if (parent is None):
        raise TypeError('Must provide a parent')

    if not IContained.providedBy(obj):
        if ILocation.providedBy(obj):
            interface.directlyProvides(obj, IContained,
                                       interface.directlyProvidedBy(obj))
        else:
            obj = ContainedProxy(obj)

    oldparent = obj.__parent__
    oldname = obj.__name__

    if (oldparent is None) or not (oldparent is parent
                                   or sameProxiedObjects(oldparent, parent)):
        obj.__parent__ = parent

    if oldname != name and name is not None:
        obj.__name__ = name

    return obj

def _get_title_from_context(context):
    title = None
    if IAlchemistContent.providedBy(context):
        if IDCDescriptiveProperties.providedBy(context):
            title = context.title
        else:
            props = IDCDescriptiveProperties(context, None)
            if props is not None:
                title = props.title
            else:
                ''' !+
AttributeError: 'GroupAddress' object has no attribute 'short_name':   File "/home/undesa/bungeni/cap_installs/bungeni_install/bungeni/releases/20100305100101/src/bungeni.main/bungeni/ui/viewlets/navigation.py", line 59, in _get_title_from_context
                #title = context.short_name 
So, we temporarily default the above to the context.__class__.__name__:
                '''
                title = getattr(context, "short_name", 
                    context.__class__.__name__)
    elif IAlchemistContainer.providedBy(context):
        domain_model = context._class 
        try:
            descriptor = queryModelDescriptor(domain_model)
        except:
            descriptor = None
            name = ""
        if descriptor:
            name = getattr(descriptor, 'container_name', None)
            if name is None:
                name = getattr(descriptor, 'display_name', None)
        if not name:
            name = getattr(context, '__name__', None)
        title = name
    elif ILocation.providedBy(context) and \
         IDCDescriptiveProperties.providedBy(context):
        title = context.title
    return title

    def __call__(self, econtext):
        name = super(ProviderExpression, self).__call__(econtext)
        view = econtext.vars['view']
        context = view.context
        request = view.request

        # Try to look up the provider.
        provider = zope.component.queryMultiAdapter(
            (context, request, view), interfaces.IContentProvider, name)

        # Provide a useful error message, if the provider was not found.
        if provider is None:
            raise interfaces.ContentProviderLookupError(name)

        # add the __name__ attribute if it implements ILocation
        if ILocation.providedBy(provider):
            provider.__name__ = name

        # Insert the data gotten from the context
        addTALNamespaceData(provider, econtext)

        # Stage 1: Do the state update.
        zope.event.notify(interfaces.BeforeUpdateEvent(provider, request))
        provider.update()

        # Stage 2: Render the HTML content.
        return provider.render()

    def test_factory_no_location(self):

        getAnnotation = factory(Target)

        context = Context()
        target = getAnnotation(context)

        # Several things have happened now.
        # First, we have an annotation, derived from
        # our class name
        key = 'zope.annotation.tests.test_factory.Target'
        self.assertEqual([key],
                         list(context))

        # Second, a target object is stored at that location.
        self.assertEqual(type(context[key]), Target)

        # Third, the returned object is an ILocation, rooted at the
        # parent and having the given name.
        self.assertTrue(ILocation.providedBy(target))
        self.assertIs(target.__parent__, context)
        self.assertEqual(target.__name__, key)

        # But it's a proxy.
        self.assertNotEqual(type(target), Target)
        self.assertTrue(ITarget.providedBy(target))

def render_content_provider(econtext, name):
    name = name.strip()

    context = econtext.get('context')
    request = econtext.get('request')
    view = econtext.get('view')

    cp = zope.component.queryMultiAdapter(
        (context, request, view), IContentProvider, name=name)

    # provide a useful error message, if the provider was not found.
    if cp is None:
        raise ContentProviderLookupError(name)

    # add the __name__ attribute if it implements ILocation
    if ILocation.providedBy(cp):
        cp.__name__ = name

    # Insert the data gotten from the context
    addTALNamespaceData(cp, econtext)

    # Stage 1: Do the state update.
    if BeforeUpdateEvent is not None:
        zope.event.notify(BeforeUpdateEvent(cp, request))
    cp.update()

    # Stage 2: Render the HTML content.
    return cp.render()

 def _setUpWidgets(self):
     adapted = self.schema(self.context)
     if adapted is not self.context:
         if not ILocation.providedBy(adapted):
             adapted = LocationProxy(adapted)
         adapted.__parent__ = self.context
     self.adapted = adapted
     setUpEditWidgets(self, self.schema, source=self.adapted,
                      names=self.fieldNames)

    def __setitem__(self, name, value):
        if ILocation.providedBy(value):
            super(HighlightData, self).__setitem__(name, value)

            if hasattr(self, name):
                delattr(self, name)

        else:
            setattr(self, name, value)

 def __init__(self, authplugin, pau):
     # locate them
     if ILocation.providedBy(authplugin):
         self.__parent__ = authplugin.__parent__
         self.__name__ = authplugin.__name__
     else:
         self.__parent__ = pau
         self.__name__ = ""
     self.authplugin = authplugin
     self.pau = pau

    def update(self):
        self.path = self._get_path(self.context)

        # if the view is a location, append this to the breadcrumbs
        if ILocation.providedBy(self.__parent__) and IDCDescriptiveProperties.providedBy(self.__parent__):
            self.path.append({"name": self.__parent__.title, "url": None})

        try:
            self.user_name = self.request.principal.login
        except:
            pass

 def update(self):
     self.path = self._get_path(self.context)
     
     # if the view is a location, append this to the breadcrumbs
     if ILocation.providedBy(self.__parent__) and \
            IDCDescriptiveProperties.providedBy(self.__parent__):
         self.path.append({
                 "name": self.__parent__.title,
                 "url": None,
             })
     self.chamber = get_chamber_for_context(self.context)

 def __init__(self, authplugin, pau):
     if (ILocation.providedBy(authplugin) and
         authplugin.__parent__ is not None):
         # Checking explicitly for the parent, because providing ILocation
         # basically means that the object *could* be located. It doesn't
         # say the object must be located.
         self.__parent__ = authplugin.__parent__
         self.__name__ = authplugin.__name__
     else:
         self.__parent__ = pau
         self.__name__ = ""
     self.authplugin = authplugin
     self.pau = pau
     self.schema = authplugin.schema

 def publishTraverse(self, request, name):
     # this is the primary condition; traverse to ``name`` by
     # looking up methods on this class
     try:
         method = getattr(self.context, "get_%s" % name)
     except AttributeError:
         # fall back to default traversal (view lookup)
         def method():
             return super(SchedulingContextTraverser, self
                 ).publishTraverse(request, name)
     obj = method()
     assert ILocation.providedBy(obj), obj
     log.debug("SchedulingContextTraverser.publishTraverse: " \
         "self=%s context=%s name=%s obj=%s" % (self, self.context, name, obj))
     return ProxyFactory(LocationProxy(
         removeSecurityProxy(obj), container=self.context, name=name))

    def show_overlay(self):
        """Check whether the calendar overlay portlet needs to be rendered.

            >>> from zope.app.testing import setup
            >>> setup.placelessSetUp()
            >>> setup.setUpAnnotations()

            >>> from schooltool.testing import setup as sbsetup
            >>> sbsetup.setUpCalendaring()

        The portlet is only shown when an authenticated user is looking
        at his/her calendar.

        Anonymous user:

            >>> from zope.publisher.browser import TestRequest
            >>> from schooltool.person.person import Person
            >>> request = TestRequest()
            >>> person = Person()
            >>> context = ISchoolToolCalendar(person)
            >>> view = CalendarOverlayView(context, request, None, None)
            >>> view.show_overlay()
            False

        Person that we're looking at

            >>> from schooltool.app.security import Principal
            >>> request.setPrincipal(Principal('id', 'title', person))
            >>> view.show_overlay()
            True

        A different person:

            >>> request.setPrincipal(Principal('id', 'title', Person()))
            >>> view.show_overlay()
            False

       Cleanup:

            >>> setup.placelessTearDown()

        """
        if not ILocation.providedBy(self.context):
            return False
        logged_in = removeSecurityProxy(IPerson(self.request.principal, None))
        calendar_owner = removeSecurityProxy(self.context.__parent__)
        return logged_in is calendar_owner

    def update(self):
        """See zope.contentprovider.interfaces.IContentProvider"""
        self.__updated = True

        # Find all content providers for the region
        viewlets = zope.component.getAdapters(
            (self.context, self.request, self.__parent__, self),
            interfaces.IViewlet)

        viewlets = self.filter(viewlets)
        viewlets = self.sort(viewlets)
        # Just use the viewlets from now on
        self.viewlets=[]
        for name, viewlet in viewlets:
            if ILocation.providedBy(viewlet):
                viewlet.__name__ = name
            self.viewlets.append(viewlet)
        self._updateViewlets()