Python widgets.get_language_config函数代码示例

 def test_default_config(self):
     config = get_language_config()
     config_ok = {
         'spellchecker_languages': '+English=en',
         'directionality': 'ltr',
         'language': 'en',
         'spellchecker_rpc_url': '/tinymce/spellchecker/'
     }
     self.assertEqual(config, config_ok)
     with override(None):
         # Even when no language is activated
         config = get_language_config()
         self.assertEqual(config, config_ok)

    def render(self, name, value, attrs=None):
        if value is None: value = ''
        value = smart_unicode(value)
        final_attrs = self.build_attrs(attrs)
        final_attrs['name'] = name
        assert 'id' in final_attrs, "TinyMCE widget attributes must contain 'id'"
        mce_config = cms.plugins.text.settings.TINYMCE_CONFIG.copy()
        mce_config.update(get_language_config(self.content_language))
        if tinymce.settings.USE_FILEBROWSER:
            mce_config['file_browser_callback'] = "djangoFileBrowser"
        mce_config.update(self.mce_attrs)
        mce_config['mode'] = 'exact'
        mce_config['elements'] = final_attrs['id']
        mce_config['strict_loading_mode'] = 1
        json = simplejson.dumps(mce_config)

        html = [u'<textarea%s>%s</textarea>' % (flatatt(final_attrs), escape(value))]
        if tinymce.settings.USE_COMPRESSOR:
            compressor_config = {
                'plugins': mce_config.get('plugins', ''),
                'themes': mce_config.get('theme', 'advanced'),
                'languages': mce_config.get('language', ''),
                'diskcache': True,
                'debug': False,
                }
            c_json = simplejson.dumps(compressor_config)
            html.append(u'<script type="text/javascript">tinyMCE_GZ.init(%s);</script>' % (c_json))
        html.append(u'<script type="text/javascript">%s;\ntinyMCE.init(%s);</script>' % (
            self.render_additions(name, value, attrs), json))
        return mark_safe(u'\n'.join(html))

 def test_content_language(self):
     config = get_language_config('ru-ru')
     config_ok = {
         'spellchecker_languages': 'English=en',
         'directionality': 'ltr',
         'language': 'en',
         'spellchecker_rpc_url': '/tinymce/spellchecker/'
     }
     self.assertEqual(config, config_ok)

 def test_default_config_rtl(self):
     config = get_language_config()
     config_ok = {
         'spellchecker_languages': '+English=en',
         'directionality': 'rtl',
         'language': 'en',
         'spellchecker_rpc_url': '/tinymce/spellchecker/'
     }
     self.assertEqual(config, config_ok)

def textareas_js(request, name, lang=None):
    """
    Returns a HttpResponse whose content is a Javscript file. The template
    is loaded from 'tinymce/<name>_textareas.js' or
    '<name>/tinymce_textareas.js'. Optionally, the lang argument sets the
    content language.
    """
    template_files = ("tinymce/%s_textareas.js" % name, "%s/tinymce_textareas.js" % name)
    template = loader.select_template(template_files)

    vars = get_language_config(lang)
    vars["content_language"] = lang
    context = RequestContext(request, vars)

    return HttpResponse(template.render(context), content_type="application/x-javascript")

    def render(self, name, value, attrs=None):
        if value is None:
            value = ""
        value = smart_unicode(value)
        final_attrs = self.build_attrs(attrs)
        final_attrs["name"] = name
        assert "id" in final_attrs, "TinyMCE widget attributes must contain 'id'"

        mce_config = tinymce.settings.DEFAULT_CONFIG.copy()

        # remove image plugin
        mce_config = self.remove_plugin(mce_config, "image")

        mce_config.update(get_language_config(self.content_language))
        if tinymce.settings.USE_FILEBROWSER:
            mce_config["file_browser_callback"] = "djangoFileBrowser"
        mce_config.update(self.mce_attrs)
        if not "mode" in mce_config:
            mce_config["mode"] = "exact"
        if mce_config["mode"] == "exact":
            mce_config["elements"] = final_attrs["id"]
        mce_config["strict_loading_mode"] = 1

        # Fix for js functions
        js_functions = {}
        for k in ("paste_preprocess", "paste_postprocess"):
            if k in mce_config:
                js_functions[k] = mce_config[k]
                del mce_config[k]
        mce_json = simplejson.dumps(mce_config)
        for k in js_functions:
            index = mce_json.rfind("}")
            mce_json = mce_json[:index] + ", " + k + ":" + js_functions[k].strip() + mce_json[index:]

        html = [u"<textarea%s>%s</textarea>" % (flatatt(final_attrs), escape(value))]
        if tinymce.settings.USE_COMPRESSOR:
            compressor_config = {
                "plugins": mce_config.get("plugins", ""),
                "themes": mce_config.get("theme", "advanced"),
                "languages": mce_config.get("language", ""),
                "diskcache": True,
                "debug": False,
            }
            compressor_json = simplejson.dumps(compressor_config)
            html.append(u'<script type="text/javascript">tinyMCE_GZ.init(%s)</script>' % compressor_json)
        html.append(u'<script type="text/javascript">tinyMCE.init(%s)</script>' % mce_json)

        return mark_safe(u"\n".join(html))

 def render(self, name, value, attrs=None):
     if value is None: value = ''
     value = smart_unicode(value)
     final_attrs = self.build_attrs(attrs)
     final_attrs['name'] = name
     assert 'id' in final_attrs, "TinyMCE widget attributes must contain 'id'"
     mce_config = cms.plugins.text.settings.TINYMCE_CONFIG.copy()
     mce_config.update(get_language_config(self.content_language))
     if tinymce.settings.USE_FILEBROWSER:
         mce_config['file_browser_callback'] = "djangoFileBrowser"
     mce_config.update(self.mce_attrs)
     mce_config['mode'] = 'exact'
     mce_config['elements'] = final_attrs['id']
     mce_config['strict_loading_mode'] = 1
     plugins = mce_config.get("plugins", "")
     if len(plugins):
         plugins += ","
     plugins += "-cmsplugins"
     mce_config['plugins'] = plugins
     if mce_config['theme'] == "simple":
         mce_config['theme'] = "advanced"
     # Add cmsplugin to first toolbar, if not already present
     all_tools = []
     idx = 0
     while True:
         idx += 1
         buttons = mce_config.get('theme_advanced_buttons%d' % (idx,), None)
         if buttons is None:
             break
         all_tools.extend(buttons.split(','))
     if 'cmsplugins' not in all_tools and 'cmspluginsedit' not in all_tools:
         mce_config['theme_advanced_buttons1_add_before'] = "cmsplugins,cmspluginsedit"
     
     json = simplejson.dumps(mce_config)
     html = [u'<textarea%s>%s</textarea>' % (flatatt(final_attrs), escape(value))]
     if tinymce.settings.USE_COMPRESSOR:
         compressor_config = {
             'plugins': mce_config.get('plugins', ''),
             'themes': mce_config.get('theme', 'advanced'),
             'languages': mce_config.get('language', ''),
             'diskcache': True,
             'debug': False,
         }
         c_json = simplejson.dumps(compressor_config)
         html.append(u'<script type="text/javascript">//<![CDATA[\ntinyMCE_GZ.init(%s);\n//]]></script>' % (c_json))
     html.append(u'<script type="text/javascript">//<![CDATA[\n%s;\ntinyMCE.init(%s);\n//]]></script>' % (self.render_additions(name, value, attrs), json))
     return mark_safe(u'\n'.join(html))

    def render(self, name, value, attrs=None):
        if value is None:
            value = ""
        value = smart_unicode(value)
        final_attrs = self.build_attrs(attrs)
        final_attrs["name"] = name
        assert "id" in final_attrs, "TinyMCE widget attributes must contain 'id'"
        mce_config = cms.plugins.text.settings.TINYMCE_CONFIG.copy()
        mce_config.update(get_language_config(self.content_language))
        if tinymce.settings.USE_FILEBROWSER:
            mce_config["file_browser_callback"] = "djangoFileBrowser"
        mce_config.update(self.mce_attrs)
        mce_config["mode"] = "exact"
        mce_config["elements"] = final_attrs["id"]
        mce_config["strict_loading_mode"] = 1
        plugins = mce_config.get("plugins", "")
        if len(plugins):
            plugins += ","
        plugins += "-cmsplugins"
        mce_config["plugins"] = plugins
        adv2 = mce_config.get("theme_advanced_buttons1", None)
        if adv2 is not None:
            if len(adv2):
                adv2 = "," + adv2
            adv2 = "cmsplugins,cmspluginsedit" + adv2
            mce_config["theme_advanced_buttons1"] = adv2
        json = simplejson.dumps(mce_config)

        html = [u"<textarea%s>%s</textarea>" % (flatatt(final_attrs), escape(value))]
        if tinymce.settings.USE_COMPRESSOR:
            compressor_config = {
                "plugins": mce_config.get("plugins", ""),
                "themes": mce_config.get("theme", "advanced"),
                "languages": mce_config.get("language", ""),
                "diskcache": True,
                "debug": False,
            }
            c_json = simplejson.dumps(compressor_config)
            html.append(u'<script type="text/javascript">tinyMCE_GZ.init(%s);</script>' % (c_json))
        html.append(
            u'<script type="text/javascript">%s;\ntinyMCE.init(%s);</script>'
            % (self.render_additions(name, value, attrs), json)
        )
        return mark_safe(u"\n".join(html))

    def render(self, name, value, attrs=None):
        if value is None: value = ''
        value = smart_unicode(value)
        final_attrs = self.build_attrs(attrs)
        final_attrs['name'] = name
        assert 'id' in final_attrs, "TinyMCE widget attributes must contain 'id'"

        mce_config = tinymce.settings.DEFAULT_CONFIG
        mce_config.update(get_language_config(self.content_language))
        if tinymce.settings.USE_FILEBROWSER:
            mce_config['file_browser_callback'] = "djangoFileBrowser"
        mce_config.update(self.mce_attrs)
        mce_config['mode'] = 'exact'
        mce_config['elements'] = final_attrs['id']
        mce_config['strict_loading_mode'] = 1
        mce_json = simplejson.dumps(mce_config)

        html = [u'<textarea%s>%s</textarea>' % (flatatt(final_attrs), escape(value))]
        if tinymce.settings.USE_COMPRESSOR:
            compressor_config = {
                'plugins': mce_config.get('plugins', ''),
                'themes': mce_config.get('theme', 'advanced'),
                'languages': mce_config.get('language', ''),
                'diskcache': True,
                'debug': False,
            }
            compressor_json = simplejson.dumps(compressor_config)
            
            # Now the trick - instead of ouputting <javascript> tags and initializing when they are rendered, 
            # let's simply put the json string in a hidden div and fetch the info / initialize when the view
            # actually displays them :)
            
            #html.append(u'<script type="text/javascript">tinyMCE_GZ.init(%s)</script>' % compressor_json)
            html.append(u'<div style="visibility:hidden" class="uninitialized-tiny-field" id="hidden_div_%s">%s</div>' % (final_attrs['id'], compressor_json))
        
        #html.append(u'<script type="text/javascript">tinyMCE.init(%s)</script>' % mce_json)
        html.append(r'<div style="visibility:hidden" class="uninitialized-tiny-field" id="hidden_div_%s">%s</div>' % (final_attrs['id'], mce_json))    

        return mark_safe(u'\n'.join(html))

def textareas_js(request, name, lang=None):
    """
    Returns a HttpResponse whose content is a Javscript file. The template
    is loaded from 'tinymce/<name>_textareas.js' or
    '<name>/tinymce_textareas.js'. Optionally, the lang argument sets the
    content language.
    """
    template_files = (
        'tinymce/%s_textareas.js' % name,
        '%s/tinymce_textareas.js' % name,
    )
    try:
        template = loader.select_template(template_files)
    except TemplateDoesNotExist:
        raise Http404("The template couldn't found")

    vars = get_language_config(lang)
    vars['content_language'] = lang
    context = RequestContext(request, vars)

    return HttpResponse(template.render(context),
                        content_type="application/x-javascript")

    def render(self, name, value, attrs=None):
        if value is None:
            value = ''
        value = smart_unicode(value)
        final_attrs = self.build_attrs(attrs)
        final_attrs['name'] = name
        assert 'id' in final_attrs, \
            "TinyMCE widget attributes must contain 'id'"

        mce_config = tinymce.settings.DEFAULT_CONFIG.copy()
        mce_config.update(get_language_config(self.content_language))
        if tinymce.settings.USE_FILEBROWSER:
            mce_config['file_browser_callback'] = "djangoFileBrowser"
        mce_config.update(self.mce_attrs)
        if not 'mode' in mce_config:
            mce_config['mode'] = 'exact'
        if mce_config['mode'] == 'exact':
            mce_config['elements'] = final_attrs['id']
        mce_config['strict_loading_mode'] = 1

        # Fix for js functions
        js_functions = {}
        for k in ('paste_preprocess', 'paste_postprocess', 'setup'):
            if k in mce_config:
                js_functions[k] = mce_config[k]
                del mce_config[k]
        mce_json = simplejson.dumps(mce_config)

        pos = final_attrs['id'].find('__prefix__')
        if pos != -1:
            mce_json = mce_json.replace(
                u'"%s"' % final_attrs['id'], u'elements'
            )

        for k in js_functions:
            index = mce_json.rfind('}')
            mce_json = mce_json[:index] + ', ' + k \
                + ':' + js_functions[k].strip() \
                + mce_json[index:]
        html = [
            u'<textarea%s>%s</textarea>' % (
                flatatt(final_attrs), escape(value)
            )
        ]
        if tinymce.settings.USE_COMPRESSOR:
            compressor_config = {
                'plugins': mce_config.get('plugins', ''),
                'themes': mce_config.get('theme', 'advanced'),
                'languages': mce_config.get('language', ''),
                'diskcache': True,
                'debug': False,
            }
            # pylint: disable=W0612
            compressor_json = simplejson.dumps(compressor_config)

        if pos != -1:
            html.append(u'''<script type="text/javascript">
setTimeout(function () {
    var id = '%s';

    if (typeof(window._tinymce_inited) == 'undefined') {
        window._tinymce_inited = [];
    }

    if (typeof(window._tinymce_inited[id]) == 'undefined') {
        window._tinymce_inited[id] = true;
    } else {
        var elements = id.replace(/__prefix__/, parseInt(document.getElementById('%sTOTAL_FORMS').value) - 1);
        console.log(elements);
        if (document.getElementById(elements)) {
            tinymce.init(%s);
        }
    }
}, 0);
</script>''' % (final_attrs['id'], final_attrs['id'][0:pos], mce_json))
        else:
            html.append(
                u'<script type="text/javascript">'
                'tinyMCE.init(%s)</script>' % mce_json
            )

        return mark_safe(u'\n'.join(html))