☰

jquery.localizationTool.js

jquery.localizationTool

此脚本不应直接安装，它是一个供其他脚本使用的外部库。如果您需要使用该库，请在脚本元属性加入：// @require https://update.cn-greasyfork.org/scripts/403927/808323/jquerylocalizationTooljs.js 

  1. /**
  2.  * @fileOverview Contains the code for jQuery.localizationTool
  3.  * 
  4.  * @author Savio Dimatteo <darksmo@gmail.com>
  5.  */
  6.  
  7. (function($) {
  8.     var _keyboardPressed = false;
  9.  
  10.     var methods = {
  11.         /**
  12.          * Returns the ordinal number corresponding to the given language code,
  13.          * or throws in case the given language code is not defined.
  14.          * NOTE: this method operates on the active languages, therefore
  15.          * $this.data('activeLanguageCodeArray') must be available when the
  16.          * method is called.
  17.          *
  18.          * @name _languageCodeToOrdinal
  19.          * @function
  20.          * @access private
  21.          * @param {string} lanuageCode - the language code to convert to ordinal
  22.          * @returns {number} ordinal - the converted ordinal
  23.          */
  24.         '_languageCodeToOrdinal' : function (languageCode) {
  25.             var $this = this,
  26.                 activeLanguageCodes = $this.data('activeLanguageCodeArray');
  27.  
  28.             var ordinal = $.inArray(languageCode, activeLanguageCodes);
  29.  
  30.             if (ordinal === -1) {
  31.                 $.error('Cannot convert ' + languageCode + ' into an ordinal number');
  32.             }
  33.  
  34.             return ordinal;
  35.         },
  36.         /**
  37.          * Returns the language code corresponding to the given ordinal number.
  38.          * It throws in case the given ordinal number does not correspond to any
  39.          * language code.
  40.          * NOTE: this method operates on the active languages, therefore
  41.          * $this.data('activeLanguageCodeArray') must be available when the
  42.          * method is called.
  43.          *
  44.          * @name _ordinalToLanguageCode
  45.          * @function
  46.          * @access private
  47.          * @param {number} ordinal - the ordinal number to convert into a language code
  48.          * @returns {string} languageCode - the converted language code
  49.          */
  50.         '_ordinalToLanguageCode' : function (ordinal) {
  51.             var $this = this,
  52.                 activeLanguageCodes = $this.data('activeLanguageCodeArray');
  53.  
  54.             if (activeLanguageCodes.length <= ordinal || ordinal < 0) {
  55.                 $.error('Cannot convert ' + ordinal + ' into a language code.');
  56.             }
  57.  
  58.             return activeLanguageCodes[ordinal];
  59.         },
  60.         /**
  61.          * Returns the html representation for the given language code.
  62.          * @name _languageCodeToHtml
  63.          * @function
  64.          * @param {string} languageCode - the language code as defined in the settings object
  65.          */
  66.         '_languageCodeToHtml': function (languageCode) {
  67.             var $this = this,
  68.                 settings = $this.data('settings'),
  69.                 languagesObj = settings.languages,
  70.                 languageDefinitionObj = languagesObj[languageCode];
  71.  
  72.             var htmlClass = '';
  73.             if (languageDefinitionObj.flag.hasOwnProperty('class')) {
  74.                 htmlClass = ' ' + languageDefinitionObj.flag['class'];
  75.             }
  76.  
  77.             var htmlImage = '';
  78.             if (languageDefinitionObj.flag.hasOwnProperty('url')) {
  79.                 htmlImage = '<img src="' + languageDefinitionObj.flag.url + '" />';
  80.             }
  81.  
  82.             var languageName = languageDefinitionObj.language;
  83.             var haveCountry = languageDefinitionObj.hasOwnProperty('country');
  84.  
  85.             /*
  86.              * Build up the html
  87.              */
  88.             var html = [];
  89.  
  90.             html.push('<li class="ltool-language ', languageCode, '">');
  91.  
  92.             if (settings.showFlag) {
  93.                 html.push(
  94.                     '<div class="ltool-language-flag', htmlClass, '"></div>'
  95.                 );
  96.                 html.push(
  97.                     htmlImage
  98.                 );
  99.             }
  100.  
  101.             var interpolatedTemplate = methods._interpolateTemplate.call($this,
  102.                 haveCountry ? languageDefinitionObj.country : undefined,
  103.                 languageName
  104.             );
  105.             html.push(interpolatedTemplate);
  106.             html.push('</li>');
  107.  
  108.             return html.join('');
  109.         },
  110.         /**
  111.          * Interpolates the given country name and language name to the
  112.          * labelTemplate specified in the settings.
  113.          *
  114.          * @param {string} countryName
  115.          *   the country name
  116.          * @param {string} languageName
  117.          *   the language name
  118.          *
  119.          * @returns {string}
  120.          *   the interpolated template
  121.          */
  122.         _interpolateTemplate: function (countryName, languageName) {
  123.             var $this = this,
  124.                 settings = $this.data('settings'),
  125.                 template = settings.labelTemplate,
  126.                 countryReplacement = '',
  127.                 languageReplacement = '',
  128.                 haveCountry = typeof countryName === 'string';
  129.  
  130.             if (settings.showCountry && haveCountry) {
  131.                 countryReplacement = [
  132.                     '<span class="ltool-language-country">',
  133.                     '$1' + countryName.replace(/[$]/g, '&#36;') + '$2',
  134.                     '</span>'
  135.                 ].join('');
  136.             }
  137.             if (settings.showLanguage) {
  138.                 var hasCountryClass = haveCountry ? 'ltool-has-country ' : "";
  139.                 languageReplacement = [
  140.                     '<span class="', hasCountryClass, 'ltool-language-name">',
  141.                     '$1' + languageName.replace(/[$]/g, '&#36;') + '$2' ,
  142.                     '</span>'
  143.                 ].join('');
  144.             }
  145.  
  146.             return '<span class="ltool-language-countryname">' + 
  147.                     template
  148.                         .replace(/{{([^{]*)language([^}]*)}}/g, languageReplacement)
  149.                         .replace(/{{([^{]*)country([^}]*)}}/g, countryReplacement) +
  150.                 '</span>';
  151.         },
  152.         /**
  153.          * Displays the given language in the dropdown menu. 在下拉菜单中显示给定的语言。
  154.          * @name _selectLanguage
  155.          * @function
  156.          * @access private
  157.          * @param {string} languageCode - the language code
  158.          */
  159.         '_selectLanguage': function (languageCode) {
  160.             var $this = this;
  161.  
  162.             $this.find('.ltool-dropdown-label').html(
  163.                 $('.ltool-language.' + languageCode).html()
  164.             );
  165.  
  166.             $this.data('selectedLanguageCode', languageCode);
  167.         },
  168.         /**
  169.          * Initializes the localization tool widget. 初始化本地化工具小部件。
  170.          * @name _initializeWidget
  171.          * @function
  172.          * @access private
  173.          * @param {array} languageCodeArray - the language code array of the languages to be displayed
  174.          */
  175.         '_initializeWidget': function (languageCodeArray) {
  176.  
  177.             var $this = this,
  178.                 settings = $this.data('settings'),
  179.                 languagesObj = settings.languages;
  180.             
  181.             var markupArray = [];
  182.  
  183.             markupArray.push('<span tabindex="0" class="ltool-dropdown-label">Change Language</span><div class="ltool-dropdown-label-arrow"></div>');
  184.             markupArray.push('<ul class="ltool-dropdown-items">');
  185.             var languageCode, i;
  186.             for (i=0;languageCode=languageCodeArray[i++];) {
  187.  
  188.                 if ( languagesObj.hasOwnProperty(languageCode)) {
  189.                     markupArray.push(
  190.                         methods._languageCodeToHtml.call($this, languageCode)
  191.                     );
  192.                 }
  193.                 else {
  194.                     $.error('The language \'' + languageCode + '\' must be defined');
  195.                 }
  196.             }
  197.             markupArray.push('</ul>');
  198.  
  199.             $(markupArray.join('')).appendTo($this);
  200.  
  201.             return $this;
  202.         },
  203.         /**
  204.          * Handles dropdown click event. 处理下拉单击事件。
  205.          * @name _onDropdownClicked
  206.          * @function
  207.          * @access private
  208.          */
  209.         '_onDropdownClicked' : function (/*e*/) {
  210.             var $this = this;
  211.  
  212.             var selectedLanguageCode = $this.data('selectedLanguageCode');
  213.  
  214.             $this.find('.ltool-language').removeClass('ltool-is-selected');
  215.             $this.find('.' + selectedLanguageCode).addClass('ltool-is-selected');
  216.  
  217.             $this.toggleClass('ltool-is-visible');
  218.  
  219.             return $this;
  220.         },
  221.         '_closeDropdown' : function () {
  222.             var $this = this;
  223.  
  224.             $this.removeClass('ltool-is-visible');
  225.         },
  226.         /**
  227.          * Handles mouseout on dropdown items.
  228.          * @name _onMouseout
  229.          * @function
  230.          * @access private
  231.          */
  232.         '_onMouseout': function (e) {
  233.             var $this = this;
  234.  
  235.             if ($this.find(e.relatedTarget).length > 0) {
  236.                 // get rid of the current selected item!
  237.                 $this.find('.ltool-is-selected')
  238.                     .removeClass('ltool-is-selected');
  239.  
  240.                 // we will be over an element of ours
  241.                 e.preventDefault();
  242.                 return $this;
  243.             }
  244.  
  245.             /* We will be over another element that doesn't belong to us */
  246.             $this.removeClass('ltool-is-visible');
  247.         },
  248.         /**
  249.          * Handles user clicks on a certain dropdown item. 处理用户单击某个下拉项。
  250.          * @name _onLanguageSelected
  251.          * @function
  252.          * @param {$element} $item - the jquery item clicked
  253.          * @access private
  254.          */
  255.         '_onLanguageSelected': function ($item) {
  256.             var $this = this;
  257. 			
  258.             // extract language code from the $item
  259.             var languageCode = $item.attr('class')
  260.                 .replace('ltool-language', '')
  261.                 .replace('ltool-is-selected', '')
  262.                 .replace(/ /g, '');
  263. 			
  264. 			//存储当前选择的语言
  265. 			console.log("存储! languageCode: ",languageCode);
  266. 			gc_multiLanguage.saveConfig(languageCode);
  267. 			
  268.             methods._selectLanguage.call($this, languageCode);
  269.             methods._mayTranslate.call($this, languageCode);
  270.         },
  271.         /**
  272.          * Select the language before the current language in the list. 在列表中选择当前语言之前的语言。
  273.          * @name _selectPreviousLanguage
  274.          * @function
  275.          * @access private
  276.          */
  277.         '_selectPreviousLanguage' : function () {
  278.             var $this = this;
  279.  
  280.             var currentLanguageCode = $this.data('selectedLanguageCode');
  281.             var currentLanguageCodeOrdinal = methods._languageCodeToOrdinal.call($this, currentLanguageCode);
  282.  
  283.             if (currentLanguageCodeOrdinal === 0) {
  284.                 return;  // cannot go before the first language
  285.             }
  286.  
  287.             var nextLanguageCode = methods._ordinalToLanguageCode.call($this, currentLanguageCodeOrdinal-1);
  288.  
  289.             // peform the selection
  290.             $this.find('.ltool-is-selected').removeClass('ltool-is-selected');
  291.             methods._selectLanguage.call($this, nextLanguageCode);
  292.             methods._mayTranslate.call($this, nextLanguageCode);
  293.             $this.find('.' + nextLanguageCode).addClass('ltool-is-selected');
  294.  
  295.             return $this;
  296.         },
  297.         /**
  298.          * Select the language after the current language in the list. 选择列表中当前语言之后的语言。
  299.          * @name _selectPreviousLanguage
  300.          * @function
  301.          * @access private
  302.          */
  303.         '_selectNextLanguage' : function () {
  304.             var $this = this,
  305.                 activeLanguageCodes = $this.data('activeLanguageCodeArray');
  306.  
  307.             var currentLanguageCode = $this.data('selectedLanguageCode');
  308.             var currentLanguageCodeOrdinal = methods._languageCodeToOrdinal.call($this, currentLanguageCode);
  309.  
  310.             if (currentLanguageCodeOrdinal + 1 >= activeLanguageCodes.length) {
  311.                 return;
  312.             }
  313.  
  314.             var nextLanguageCode = methods._ordinalToLanguageCode.call($this, currentLanguageCodeOrdinal+1);
  315.  
  316.             // peform the selection
  317.             $this.find('.ltool-is-selected').removeClass('ltool-is-selected');
  318.             methods._selectLanguage.call($this, nextLanguageCode);
  319.             methods._mayTranslate.call($this, nextLanguageCode);
  320.             $this.find('.' + nextLanguageCode).addClass('ltool-is-selected');
  321.  
  322.             return $this;
  323.         },
  324.         /**
  325.          * Handles keydown event
  326.          * @name _onKeydown
  327.          * @function
  328.          * @param {event} e - the keydown event
  329.          * @access private
  330.          */
  331.         '_onKeydown': function (e) {
  332.             var $this = this;
  333.  
  334.             switch (e.keyCode) {
  335.                 case 13: /* enter (open-close menu) */
  336.                     methods._onDropdownClicked.call($this);
  337.                     e.preventDefault();
  338.                     break;
  339.                 case 40: /* down (select next) */
  340.                     methods._selectNextLanguage.call($this);
  341.                     e.preventDefault();
  342.                     break;
  343.                 case 38: /* up (select previous) */
  344.                     methods._selectPreviousLanguage.call($this);
  345.                     e.preventDefault();
  346.                     break;
  347.                 case 27:
  348.                     methods._closeDropdown.call($this);
  349.                     e.preventDefault();
  350.                     break;
  351.             }
  352.  
  353.             return $this;
  354.         },
  355.         /**
  356.          * Binds events to the localization tool widget.
  357.          * @name _bindEvents
  358.          * @function
  359.          * @access private
  360.          */
  361.         '_bindEvents': function () {
  362.             var $this = this;
  363.  
  364.             $this
  365.                 .bind('mousedown.localizationTool', function (e) {
  366.                     _keyboardPressed = false;
  367.                     methods._onKeydown.call($this, e);
  368.                 })
  369.                 .bind('click.localizationTool', function (e) { 
  370.                     methods._onDropdownClicked.call($this, e);
  371.                 })
  372.                 .bind('keydown.localizationTool', function (e){ 
  373.                     _keyboardPressed = true;
  374.                     methods._onKeydown.call($this, e);
  375.                 })
  376.                 .bind('mouseout.localizationTool', function (e) { 
  377.                     methods._onMouseout.call($this, e);
  378.                 })
  379.                 .bind('focusout.localizationTool', function () {
  380.                     if (_keyboardPressed) {
  381.                         methods._closeDropdown.call($this);
  382.                     }
  383.                 });
  384.  
  385.             $this.find('.ltool-language')
  386.                 .bind('click.localizationTool', function (/*e*/) {
  387.                     methods._onLanguageSelected.call($this, $(this));
  388.                 });
  389.  
  390.  
  391.             return $this;
  392.         },
  393.         /**
  394.          * Analizes the input strings object and decomposes its keys in
  395.          * sections: text strings, id strings, class strings, element strings,
  396.          * attribute strings.
  397.          * @name _decomposeStringsForReferenceMapping
  398.          * @function
  399.          * @access private
  400.          * @returns {object} the decomposition object.
  401.          */
  402.         '_decomposeStringsForReferenceMapping' : function () {
  403.             var decompositionObj = {
  404.                 'idStrings' : [],
  405.                 'classStrings' : [],
  406.                 'elementStrings' : [],
  407.                 'textStrings' : [],
  408.                 'attributeStrings' : []
  409.             };
  410.  
  411.             var $this = this,
  412.                 stringsObj = $this.data('settings').strings;
  413.  
  414.             // regexp for attributes matching
  415.             var attrRegexp = new RegExp('^[a-zA-Z-]+?::');
  416.  
  417.             var stringKey;
  418.             for (stringKey in stringsObj) {
  419.                 if (stringsObj.hasOwnProperty(stringKey)) {
  420.                     if (stringKey.match(attrRegexp)) {   // NOTE: check first!
  421.                         decompositionObj.attributeStrings.push(stringKey);
  422.                     } 
  423.                     else if (stringKey.indexOf('id:') === 0) {
  424.                         decompositionObj.idStrings.push(stringKey);
  425.                     }
  426.                     else if (stringKey.indexOf('class:') === 0) {
  427.                         decompositionObj.classStrings.push(stringKey);
  428.                     }
  429.                     else if (stringKey.indexOf('element:') === 0) {
  430.                         decompositionObj.elementStrings.push(stringKey);
  431.                     }
  432.                     else {
  433.                         decompositionObj.textStrings.push(stringKey);
  434.                     }
  435.                 }
  436.             }
  437.  
  438.             return decompositionObj;
  439.         },
  440.         /**
  441.          * Goes through each text node and builds a string reference mapping.
  442.          * It is a mapping (an object) 
  443.          * STRING_IDENTIFIER -> <IS_ATTRIBUTE?, ORIGINAL_HTML, [DOM_NODES]> 
  444.          * used later for the translation. See init method for a
  445.          * reference. The resulting object is stored internally in
  446.          * $this.data('refMappingObj') as refMapping.
  447.          * @name _buildStringReferenceMapping
  448.          * @function
  449.          * @access private
  450.          */
  451.         '_buildStringReferenceMapping': function () {
  452.  
  453.            var $this = this,
  454.                refMapping = {},
  455.                settings = $this.data('settings'),
  456.                stringsObj = settings.strings;
  457.  
  458.            // decompose the initial strings in various bits
  459.            var decompositionObj = methods._decomposeStringsForReferenceMapping.call($this);
  460.  
  461.            /*
  462.             * First go through each id
  463.             */
  464.  
  465.            var idString, i;
  466.            for (i=0; idString = decompositionObj.idStrings[i++];) {
  467.  
  468.                var idStringName = idString.substring('id:'.length);
  469.                var $idNode = $('#' + idStringName);
  470.                var contents = $idNode.contents();
  471.  
  472.                if (settings.ignoreUnmatchedSelectors === true && contents.length === 0) {
  473.                    continue;
  474.                }
  475.  
  476.                if (contents.length !== 1) {
  477.                    $.error(idString + ' must contain exactly one text node, found ' + contents.length + ' instead');
  478.                }
  479.                else if (contents[0].nodeType !== 3) {
  480.                    $.error(idString + ' does not contain a #text node (i.e., type 3)');
  481.                }
  482.                else {
  483.                    // add this to the refMapping
  484.                    refMapping[idString] = {
  485.                        isAttribute : false, // it's an id: selector
  486.                        originalText : $idNode.text(),
  487.                        domNodes : [ $idNode ]
  488.                    };
  489.                }
  490.            }
  491.  
  492.            /*
  493.             * Helper function to not write the same code over again...
  494.             */
  495.            var processMultipleElements = function (prefix, jqueryPrefix, checkForIds, checkForClasses) {
  496.  
  497.                var string;
  498.                var decompositionKeyPrefix = prefix.replace(':','');
  499.                for (i=0; string = decompositionObj[decompositionKeyPrefix + 'Strings'][i++];) {
  500.                    
  501.                    var stringName = string.substring(prefix.length);
  502.  
  503.                    // keeps the text of the first dom node in the loop below
  504.                    var domNodeText;
  505.                    var domNodesArray = [];
  506.                    var allNodeTextsAreEqual = true;
  507.                    domNodeText = undefined;  // note: assigns undefined
  508.  
  509.                    
  510.                    var k=0, node; 
  511.                    NODE:
  512.                    for (; node = $(jqueryPrefix + stringName)[k++];) {
  513.  
  514.                        var $node = $(node);
  515.  
  516.                        if (checkForIds) {
  517.                            var nodeId = $node.attr('id');
  518.                     
  519.                            // skip any node that was previously translated via an id
  520.                            if (typeof nodeId === 'string' && stringsObj.hasOwnProperty('id:' + nodeId)) {
  521.                                continue NODE;
  522.                            }
  523.                        }
  524.  
  525.                        if (checkForClasses) {
  526.                            // skip any node that was previously translated via a class
  527.                            var nodeClasses = $node.attr('class');
  528.  
  529.                            if (typeof nodeClasses === 'string') {
  530.  
  531.                                var nodeClassArray = nodeClasses.split(' '),
  532.                                    nodeClass,
  533.                                    j = 0;
  534.  
  535.                                for(;nodeClass = nodeClassArray[j++];) {
  536.                                    if (typeof nodeClass === 'string' && stringsObj.hasOwnProperty('class:' + nodeClass)) {
  537.                                        continue NODE;
  538.                                    }
  539.                                }
  540.                            }
  541.                        }
  542.  
  543.                        // make sure this node contains only one text content
  544.                        var nodeContents = $node.contents();
  545.                        if (nodeContents.length === 0 || nodeContents.length > 1) {
  546.                            $.error('A \'' +  string + '\' node was found to contain ' + nodeContents.length + ' child nodes. This node must contain exactly one text node!');
  547.  
  548.                            continue;
  549.                        }
  550.  
  551.                        if (nodeContents[0].nodeType !== 3) {
  552.                            $.error('A \'' + string + '\' node does not contain a #text node (i.e., type 3)');
  553.  
  554.                            continue;
  555.                        }
  556.  
  557.                        // this node is pushable at this point...
  558.                        domNodesArray.push($node);
  559.  
  560.                        // also check the text is the same across the nodes considered
  561.                        if (typeof domNodeText === 'undefined') {
  562.                            // ... the first time we store the text of the node
  563.                            domNodeText = $node.text();
  564.                        }
  565.                        else if (domNodeText !== $node.text()) {
  566.                            // ... then we keep checking if the text node is the same
  567.                            allNodeTextsAreEqual = false;
  568.                        }
  569.  
  570.                    } // end for k loop
  571.  
  572.                    // make sure that the remaining classes contain the same text
  573.                    if (!allNodeTextsAreEqual) {
  574.                       $.error('Not all text content of elements with ' + string + ' were found to be \'' + domNodeText + '\'. So these elements will be ignored.');
  575.                    }
  576.                    else {
  577.                        // all good
  578.                        refMapping[string] = {
  579.                            isAttribute : false, // it's a class: or an element: selector
  580.                            originalText : domNodeText,
  581.                            domNodes : domNodesArray
  582.                        };
  583.                    }
  584.                }
  585.  
  586.            }; // end of processMultipleElements
  587.  
  588.  
  589.            /*
  590.             * Then go through classes
  591.             */
  592.            processMultipleElements('class:', '.', true, false);
  593.  
  594.            /*
  595.             * Then go through elements
  596.             */
  597.            processMultipleElements('element:', '', true, true);
  598.  
  599.            /*
  600.             * Time to process the attributes
  601.             */
  602.            var firstSelectorStringRegex = new RegExp('(class|id|element):[^:]');
  603.            var attrString;
  604.            for (i=0; attrString = decompositionObj.attributeStrings[i++];) {
  605.  
  606.  
  607.                 // let's extract the attribute name from the element selector
  608.                 var splitStringArray = attrString.split("::");
  609.                 var attributeString = splitStringArray.shift();
  610.  
  611.  
  612.                 // sanity check on the format
  613.                 if (splitStringArray.length === 0) {
  614.                     $.error('sorry, you need to specify class:, element: or id: selectors in ' + attrString);
  615.                 }
  616.  
  617.                 var selectorString = splitStringArray.join('::');
  618.  
  619.                 if (!splitStringArray[0].match(firstSelectorStringRegex)) {
  620.                     $.error(attrString + "Doesn't look right. Perhaps you've added extra semicolons?");
  621.                 }
  622.  
  623.  
  624.                 // turn selector into jQuery selector
  625.                 selectorString = selectorString.replace('id:', '#');
  626.                 selectorString = selectorString.replace('class:', '.');
  627.                 selectorString = selectorString.replace('element:', '');
  628.  
  629.                 // find DOM nodes
  630.                 var $domNodes = $(selectorString + '[' + attributeString + ']');
  631.                 if ($domNodes.length === 0) {
  632.                     $.error('The selector "' + attrString + '" does not point to an existing DOM element');
  633.                 }
  634.  
  635.  
  636.                 // avoid using Array.prototype.reduce as it's supported in IE9+
  637.                 var j = 0,
  638.                     allSameAttributeValue = true;
  639.  
  640.                 var attributeText = $($domNodes[0]).attr(attributeString);
  641.  
  642.                 var domNodesToAdd = [];
  643.  
  644.                 for (j=0; j<$domNodes.length; j++) {
  645.                     // check the placeholder text is all the same
  646.                     var $dom = $($domNodes[j]);
  647.                     if (attributeText !== $dom.attr(attributeString)) {
  648.                         allSameAttributeValue = false;
  649.                     }
  650.  
  651.                     // also add for later...
  652.                     domNodesToAdd.push($dom);
  653.                 }
  654.                 if (!allSameAttributeValue) {
  655.                     $.error('Not all the attribute values selected via ' + attrString + ' are the same');
  656.                 }
  657.  
  658.                 // now we have everything in place, we just add it to the rest!
  659.                 refMapping[attrString] = {
  660.                     isAttribute : true,  // yes, we are dealing with an attribute here
  661.                     originalText : attributeText,
  662.                     domNodes : domNodesToAdd
  663.                 };
  664.            }
  665.  
  666.  
  667.            /*
  668.             * Finally find the dom nodes associated to any text searched
  669.             */
  670.            var textString;
  671.  
  672.            for (i=0; textString = decompositionObj.textStrings[i++];) {
  673.               // nodes that will contain the text to translate
  674.               var textNodesToAdd = [];
  675.  
  676.               var allParentNodes = $(':contains(' + textString + ')');
  677.               var k, parentNode;
  678.               for (k=0; parentNode = allParentNodes[k++];) {
  679.                   var nodeContents = $(parentNode).contents();
  680.                   if (nodeContents.length === 1 &&
  681.                       nodeContents[0].nodeType === 3) {
  682.  
  683.                       textNodesToAdd.push($(parentNode));
  684.                   }
  685.               }
  686.               if (textNodesToAdd.length > 0) {
  687.                   // all good
  688.                   refMapping[textString] = {
  689.                       isAttribute: false, // no it's just another dom element
  690.                       originalText : textString,
  691.                       domNodes : textNodesToAdd
  692.                   };
  693.               }
  694.            }
  695.  
  696.            $this.data('refMappingObj', refMapping);
  697.  
  698.            return $this;
  699.         },
  700.         /**
  701.          * Calls the user specified callback (if any), then translates the page.
  702.          * If the user returned 'false' in his/her callback, the translation is
  703.          * not performed.
  704.          * @name _mayTranslate
  705.          * @function
  706.          * @access private
  707.          * @param {string} [languageCode] - the language code to translate to
  708.          */
  709.         '_mayTranslate': function (languageCode) {
  710.             var $this = this,
  711.                 settings = $this.data('settings');
  712.  
  713.             if (false !== settings.onLanguageSelected(languageCode)) {
  714.                 methods._translate.call($this, languageCode);
  715.             }
  716.         },
  717.         /**
  718.          * Returns the code of the language currently selected
  719.          * @name getSelectedLanguageCode
  720.          * @function
  721.          * @access public
  722.          * @returns {string} [languageCode] - the language code currently selected
  723.          */
  724.         'getSelectedLanguageCode' : function () {
  725.             var $this = this;
  726.             return $this.data('selectedLanguageCode');
  727.         },
  728.         /**
  729.          * Translates the current page.
  730.          * @name translate
  731.          * @function
  732.          * @access public
  733.          * @param {string} [languageCode] - the language to translate to.
  734.          */
  735.         '_translate': function (languageCode) {
  736.             var $this = this,
  737.                 settings = $this.data('settings'),
  738.                 stringsObj = settings.strings,
  739.                 refMappingObj = $this.data('refMappingObj');
  740.  
  741.             var cssDirection = 'ltr';
  742.             if (typeof languageCode !== 'undefined') {
  743.                 // check if the language code exists actually
  744.                 if (!settings.languages.hasOwnProperty(languageCode)) {
  745.                     $.error('The language code ' + languageCode + ' is not defined');
  746.                     return $this;
  747.                 }
  748.  
  749.                 // check if we are dealing with a right to left language
  750.                 if (settings.languages[languageCode].hasOwnProperty('cssDirection')) {
  751.  
  752.                     cssDirection = settings.languages[languageCode].cssDirection;
  753.                 }
  754.             }
  755.  
  756.             // translate everything according to the reference mapping
  757.             var string;
  758.             for (string in refMappingObj) {
  759.                 if (refMappingObj.hasOwnProperty(string)) {
  760.  
  761.                     // get the translation for this string...
  762.                     var translation;
  763.                     if (typeof languageCode === 'undefined' || languageCode === settings.defaultLanguage) {
  764.                         translation = refMappingObj[string].originalText;
  765.                     }
  766.                     else {
  767.                         translation = stringsObj[string][languageCode];
  768.                     }
  769. 					
  770. 					//console.log("翻译的文本:",translation);
  771. 					//console.log("语言代码:",languageCode);
  772. 					
  773.                     var domNodes = refMappingObj[string].domNodes;
  774.  
  775.                     var $domNode, i;
  776.  
  777.                     // attribute case
  778.                     if (refMappingObj[string].isAttribute === true) {
  779.                         var attributeName = string.split("::", 1)[0];
  780.  
  781.                         for (i=0; $domNode = domNodes[i++];) {
  782.                             $domNode.attr(attributeName, translation);
  783.                             $domNode.css('direction', cssDirection);
  784.                         }
  785.                         
  786.                     }
  787.                     else {
  788.                         // all other cases
  789.                         for (i=0; $domNode = domNodes[i++];) {
  790.                             $domNode.html(translation);
  791.                             $domNode.css('direction', cssDirection);
  792.                         }
  793.                     }
  794.                 }
  795.             }
  796.  
  797.             return $this;
  798.         },
  799.         /**
  800.          * Translates according to the widget configuration programmatically.
  801.          * This is meant to be called by the user. The difference with the
  802.          * private counterpart _translate method is that the language is
  803.          * selected in the widget.
  804.          */
  805.         'translate' : function (languageCode) {
  806.             var $this = this;
  807.  
  808.             methods._translate.call($this, languageCode);
  809.  
  810.             // must also select the language when translating via the public method
  811.             methods._selectLanguage.call($this, languageCode);
  812.  
  813.             return $this;
  814.         },
  815.         /**
  816.          * Destroys the dropdown widget.
  817.          *
  818.          * @name destroy
  819.          * @function
  820.          * @access public
  821.          **/
  822.         'destroy' : function () {
  823.             var $this = this;
  824.  
  825.             // remove all data set with .data()
  826.             $this.removeData();
  827.  
  828.             // unbind events
  829.             $this.unbind('click.localizationTool', function (e) { 
  830.                 methods._onDropdownClicked.call($this, e);
  831.             });
  832.             $this.find('.ltool-language')
  833.                 .unbind('click.localizationTool', function (/*e*/) {
  834.                     methods._onLanguageSelected.call($this, $(this));
  835.                 });
  836.  
  837.             $this
  838.                 .unbind('mouseout.localizationTool', function (e) { 
  839.                     methods._onMouseout.call($this, e);
  840.                 });
  841.  
  842.             // remove markup
  843.             $this.empty();
  844.  
  845.             return $this;
  846.         },
  847.         /**
  848.          * Sorts the given array of countryLanguageCodes by country name.
  849.          * If a language has no name goes to the bottom of the list.
  850.          *
  851.          * @name _sortCountryLanguagesByCountryName
  852.          * @function
  853.          * @access private
  854.          * @param {object} languagesDefinition - the array countryLanguageCodes defined during initialization.
  855.          * @param {array} arrayOfCountryLanguageCodes - the input array countryLanguageCodes.
  856.          * @returns {array} sortedArrayOfCountryLanguageCodes - the sorted array countryLanguageCodes.
  857.          */
  858.         '_sortCountryLanguagesByCountryName': function (languagesDefinition, arrayOfCountryLanguageCodes) {
  859.             return arrayOfCountryLanguageCodes.sort(function (a, b) {
  860.                 if (languagesDefinition[a].hasOwnProperty('country') && languagesDefinition[b].hasOwnProperty('country')) {
  861.                     return languagesDefinition[a].country.localeCompare(
  862.                         languagesDefinition[b].country
  863.                     );
  864.                 }
  865.                 else if (languagesDefinition[a].hasOwnProperty('country')) {
  866.                     return languagesDefinition[a].country.localeCompare(
  867.                         languagesDefinition[b].language
  868.                     );
  869.                 }
  870.                 // else if (languagesDefinition[b].hasOwnProperty('country')) {
  871.                 return languagesDefinition[a].language.localeCompare(
  872.                     languagesDefinition[b].country
  873.                 );
  874.                 // }
  875.             });
  876.         },
  877.         /**
  878.          * Goes through each string defined and extracts the common subset of
  879.          * languages that actually used. The default language is added to this
  880.          * subset a priori. The resulting list is sorted by country name.
  881.          *
  882.          * @name _findSubsetOfUsedLanguages
  883.          * @function
  884.          * @access private
  885.          * @param {object} stringsObj - the strings to translate
  886.          * @returns {array} usedLanguageCodes - an array of country codes sorted based on country names.
  887.          */
  888.         '_findSubsetOfUsedLanguages' : function (stringsObj) {
  889.             var $this = this;
  890.             var string;
  891.             var settings = $this.data('settings');
  892.  
  893.             // build an histogram of all the used languages in strings
  894.             var usedLanguagesHistogram = {};
  895.             var howManyDifferentStrings = 0;
  896.  
  897.             for (string in stringsObj) { 
  898.                 if (stringsObj.hasOwnProperty(string)) {
  899.  
  900.                     var languages = stringsObj[string],
  901.                         language;
  902.  
  903.                     for (language in languages) {
  904.                         if (languages.hasOwnProperty(language)) {
  905.                             if (!usedLanguagesHistogram.hasOwnProperty(language)) {
  906.                                 usedLanguagesHistogram[language] = 0;
  907.                             }
  908.                         }
  909.                         usedLanguagesHistogram[language]++;
  910.                     }
  911.  
  912.                     howManyDifferentStrings++;
  913.                 }
  914.             }
  915.  
  916.             // find languages that are guaranteed to appear in all strings
  917.             var guaranteedLanguages = [],
  918.                 languageCode;
  919.  
  920.             for (languageCode in usedLanguagesHistogram) {
  921.                 if (usedLanguagesHistogram.hasOwnProperty(languageCode) &&
  922.                     usedLanguagesHistogram[languageCode] === howManyDifferentStrings
  923.                 ) {
  924.  
  925.                     guaranteedLanguages.push(languageCode);
  926.                 }
  927.             }
  928.  
  929.             // delete the default language if it's in the guaranteed languages
  930.             var defaultIdx = $.inArray(settings.defaultLanguage, guaranteedLanguages);
  931.             if (defaultIdx > -1) {
  932.                 // delete the default language from the array
  933.                 guaranteedLanguages.splice(defaultIdx, 1);
  934.             }
  935.  
  936.             // add the default language in front
  937.             guaranteedLanguages.unshift(settings.defaultLanguage);
  938.  
  939.             return methods._sortCountryLanguagesByCountryName.call(
  940.                 this,
  941.                 settings.languages,
  942.                 guaranteedLanguages
  943.             );
  944.         },
  945.         /**
  946.          * Initialises the localization tool plugin.
  947.          * @name init
  948.          * @function
  949.          * @param {object} [options] - the user options
  950.          * @access public
  951.          * @returns jqueryObject
  952.          */
  953.         'init' : function(options) {
  954.             // NOTE: "country" is optional
  955.             var knownLanguages = {
  956.                 'en_GB' : {
  957.                     'country' : 'United Kingdom',
  958.                     'language': 'English',
  959.                     'countryTranslated' : 'United Kingdom',
  960.                     'languageTranslated': 'English',
  961.                     'flag': {
  962.                         'class' : 'flag flag-gb'
  963.                     }
  964.                 },
  965.                 'de_DE' : {
  966.                     'country' : 'Germany',
  967.                     'language' : 'German',
  968.                     'countryTranslated' : 'Deutschland',
  969.                     'languageTranslated' : 'Deutsch',
  970.                     'flag' : {
  971.                         'class' : 'flag flag-de'
  972.                     }
  973.                 },
  974.                 'es_ES' : {
  975.                     'country' : 'Spain',
  976.                     'language' : 'Spanish',
  977.                     'countryTranslated': 'España',
  978.                     'languageTranslated' : 'Español',
  979.                     'flag' : {
  980.                         'class' : 'flag flag-es'
  981.                     }
  982.                 },
  983.                 'fr_FR' : {
  984.                     'country' : 'France',
  985.                     'language' : 'French',
  986.                     'countryTranslated' : 'France',
  987.                     'languageTranslated' : 'Français',
  988.                     'flag' : {
  989.                         'class' : 'flag flag-fr'
  990.                     }
  991.                 },
  992.                 'ko_KR' : {
  993.                     'country' : 'Korea, Republic of.',
  994.                     'language' : 'Korean',
  995.                     'countryTranslated' : '대한민국',
  996.                     'languageTranslated' : '한국어',
  997.                     'flag' : {
  998.                         'class' : 'flag flag-kr'
  999.                     }
  1000.                 },
  1001.                 'pt_BR' : {
  1002.                     'country' : 'Brazil',
  1003.                     'language' : 'Portuguese',
  1004.                     'countryTranslated': 'Brasil',
  1005.                     'languageTranslated' : 'Português',
  1006.                     'flag' : {
  1007.                         'class' : 'flag flag-br'
  1008.                     }
  1009.                 },
  1010.                 'en_AU' : {
  1011.                     'country' : 'Australia',
  1012.                     'language' : 'English',
  1013.                     'countryTranslated' : 'Australia',
  1014.                     'languageTranslated' : 'English',
  1015.                     'flag' : {
  1016.                         'class' : 'flag flag-au'
  1017.                     }
  1018.                 },
  1019.                 'en_IN' : {
  1020.                     'country' : 'India',
  1021.                     'language' : 'English',
  1022.                     'countryTranslated': 'India',
  1023.                     'languageTranslated': 'English',
  1024.                     'flag': {
  1025.                         'class' : 'flag flag-in'
  1026.                     }
  1027.                 },
  1028.                 'it_IT' : {
  1029.                     'country' : 'Italy',
  1030.                     'language': 'Italian',
  1031.                     'countryTranslated': 'Italia',
  1032.                     'languageTranslated': 'Italiano',
  1033.                     'flag' : {
  1034.                         'class' : 'flag flag-it'
  1035.                     }
  1036.                 },
  1037.                 'jp_JP' : {
  1038.                     'country' : 'Japan',
  1039.                     'language': 'Japanese',
  1040.                     'countryTranslated': '日本',
  1041.                     'languageTranslated': '日本語',
  1042.                     'flag' : {
  1043.                         'class' : 'flag flag-jp'
  1044.                     }
  1045.                 },
  1046.                 'ar_TN' : {
  1047.                     'country' : 'Tunisia',
  1048.                     'language' : 'Arabic',
  1049.                     'countryTranslated': 'تونس',
  1050.                     'languageTranslated': 'عربي',
  1051.                     'cssDirection': 'rtl',
  1052.                     'flag' : {
  1053.                         'class' : 'flag flag-tn'
  1054.                     }
  1055.                 },
  1056.                 'en_IE' : {
  1057.                     'country': 'Ireland',
  1058.                     'language': 'English',
  1059.                     'countryTranslated': 'Ireland',
  1060.                     'languageTranslated' : 'English',
  1061.                     'flag' : {
  1062.                         'class' : 'flag flag-ie'
  1063.                     }
  1064.                 },
  1065.                 'nl_NL': {
  1066.                     'country' : 'Netherlands',
  1067.                     'language': 'Dutch',
  1068.                     'countryTranslated' : 'Nederland',
  1069.                     'languageTranslated' : 'Nederlands',
  1070.                     'flag' : {
  1071.                         'class' : 'flag flag-nl'
  1072.                     }
  1073.                 },
  1074.                 'zh_CN': {
  1075.                     'country' : 'China',
  1076.                     'language' : 'Simplified Chinese',
  1077.                     'countryTranslated': '中国',
  1078.                     'languageTranslated': '简体中文',
  1079.                     'flag' : {
  1080.                         'class' : 'flag flag-cn'
  1081.                     }
  1082.                 },
  1083.                 'zh_TW': {
  1084.                     'country' : 'Taiwan',
  1085.                     'language' : 'Traditional Chinese',
  1086.                     'countryTranslated': '臺灣',
  1087.                     'languageTranslated': '繁體中文',
  1088.                     'flag' : {
  1089.                         'class' : 'flag flag-tw'
  1090.                     }
  1091.                 },
  1092.                 'fi_FI': {
  1093.                     'country' : 'Finland',
  1094.                     'language' : 'Finnish',
  1095.                     'countryTranslated' : 'Suomi',
  1096.                     'languageTranslated' : 'Suomi',
  1097.                     'flag' : {
  1098.                         'class' : 'flag flag-fi'
  1099.                     }
  1100.                 },
  1101.                 'pt_PT' : {
  1102.                     'country' : 'Portugal',
  1103.                     'language' : 'Portuguese',
  1104.                     'countryTranslated': 'Portugal',
  1105.                     'languageTranslated' : 'Português',
  1106.                     'flag' : {
  1107.                         'class' : 'flag flag-pt'
  1108.                     }
  1109.                 },
  1110.                 'pl_PL': {
  1111.                     'country' : 'Poland',
  1112.                     'language': 'Polish',
  1113.                     'countryTranslated' : 'Polska',
  1114.                     'languageTranslated': 'Polski',
  1115.                     'flag' : {
  1116.                         'class' : 'flag flag-pl'
  1117.                     }
  1118.                 },
  1119.                 'ru_RU': {
  1120.                     'country' : 'Russia',
  1121.                     'language' : 'Russian',
  1122.                     'languageTranslated': 'Русский',
  1123.                     'countryTranslated' : 'Россия',
  1124.                     'flag': {
  1125.                         'class': 'flag flag-ru'
  1126.                     }
  1127.                 },
  1128.                 'hi_IN': {
  1129.                     'country' : 'India',
  1130.                     'language': 'Hindi',
  1131.                     'countryTranslated': 'भारत',
  1132.                     'languageTranslated': 'हिन्द',
  1133.                     'flag': {
  1134.                         'class': 'flag flag-in'
  1135.                     }
  1136.                 },
  1137.                 'ta_IN': {
  1138.                     'country' : 'India',
  1139.                     'language': 'Tamil',
  1140.                     'countryTranslated': 'இந்தியா',
  1141.                     'languageTranslated': 'தமிழ்',
  1142.                     'flag': {
  1143.                         'class': 'flag flag-in'
  1144.                     }
  1145.                 },
  1146.                 'tr_TR': {
  1147.                     'country' : 'Turkey',
  1148.                     'language' : 'Turkish',
  1149.                     'countryTranslated': 'Türkiye',
  1150.                     'languageTranslated': 'Türkçe',
  1151.                     'flag': {
  1152.                         'class': 'flag flag-tr'
  1153.                     }
  1154.                 },
  1155.                 'he_IL': {
  1156.                     'country' : 'Israel',
  1157.                     'language' : 'Hebrew',
  1158.                     'countryTranslated' : 'מדינת ישראל',
  1159.                     'languageTranslated': 'עברית',
  1160.                     'cssDirection': 'rtl',
  1161.                     'flag': {
  1162.                         'class': 'flag flag-il'
  1163.                     }
  1164.                 },
  1165.                 'da_DK' : {
  1166.                     'country' : 'Denmark',
  1167.                     'language' : 'Danish',
  1168.                     'countryTranslated': 'Danmark',
  1169.                     'languageTranslated': 'Dansk',
  1170.                     'flag' : {
  1171.                         'class': 'flag flag-dk'
  1172.                     }
  1173.                 },
  1174.                 'ro_RO': {
  1175.                     'country' : 'Romania',
  1176.                     'language' : 'Romanian',
  1177.                     'countryTranslated': 'România',
  1178.                     'languageTranslated': 'Român',
  1179.                     'flag' : {
  1180.                         'class': 'flag flag-ro'
  1181.                     }
  1182.                 },
  1183.                 'eo' : {
  1184.                     // NOTE: no country
  1185.                     'language' : 'Esperanto',
  1186.                     'languageTranslated' : 'Esperanto',
  1187.                     'flag' : {
  1188.                         'class': 'flag flag-esperanto'
  1189.                     }
  1190.                 }
  1191.             };
  1192.  
  1193.             var settings = $.extend({
  1194.                 'defaultLanguage' : 'en_GB',
  1195.                 /* do not throw error if a selector doesn't match */
  1196.                 'ignoreUnmatchedSelectors': false,
  1197.                 /* show the flag on the widget */
  1198.                 'showFlag' : true,
  1199.                 /* show the language on the widget */
  1200.                 'showLanguage': true,
  1201.                 /* show the country on the widget */
  1202.                 'showCountry': true,
  1203.                 /* format of the language/country label */
  1204.                 'labelTemplate': '{{country}} {{(language)}}',
  1205.                 'languages' : {
  1206.                     /*
  1207.                      * The format here is <country code>_<language code>.
  1208.                      * - list of country codes: http://www.gnu.org/software/gettext/manual/html_node/Country-Codes.html
  1209.                      * - list of language codes: http://www.gnu.org/software/gettext/manual/html_node/Usual-Language-Codes.html#Usual-Language-Codes
  1210.                      */
  1211.                 },
  1212.                 /*
  1213.                  * Strings are provided by the user of the plugin. Each entry
  1214.                  * in the dictionary has the form:
  1215.                  *
  1216.                  * [STRING_IDENTIFIER] : {
  1217.                  *      [LANGUAGE] : [TRANSLATION]
  1218.                  * }
  1219.                  *
  1220.                  * STRING_IDENTIFIER:
  1221.                  *     id:<html-id-name>           OR
  1222.                  *     class:<html-class-name>     OR
  1223.                  *     element:<html-element-name> OR
  1224.                  *     <string>
  1225.                  *
  1226.                  * LANGUAGE: one of the languages defined above (e.g., it_IT)
  1227.                  *
  1228.                  * TRANSLATION: <string>
  1229.                  *
  1230.                  */
  1231.                 'strings' : {},
  1232.                 /*
  1233.                  * A callback called whenever the user selects the language
  1234.                  * from the dropdown menu. If false is returned, the
  1235.                  * translation will not be performed (but just the language
  1236.                  * will be selected from the widget).
  1237.                  *
  1238.                  * The countryLanguageCode is a string representing the
  1239.                  * selected language identifier like 'en_GB'
  1240.                  */
  1241.                 'onLanguageSelected' : function (/*countryLanguageCode*/) { return true; }
  1242.             }, options);
  1243.  
  1244.             // add more languages
  1245.             settings.languages = $.extend(knownLanguages, settings.languages);
  1246.  
  1247.             // check that the default language is defined
  1248.             if (!settings.languages.hasOwnProperty(settings.defaultLanguage)) {
  1249.                 $.error('FATAL: the default language ' + settings.defaultLanguage + ' is not defined in the \'languages\' parameter!');
  1250.             }
  1251.  
  1252.             return this.each(function() {
  1253.                 // save settings
  1254.                 var $this = $(this);
  1255.  
  1256.                 $this.data('settings', settings);
  1257.  
  1258.                 // language codes common to all translations
  1259.                 var activeLanguageCodeArray = methods._findSubsetOfUsedLanguages.call(
  1260.                     $this, settings.strings
  1261.                 );
  1262.                 $this.data('activeLanguageCodeArray', activeLanguageCodeArray);
  1263.  
  1264.                 methods._initializeWidget.call($this, activeLanguageCodeArray);
  1265.  
  1266.                 methods._selectLanguage.call($this, settings.defaultLanguage);
  1267.  
  1268.                 methods._bindEvents.call($this);
  1269.  
  1270.                 methods._buildStringReferenceMapping.call($this);
  1271.             });
  1272.         }
  1273.     };
  1274.  
  1275.     var __name__ = 'localizationTool';
  1276.  
  1277.     /**
  1278.      * jQuery Localization Tool - a jQuery widget to translate web pages
  1279.      *
  1280.      * @memberOf jQuery.fn
  1281.      */
  1282.     $.fn[__name__] = function(method) {
  1283.         /*
  1284.          * Just a router for method calls
  1285.          */
  1286.         if (methods[method]) {
  1287.             if (this.data('initialized') === true) {
  1288.                 // call a method
  1289.                 return methods[method].apply(this,
  1290.                     Array.prototype.slice.call(arguments, 1)
  1291.                 );
  1292.             }
  1293.             else {
  1294.                 throw new Error('method ' + method + ' called on an uninitialized instance of ' + __name__);
  1295.             }
  1296.         }
  1297.         else if (typeof method === 'object' || !method) {
  1298.             // call init, user passed the settings as parameters
  1299.             this.data('initialized', true);
  1300.             return methods.init.apply(this, arguments);
  1301.         }
  1302.         else {
  1303.             $.error('Cannot call method ' + method);
  1304.         }
  1305.     };
  1306. })(jQuery);