Il motivo per cui non possiamo manipolare il meccanismo della site map di Plone per "centrare" velocemente la mappa dove serve a noi è evidentemente il fatto che la query usata a tal scopo non è in alcun modo sensibile al contesto.

Andiamo quindi a "duplicare" tutto quanto necessario, partendo dall'interfaccia ISitemapView, che per noi sarà ILocalmapView.

Lasciamo che l'implementazione di ILocalmapView deleghi a sua volta la gestione della mappa a un adattatore, che chiameremo localmap_builder_view, e che nella sua realizzazione di base implementerà l'interfaccia ILocalMap.

A questo punto affidiamo anche noi il grosso del lavoro a buildFolderTree, a cui però potremo offrire il nostro queryBuilder, in cui la radice sarà rappresentata dal contesto locale.

Ultimi ritocchi: la strategia di base deve essere identica a quella applicata al portale, per cui lasciamo che valga quanto definito per il portale.

Scorciatoie

La realizzazione di quanto descritto la lasciamo all'esercizio del lettore, piuttosto, per nostro esercizio, ci chiediamo se esiste un modo per ottenere quanto necessario sacrificando un po' di flessibilità e qualche salto “di troppo”. Be', pare di sì :)

Non preoccupandosi di creare delle apposite interfacce per la Localmap, possiamo definire un template localmap.pt esattamente identico a sitemap.pt, facendogli tuttavia usare la nostra vista ContextmapViev, che implementa ISitemapView come segue:

from Acquisition import aq_inner 
from zope.interface import implements 

from Products.Five import BrowserView 
from Products.CMFPlone.browser.interfaces import ISitemapView 
from Products.CMFPlone.browser.navtree import NavtreeQueryBuilder 
from Products.CMFPlone.browser.navtree import SitemapNavtreeStrategy 
from plone.app.layout.navigation.navtree import buildFolderTree 
class ContextmapView(BrowserView):
    implements(ISitemapView) 
    def createSiteMap(self): 
        context = aq_inner(self.context) 
        queryBuilder = ContextmapQueryBuilder(context)
        query = queryBuilder() 
        portal = context.restrictedTraverse(@@plone_portal_state).portal() 
        strategy = SitemapNavtreeStrategy(portal) 
        data = buildFolderTree(context, obj=context, query=query, strategy=strategy) 
        return context.portlet_navtree_macro(children=data.get(children,[]), 
                                             level=1, bottomLevel=2) 
class ContextmapQueryBuilder(NavtreeQueryBuilder): 
    “““Build a folder tree query suitable for a sitemap 
    “““ 

    def __init__(self, context): 
        NavtreeQueryBuilder.__init__(self, context) 
        self.query['path'] = {query : /.join(context.getPhysicalPath()), 
                              depth : 2}

Chiaramente la browser view va configurata in un adeguato file zcml come segue:

<configure
        xmlns=“http://namespaces.zope.org/zope“
        xmlns:browser=“http://namespaces.zope.org/browser“
        i18n_domain=“plone“>
        <browser:page
            for=““
            name=“contextmap_view“
            class=“.contextmap.ContextmapView“
            permission=“zope.Public“
            allowed_interface=“Products.CMFPlone.browser.interfaces.ISitemapView“
            />

    </configure>

 A cosa abbiamo rinunciato?

Prima di tutto a lasciare che il contesto possa adattarsi in qualche modo a gestire come vuole la sua localmap (abbiamo tolto di mezzo il disaccoppiamento offerto alla sitemap da sitemap_builder_view).

Abbiamo poi realizzato il nostro query builder senza preoccuparci di renderlo troppo “sveglio”, facendogli distinguere oggetti per cui ha un senso calcolare una mappa o altro.

Infine abbiamo definito la strategia senza passare da adattamenti di qualche genere, ma generando direttamente quanto necessario usando come contesto il portale... insomma.. direi che non siamo stati troppo a pensare al pianista :)

Ogni commento, miglioramento, implementazione reale che risolve in modo elegante il problema proposto è bene accetto!