☰

jquery.localizationTool.js

jquery.localizationTool

Verze ze dne 23. 05. 2020. Zobrazit nejnovější verzi.

Tento skript by neměl být instalován přímo. Jedná se o knihovnu, kterou by měly jiné skripty využívat pomocí meta příkazu // @require https://update.greatest.deepsurf.us/scripts/403927/808313/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.             methods._selectLanguage.call($this, languageCode);
  265.             methods._mayTranslate.call($this, languageCode);
  266.         },
  267.         /**
  268.          * Select the language before the current language in the list.
  269.          * @name _selectPreviousLanguage
  270.          * @function
  271.          * @access private
  272.          */
  273.         '_selectPreviousLanguage' : function () {
  274.             var $this = this;
  275.  
  276.             var currentLanguageCode = $this.data('selectedLanguageCode');
  277.             var currentLanguageCodeOrdinal = methods._languageCodeToOrdinal.call($this, currentLanguageCode);
  278.  
  279.             if (currentLanguageCodeOrdinal === 0) {
  280.                 return;  // cannot go before the first language
  281.             }
  282.  
  283.             var nextLanguageCode = methods._ordinalToLanguageCode.call($this, currentLanguageCodeOrdinal-1);
  284.  
  285.             // peform the selection
  286.             $this.find('.ltool-is-selected').removeClass('ltool-is-selected');
  287.             methods._selectLanguage.call($this, nextLanguageCode);
  288.             methods._mayTranslate.call($this, nextLanguageCode);
  289.             $this.find('.' + nextLanguageCode).addClass('ltool-is-selected');
  290.  
  291.             return $this;
  292.         },
  293.         /**
  294.          * Select the language after the current language in the list.
  295.          * @name _selectPreviousLanguage
  296.          * @function
  297.          * @access private
  298.          */
  299.         '_selectNextLanguage' : function () {
  300.             var $this = this,
  301.                 activeLanguageCodes = $this.data('activeLanguageCodeArray');
  302.  
  303.             var currentLanguageCode = $this.data('selectedLanguageCode');
  304.             var currentLanguageCodeOrdinal = methods._languageCodeToOrdinal.call($this, currentLanguageCode);
  305.  
  306.             if (currentLanguageCodeOrdinal + 1 >= activeLanguageCodes.length) {
  307.                 return;
  308.             }
  309.  
  310.             var nextLanguageCode = methods._ordinalToLanguageCode.call($this, currentLanguageCodeOrdinal+1);
  311.  
  312.             // peform the selection
  313.             $this.find('.ltool-is-selected').removeClass('ltool-is-selected');
  314.             methods._selectLanguage.call($this, nextLanguageCode);
  315.             methods._mayTranslate.call($this, nextLanguageCode);
  316.             $this.find('.' + nextLanguageCode).addClass('ltool-is-selected');
  317.  
  318.             return $this;
  319.         },
  320.         /**
  321.          * Handles keydown event
  322.          * @name _onKeydown
  323.          * @function
  324.          * @param {event} e - the keydown event
  325.          * @access private
  326.          */
  327.         '_onKeydown': function (e) {
  328.             var $this = this;
  329.  
  330.             switch (e.keyCode) {
  331.                 case 13: /* enter (open-close menu) */
  332.                     methods._onDropdownClicked.call($this);
  333.                     e.preventDefault();
  334.                     break;
  335.                 case 40: /* down (select next) */
  336.                     methods._selectNextLanguage.call($this);
  337.                     e.preventDefault();
  338.                     break;
  339.                 case 38: /* up (select previous) */
  340.                     methods._selectPreviousLanguage.call($this);
  341.                     e.preventDefault();
  342.                     break;
  343.                 case 27:
  344.                     methods._closeDropdown.call($this);
  345.                     e.preventDefault();
  346.                     break;
  347.             }
  348.  
  349.             return $this;
  350.         },
  351.         /**
  352.          * Binds events to the localization tool widget.
  353.          * @name _bindEvents
  354.          * @function
  355.          * @access private
  356.          */
  357.         '_bindEvents': function () {
  358.             var $this = this;
  359.  
  360.             $this
  361.                 .bind('mousedown.localizationTool', function (e) {
  362.                     _keyboardPressed = false;
  363.                     methods._onKeydown.call($this, e);
  364.                 })
  365.                 .bind('click.localizationTool', function (e) { 
  366.                     methods._onDropdownClicked.call($this, e);
  367.                 })
  368.                 .bind('keydown.localizationTool', function (e){ 
  369.                     _keyboardPressed = true;
  370.                     methods._onKeydown.call($this, e);
  371.                 })
  372.                 .bind('mouseout.localizationTool', function (e) { 
  373.                     methods._onMouseout.call($this, e);
  374.                 })
  375.                 .bind('focusout.localizationTool', function () {
  376.                     if (_keyboardPressed) {
  377.                         methods._closeDropdown.call($this);
  378.                     }
  379.                 });
  380.  
  381.             $this.find('.ltool-language')
  382.                 .bind('click.localizationTool', function (/*e*/) {
  383.                     methods._onLanguageSelected.call($this, $(this));
  384.                 });
  385.  
  386.  
  387.             return $this;
  388.         },
  389.         /**
  390.          * Analizes the input strings object and decomposes its keys in
  391.          * sections: text strings, id strings, class strings, element strings,
  392.          * attribute strings.
  393.          * @name _decomposeStringsForReferenceMapping
  394.          * @function
  395.          * @access private
  396.          * @returns {object} the decomposition object.
  397.          */
  398.         '_decomposeStringsForReferenceMapping' : function () {
  399.             var decompositionObj = {
  400.                 'idStrings' : [],
  401.                 'classStrings' : [],
  402.                 'elementStrings' : [],
  403.                 'textStrings' : [],
  404.                 'attributeStrings' : []
  405.             };
  406.  
  407.             var $this = this,
  408.                 stringsObj = $this.data('settings').strings;
  409.  
  410.             // regexp for attributes matching
  411.             var attrRegexp = new RegExp('^[a-zA-Z-]+?::');
  412.  
  413.             var stringKey;
  414.             for (stringKey in stringsObj) {
  415.                 if (stringsObj.hasOwnProperty(stringKey)) {
  416.                     if (stringKey.match(attrRegexp)) {   // NOTE: check first!
  417.                         decompositionObj.attributeStrings.push(stringKey);
  418.                     } 
  419.                     else if (stringKey.indexOf('id:') === 0) {
  420.                         decompositionObj.idStrings.push(stringKey);
  421.                     }
  422.                     else if (stringKey.indexOf('class:') === 0) {
  423.                         decompositionObj.classStrings.push(stringKey);
  424.                     }
  425.                     else if (stringKey.indexOf('element:') === 0) {
  426.                         decompositionObj.elementStrings.push(stringKey);
  427.                     }
  428.                     else {
  429.                         decompositionObj.textStrings.push(stringKey);
  430.                     }
  431.                 }
  432.             }
  433.  
  434.             return decompositionObj;
  435.         },
  436.         /**
  437.          * Goes through each text node and builds a string reference mapping.
  438.          * It is a mapping (an object) 
  439.          * STRING_IDENTIFIER -> <IS_ATTRIBUTE?, ORIGINAL_HTML, [DOM_NODES]> 
  440.          * used later for the translation. See init method for a
  441.          * reference. The resulting object is stored internally in
  442.          * $this.data('refMappingObj') as refMapping.
  443.          * @name _buildStringReferenceMapping
  444.          * @function
  445.          * @access private
  446.          */
  447.         '_buildStringReferenceMapping': function () {
  448.  
  449.            var $this = this,
  450.                refMapping = {},
  451.                settings = $this.data('settings'),
  452.                stringsObj = settings.strings;
  453.  
  454.            // decompose the initial strings in various bits
  455.            var decompositionObj = methods._decomposeStringsForReferenceMapping.call($this);
  456.  
  457.            /*
  458.             * First go through each id
  459.             */
  460.  
  461.            var idString, i;
  462.            for (i=0; idString = decompositionObj.idStrings[i++];) {
  463.  
  464.                var idStringName = idString.substring('id:'.length);
  465.                var $idNode = $('#' + idStringName);
  466.                var contents = $idNode.contents();
  467.  
  468.                if (settings.ignoreUnmatchedSelectors === true && contents.length === 0) {
  469.                    continue;
  470.                }
  471.  
  472.                if (contents.length !== 1) {
  473.                    $.error(idString + ' must contain exactly one text node, found ' + contents.length + ' instead');
  474.                }
  475.                else if (contents[0].nodeType !== 3) {
  476.                    $.error(idString + ' does not contain a #text node (i.e., type 3)');
  477.                }
  478.                else {
  479.                    // add this to the refMapping
  480.                    refMapping[idString] = {
  481.                        isAttribute : false, // it's an id: selector
  482.                        originalText : $idNode.text(),
  483.                        domNodes : [ $idNode ]
  484.                    };
  485.                }
  486.            }
  487.  
  488.            /*
  489.             * Helper function to not write the same code over again...
  490.             */
  491.            var processMultipleElements = function (prefix, jqueryPrefix, checkForIds, checkForClasses) {
  492.  
  493.                var string;
  494.                var decompositionKeyPrefix = prefix.replace(':','');
  495.                for (i=0; string = decompositionObj[decompositionKeyPrefix + 'Strings'][i++];) {
  496.                    
  497.                    var stringName = string.substring(prefix.length);
  498.  
  499.                    // keeps the text of the first dom node in the loop below
  500.                    var domNodeText;
  501.                    var domNodesArray = [];
  502.                    var allNodeTextsAreEqual = true;
  503.                    domNodeText = undefined;  // note: assigns undefined
  504.  
  505.                    
  506.                    var k=0, node; 
  507.                    NODE:
  508.                    for (; node = $(jqueryPrefix + stringName)[k++];) {
  509.  
  510.                        var $node = $(node);
  511.  
  512.                        if (checkForIds) {
  513.                            var nodeId = $node.attr('id');
  514.                     
  515.                            // skip any node that was previously translated via an id
  516.                            if (typeof nodeId === 'string' && stringsObj.hasOwnProperty('id:' + nodeId)) {
  517.                                continue NODE;
  518.                            }
  519.                        }
  520.  
  521.                        if (checkForClasses) {
  522.                            // skip any node that was previously translated via a class
  523.                            var nodeClasses = $node.attr('class');
  524.  
  525.                            if (typeof nodeClasses === 'string') {
  526.  
  527.                                var nodeClassArray = nodeClasses.split(' '),
  528.                                    nodeClass,
  529.                                    j = 0;
  530.  
  531.                                for(;nodeClass = nodeClassArray[j++];) {
  532.                                    if (typeof nodeClass === 'string' && stringsObj.hasOwnProperty('class:' + nodeClass)) {
  533.                                        continue NODE;
  534.                                    }
  535.                                }
  536.                            }
  537.                        }
  538.  
  539.                        // make sure this node contains only one text content
  540.                        var nodeContents = $node.contents();
  541.                        if (nodeContents.length === 0 || nodeContents.length > 1) {
  542.                            $.error('A \'' +  string + '\' node was found to contain ' + nodeContents.length + ' child nodes. This node must contain exactly one text node!');
  543.  
  544.                            continue;
  545.                        }
  546.  
  547.                        if (nodeContents[0].nodeType !== 3) {
  548.                            $.error('A \'' + string + '\' node does not contain a #text node (i.e., type 3)');
  549.  
  550.                            continue;
  551.                        }
  552.  
  553.                        // this node is pushable at this point...
  554.                        domNodesArray.push($node);
  555.  
  556.                        // also check the text is the same across the nodes considered
  557.                        if (typeof domNodeText === 'undefined') {
  558.                            // ... the first time we store the text of the node
  559.                            domNodeText = $node.text();
  560.                        }
  561.                        else if (domNodeText !== $node.text()) {
  562.                            // ... then we keep checking if the text node is the same
  563.                            allNodeTextsAreEqual = false;
  564.                        }
  565.  
  566.                    } // end for k loop
  567.  
  568.                    // make sure that the remaining classes contain the same text
  569.                    if (!allNodeTextsAreEqual) {
  570.                       $.error('Not all text content of elements with ' + string + ' were found to be \'' + domNodeText + '\'. So these elements will be ignored.');
  571.                    }
  572.                    else {
  573.                        // all good
  574.                        refMapping[string] = {
  575.                            isAttribute : false, // it's a class: or an element: selector
  576.                            originalText : domNodeText,
  577.                            domNodes : domNodesArray
  578.                        };
  579.                    }
  580.                }
  581.  
  582.            }; // end of processMultipleElements
  583.  
  584.  
  585.            /*
  586.             * Then go through classes
  587.             */
  588.            processMultipleElements('class:', '.', true, false);
  589.  
  590.            /*
  591.             * Then go through elements
  592.             */
  593.            processMultipleElements('element:', '', true, true);
  594.  
  595.            /*
  596.             * Time to process the attributes
  597.             */
  598.            var firstSelectorStringRegex = new RegExp('(class|id|element):[^:]');
  599.            var attrString;
  600.            for (i=0; attrString = decompositionObj.attributeStrings[i++];) {
  601.  
  602.  
  603.                 // let's extract the attribute name from the element selector
  604.                 var splitStringArray = attrString.split("::");
  605.                 var attributeString = splitStringArray.shift();
  606.  
  607.  
  608.                 // sanity check on the format
  609.                 if (splitStringArray.length === 0) {
  610.                     $.error('sorry, you need to specify class:, element: or id: selectors in ' + attrString);
  611.                 }
  612.  
  613.                 var selectorString = splitStringArray.join('::');
  614.  
  615.                 if (!splitStringArray[0].match(firstSelectorStringRegex)) {
  616.                     $.error(attrString + "Doesn't look right. Perhaps you've added extra semicolons?");
  617.                 }
  618.  
  619.  
  620.                 // turn selector into jQuery selector
  621.                 selectorString = selectorString.replace('id:', '#');
  622.                 selectorString = selectorString.replace('class:', '.');
  623.                 selectorString = selectorString.replace('element:', '');
  624.  
  625.                 // find DOM nodes
  626.                 var $domNodes = $(selectorString + '[' + attributeString + ']');
  627.                 if ($domNodes.length === 0) {
  628.                     $.error('The selector "' + attrString + '" does not point to an existing DOM element');
  629.                 }
  630.  
  631.  
  632.                 // avoid using Array.prototype.reduce as it's supported in IE9+
  633.                 var j = 0,
  634.                     allSameAttributeValue = true;
  635.  
  636.                 var attributeText = $($domNodes[0]).attr(attributeString);
  637.  
  638.                 var domNodesToAdd = [];
  639.  
  640.                 for (j=0; j<$domNodes.length; j++) {
  641.                     // check the placeholder text is all the same
  642.                     var $dom = $($domNodes[j]);
  643.                     if (attributeText !== $dom.attr(attributeString)) {
  644.                         allSameAttributeValue = false;
  645.                     }
  646.  
  647.                     // also add for later...
  648.                     domNodesToAdd.push($dom);
  649.                 }
  650.                 if (!allSameAttributeValue) {
  651.                     $.error('Not all the attribute values selected via ' + attrString + ' are the same');
  652.                 }
  653.  
  654.                 // now we have everything in place, we just add it to the rest!
  655.                 refMapping[attrString] = {
  656.                     isAttribute : true,  // yes, we are dealing with an attribute here
  657.                     originalText : attributeText,
  658.                     domNodes : domNodesToAdd
  659.                 };
  660.            }
  661.  
  662.  
  663.            /*
  664.             * Finally find the dom nodes associated to any text searched
  665.             */
  666.            var textString;
  667.  
  668.            for (i=0; textString = decompositionObj.textStrings[i++];) {
  669.               // nodes that will contain the text to translate
  670.               var textNodesToAdd = [];
  671.  
  672.               var allParentNodes = $(':contains(' + textString + ')');
  673.               var k, parentNode;
  674.               for (k=0; parentNode = allParentNodes[k++];) {
  675.                   var nodeContents = $(parentNode).contents();
  676.                   if (nodeContents.length === 1 &&
  677.                       nodeContents[0].nodeType === 3) {
  678.  
  679.                       textNodesToAdd.push($(parentNode));
  680.                   }
  681.               }
  682.               if (textNodesToAdd.length > 0) {
  683.                   // all good
  684.                   refMapping[textString] = {
  685.                       isAttribute: false, // no it's just another dom element
  686.                       originalText : textString,
  687.                       domNodes : textNodesToAdd
  688.                   };
  689.               }
  690.            }
  691.  
  692.            $this.data('refMappingObj', refMapping);
  693.  
  694.            return $this;
  695.         },
  696.         /**
  697.          * Calls the user specified callback (if any), then translates the page.
  698.          * If the user returned 'false' in his/her callback, the translation is
  699.          * not performed.
  700.          * @name _mayTranslate
  701.          * @function
  702.          * @access private
  703.          * @param {string} [languageCode] - the language code to translate to
  704.          */
  705.         '_mayTranslate': function (languageCode) {
  706.             var $this = this,
  707.                 settings = $this.data('settings');
  708.  
  709.             if (false !== settings.onLanguageSelected(languageCode)) {
  710.                 methods._translate.call($this, languageCode);
  711.             }
  712.         },
  713.         /**
  714.          * Returns the code of the language currently selected
  715.          * @name getSelectedLanguageCode
  716.          * @function
  717.          * @access public
  718.          * @returns {string} [languageCode] - the language code currently selected
  719.          */
  720.         'getSelectedLanguageCode' : function () {
  721.             var $this = this;
  722.             return $this.data('selectedLanguageCode');
  723.         },
  724.         /**
  725.          * Translates the current page.
  726.          * @name translate
  727.          * @function
  728.          * @access public
  729.          * @param {string} [languageCode] - the language to translate to.
  730.          */
  731.         '_translate': function (languageCode) {
  732.             var $this = this,
  733.                 settings = $this.data('settings'),
  734.                 stringsObj = settings.strings,
  735.                 refMappingObj = $this.data('refMappingObj');
  736.  
  737.             var cssDirection = 'ltr';
  738.             if (typeof languageCode !== 'undefined') {
  739.                 // check if the language code exists actually
  740.                 if (!settings.languages.hasOwnProperty(languageCode)) {
  741.                     $.error('The language code ' + languageCode + ' is not defined');
  742.                     return $this;
  743.                 }
  744.  
  745.                 // check if we are dealing with a right to left language
  746.                 if (settings.languages[languageCode].hasOwnProperty('cssDirection')) {
  747.  
  748.                     cssDirection = settings.languages[languageCode].cssDirection;
  749.                 }
  750.             }
  751.  
  752.             // translate everything according to the reference mapping
  753.             var string;
  754.             for (string in refMappingObj) {
  755.                 if (refMappingObj.hasOwnProperty(string)) {
  756.  
  757.                     // get the translation for this string...
  758.                     var translation;
  759.                     if (typeof languageCode === 'undefined' || languageCode === settings.defaultLanguage) {
  760.                         translation = refMappingObj[string].originalText;
  761.                     }
  762.                     else {
  763.                         translation = stringsObj[string][languageCode];
  764.                     }
  765. 					
  766. 					//存储当前选择的语言
  767. 					console.log("translation:",translation);
  768. 					console.log("languageCode:",languageCode);
  769. 					if(gc_multiLanguage){
  770. 						gc_multiLanguage.saveConfig(translation);
  771. 					}
  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);