def getLanguage(self, langs, env):
    envadapter = IUserPreferredLanguages(env)
    userlangs = envadapter.getPreferredLanguages()
    # Always add the template language to the available ones. This allows the
    # template language to be picked without the need for a message catalog
    # for every domain for it to be registered.
    langs = tuple(langs) + TEMPLATE_LANGUAGE
    
    global _cache, _bcache
    l_cache = _cache
    b_cache = _bcache

    notnormalized = [l for l in langs if l not in b_cache]
    if notnormalized:
        l_cache.update(normalize_langs(notnormalized))
        b_cache.update(dict((v, k) for k, v in l_cache.items()))
    
      
    # Prioritize on the user preferred languages.  Return the
    # first user preferred language that the object has available.
    #langs = normalize_langs(langs)
    for lang in userlangs:
        if lang in l_cache:
            return l_cache[lang]
        # If the user asked for a specific variation, but we don't
        # have it available we may serve the most generic one,
        # according to the spec (eg: user asks for ('en-us',
        # 'de'), but we don't have 'en-us', then 'en' is preferred
        # to 'de').
        parts = lang.split('-')
        if len(parts) > 1 and parts[0] in l_cache:
            return l_cache.get(parts[0])
    return None

 def get_homepage_html(self):
     adapter = IUserPreferredLanguages(self.request)
     language = adapter.getPreferredLanguages()[0]
     if language == 'en':
         return self.context['admin'].english_home_html
     else:
         return self.context['admin'].dutch_home_html

    def __call__(self, objectId, instance, *args, **kw):
        lang = IUserPreferredLanguages(instance.request, None)
        if lang is not None:
            lang = lang.getPreferredLanguages()
            if lang:
                return {'request:%s'%self.name: lang[0]}

        return ()

    def __init__(self, request):
        self._send = getUtility(IMessageService).send
        self.request = request

        adapter = IUserPreferredLanguages(self.request)
        languages = adapter.getPreferredLanguages()
        if languages:
            self._language = languages[0]
        else:
            self._language = 'en'

 def today(self):
     today = datetime.date.today()
     adapter = IUserPreferredLanguages(self.request)
     lang = adapter.getPreferredLanguages()[0]
     if lang == 'en':
         month = months[today.month - 1]
         return '%s %s' % (month, today.day)
     else:
         month = maanden[today.month - 1]
         return '%s %s' % (today.day, month)

 def getLanguage(self):
     """
     """
     languages = IUserPreferredLanguages(self.context.REQUEST)
     langs = languages.getPreferredLanguages()
     if langs:
         language = langs[0]
     else:
         plone_props = getToolByName(self.context, 'portal_properties')
         language = plone_props.site_properties.default_language
     language = language.split('-')
     return language[0]

def hour_time_formatter(self, timeobj):
    """uses zope.i18n.locales to determine hour/min format
    """

    #grab locale from request
    languages = IUserPreferredLanguages(self.request)
    langs = languages.getPreferredLanguages()
    if langs:
        parts = (langs[0].split('-') + [None,None])[:3]
    else:
        parts = (None,None,None)
    locale = locales.getLocale(*parts)

    #create formatted hour minute string
    formatter = locale.dates.getFormatter('time', 'short')
    return formatter.format(timeobj)

def negotiate(request):
    """Monkey patch zope.i18n.negotiate not to rely on environment
    variable, and to cache its computation.
    """
    if IRequest.providedBy(request):
        if 'I18N_LANGUAGE' in request.other:
            return request.other['I18N_LANGUAGE']
        adapter = IUserPreferredLanguages(request)
        languages = adapter.getPreferredLanguages()
        if languages:
            language = languages[0]
        else:
            language = 'en'
        request.other['I18N_LANGUAGE'] = language
        return language
    return None

def getLocale(request):
    envadapter = IUserPreferredLanguages(request, None)
    if envadapter is None:
        return None

    langs = envadapter.getPreferredLanguages()
    for httplang in langs:
        parts = (httplang.split('-') + [None, None])[:3]
        try:
            return locales.getLocale(*parts)
        except LoadLocaleError:
            # Just try the next combination
            pass
    else:
        # No combination gave us an existing locale, so use the default,
        # which is guaranteed to exist
        return locales.getLocale(None, None, None)

 def getLanguage(self, langs, env):
     envadapter = IUserPreferredLanguages(env)
     userlangs = envadapter.getPreferredLanguages()
     # Prioritize on the user preferred languages.  Return the
     # first user preferred language that the object has available.
     langs = normalize_langs(langs)
     for lang in userlangs:
         if lang in langs:
             return langs.get(lang)
         # If the user asked for a specific variation, but we don't
         # have it available we may serve the most generic one,
         # according to the spec (eg: user asks for ('en-us',
         # 'de'), but we don't have 'en-us', then 'en' is preferred
         # to 'de').
         parts = lang.split('-')
         if len(parts) > 1 and parts[0] in langs:
             return langs.get(parts[0])
     return None

 def browser_language(self):
     language = 'en'
     pl = IUserPreferredLanguages(self.request)
     if pl is not None:
         languages = pl.getPreferredLanguages()
         for httplang in languages:
             parts = (httplang.split('-') + [None, None])[:3]
             if parts[0] == parts[1]:
                 # Avoid creating a country code for simple languages codes
                 parts = [parts[0], None, None]
             try:
                 locale = locales.getLocale(*parts)
                 language = locale.getLocaleID().replace('_', '-').lower()
                 break
             except LoadLocaleError:
                 # Just try the next combination
                 pass
     return language

    def setupLocale(self):
        envadapter = IUserPreferredLanguages(self, None)
        if envadapter is None:
            self._locale = None
            return

        langs = envadapter.getPreferredLanguages()
        for httplang in langs:
            parts = (httplang.split("-") + [None, None])[:3]
            try:
                self._locale = locales.getLocale(*parts)
                return
            except LoadLocaleError:
                # Just try the next combination
                pass
        else:
            # No combination gave us an existing locale, so use the default,
            # which is guaranteed to exist
            self._locale = locales.getLocale(None, None, None)

    def menu_items(self):
        items = [
            (self.application_url(), _('home')),
            (self.application_url('zoek'), _('zoeken')),
            (self.application_url('personen') + '?beginletter=a', _('bladeren')),
            (self.application_url('about'), _('project')),
        ]

        adapter = IUserPreferredLanguages(self.request)
        lang = adapter.getPreferredLanguages()[0]
        if lang != 'en':
            items += [(self.application_url('blog'), _('blog')),
                    (self.application_url('agenda'), _('agenda')), ]
        items += [
            (self.application_url('links'), _('links')),
            (self.application_url('faq'), _('vragen')),
            (self.application_url('contact'), _('contact')),
        ]
        return items

def getLanguage(self, langs, env):
    envadapter = IUserPreferredLanguages(env)
    userlangs = envadapter.getPreferredLanguages()
    # Always add the template language to the available ones. This allows the
    # template language to be picked without the need for a message catalog
    # for every domain for it to be registered.
    langs = list(langs) + TEMPLATE_LANGUAGE
    # Prioritize on the user preferred languages.  Return the
    # first user preferred language that the object has available.
    langs = normalize_langs(langs)
    for lang in userlangs:
        if lang in langs:
            return langs.get(lang)
        # If the user asked for a specific variation, but we don't
        # have it available we may serve the most generic one,
        # according to the spec (eg: user asks for ('en-us',
        # 'de'), but we don't have 'en-us', then 'en' is preferred
        # to 'de').
        parts = lang.split('-')
        if len(parts) > 1 and parts[0] in langs:
            return langs.get(parts[0])
    return None

    def setupLocale( self, request ):
        # slightly adapted from zope.publisher.http.HTTPRequest.setupLocale
        if getattr( request, 'locale', None) is not None:
            return
        
        envadapter = IUserPreferredLanguages(request, None)
        if envadapter is None:
            request.locale = locales.getLocale(None, None, None)            
            return

        langs = envadapter.getPreferredLanguages()
        for httplang in langs:
            parts = (httplang.split('-') + [None, None])[:3]
            try:
                request.locale = locales.getLocale(*parts)
                return
            except LoadLocaleError:
                # Just try the next combination
                pass
        else:
            # No combination gave us an existing locale, so use the default,
            # which is guaranteed to exist
            request.locale = locales.getLocale(None, None, None)

 def traverse(self, name):
     if name == 'en':
         preferred_languages = IUserPreferredLanguages(self.request)
         preferred_languages.setPreferredLanguages(['en'])
         alsoProvides(self.request, IEnglishRequest)
         return self.context

 def languages(self):
     upl = IUserPreferredLanguages(self.request)
     if ICookieLanguageSelector.providedBy(upl):
         return upl.getLanguageList()
     return None

 def selected_lang(self):
     upl = IUserPreferredLanguages(self.request)
     return upl.getSelectedLanguage()

 def get_current_language(self):
     adapter = IUserPreferredLanguages(self.request)
     return adapter.getPreferredLanguages()[0]

    def setupPortalContent(self, p):
        """
        Import default plone content
        """
        existing = p.objectIds()
        
        wftool = getToolByName(p, "portal_workflow")

        # Figure out the current user preferred language
        language = None
        locale = None
        request = getattr(p, 'REQUEST', None)
        if request is not None:
            pl = IUserPreferredLanguages(request)
            if pl is not None:
                languages = pl.getPreferredLanguages()
                for httplang in languages:
                    parts = (httplang.split('-') + [None, None])[:3]
                    try:
                        locale = locales.getLocale(*parts)
                        break
                    except LoadLocaleError:
                        # Just try the next combination
                        pass
                if len(languages) > 0:
                    language = languages[0]

        # Set the default language of the portal
        if language is not None and locale is not None:
            localeid = locale.getLocaleID()
            base_language = locale.id.language

            # If we get a territory, we enable the combined language codes
            use_combined = False
            if locale.id.territory:
                use_combined = True

            # As we have a sensible language code set now, we disable the
            # start neutral functionality
            tool = getToolByName(p, "portal_languages")
            pprop = getToolByName(p, "portal_properties")
            sheet = pprop.site_properties 

            tool.manage_setLanguageSettings(language,
                [language],
                setUseCombinedLanguageCodes=use_combined,
                startNeutral=False)

            # Enable visible_ids for non-latin scripts

            # See if we have an url normalizer
            normalizer = queryUtility(IURLNormalizer, name=localeid)
            if normalizer is None:
                normalizer = queryUtility(IURLNormalizer, name=base_language)

            # If we get a script other than Latn we enable visible_ids
            if locale.id.script is not None:
                if locale.id.script.lower() != 'latn':
                    sheet.visible_ids = True

            # If we have a normalizer it is safe to disable the visible ids
            if normalizer is not None:
                sheet.visible_ids = False

        # Special handling of the front-page, as we want to translate it
        if 'front-page' in existing:
            fp = p['front-page']
            if wftool.getInfoFor(fp, 'review_state') != 'published':
                wftool.doActionFor(fp, 'publish')

            # Show off presentation mode
            fp.setPresentation(True)

            # Mark as fully created
            fp.unmarkCreationFlag()

            if language is not None:
                util = queryUtility(ITranslationDomain, 'plonefrontpage')
                if util is not None:
                    front_title = util.translate(u'front-title',
                                       target_language=language,
                                       default="Welcome to Plone")
                    front_desc = util.translate(u'front-description',
                                       target_language=language,
                                       default="Congratulations! You have successfully installed Plone.")
                    front_text = util.translate(u'front-text',
                                       target_language=language)
                    fp.setLanguage(language)
                    fp.setTitle(front_title)
                    fp.setDescription(front_desc)
                    if front_text <> u'front-text':
                        fp.setText(front_text)

        # News topic
        if 'news' not in existing:
            news_title = 'News'
            news_desc = 'Site News'
            if language is not None:
                util = queryUtility(ITranslationDomain, 'plonefrontpage')
                if util is not None:
#.........这里部分代码省略.........