☰

jquery.localizationTool.js

jquery.localizationTool

Fra 23.05.2020. Se den seneste versjonen.

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