first commit

wp-content/plugins/sitepress-multilingual-cms/res/js/taxonomy-translation/views/copy-all-popup-view.js

@@ -0,0 +1,105 @@
+/*globals labels, TaxonomyTranslation, Backbone, WPML_core, jQuery, _ */
+
+(function () {
+	"use strict";
+	
+	TaxonomyTranslation.views.CopyAllPopUpView = Backbone.View.extend({
+
+		tagName: 'div',
+		template: WPML_core[ 'templates/taxonomy-translation/copy-all-popup.html' ],
+		model: TaxonomyTranslation.models.TermRow,
+
+		events: {
+			'click .cancel': 'close',
+			'click .js-copy-all-ok': 'copyAll'
+		},
+		initialize: function () {
+			var self = this;
+			self.dialog = null;
+			return self;
+		},
+
+		render: function () {
+
+			var self = this,
+				trid = self.model.get('trid'),
+				originalLang = self.getOriginalLanguage(),
+				flagUrl = TaxonomyTranslation.data.activeLanguages[ originalLang ].flag,
+				langLabel = TaxonomyTranslation.data.activeLanguages[ originalLang ].label,
+				copyMessage = labels.copyToAllMessage.replace( '%language%', '<img src="' + flagUrl + '"> <strong>' + langLabel + '</strong>' );
+
+			self.$el.html(
+				this.template({
+					trid: trid,
+					lang: originalLang,
+					labels: labels,
+					copyMessage: copyMessage
+				})
+			);
+
+			self.delegateEvents();
+			return self;
+		},
+		open: function ( ) {
+			var self = this,
+				popUpDomEl,
+				trid = self.model.get( 'trid' ),
+				lang = self.getOriginalLanguage();
+				
+			self.render();
+			popUpDomEl = jQuery('#' + trid + '-popup-' + lang);
+			popUpDomEl.append( self.$el );
+				
+			self.dialog = jQuery( '#icl_tt_form_' + trid + '_' + lang );
+			self.dialog.dialog({
+				autoOpen: true,
+				modal: true,
+				minWidth: 600,
+				resizable: false,
+				draggable: false,
+				dialogClass: 'dialog-fixed otgs-ui-dialog'
+			});
+			self.setElement( self.dialog );
+			self.delegateEvents();
+
+		},
+		close: function () {
+			if ( this.dialog ) {
+				this.dialog.dialog( 'close' );
+				this.undelegateEvents();
+				this.remove();
+				this.dialog = null;
+			}
+		},
+		getOriginalLanguage: function () {
+			var trid = this.model.get( 'trid' );
+			return TaxonomyTranslation.classes.taxonomy.getOriginalTerm( trid ).get( 'language_code' );
+		},
+		copyAll: function () {
+
+			var self = this,
+				trid = self.model.get( 'trid' ),
+				originalTerm = TaxonomyTranslation.classes.taxonomy.getOriginalTerm( trid ),
+				name = originalTerm.get( 'name' ),
+				slug = originalTerm.get( 'slug' ),
+				description = originalTerm.get( 'description' ),
+				overwrite = self.$el.find( 'input[name="overwrite"]:checked' ).length > 0;
+				
+			self.$el.find('.js-copy-all-ok').prop( 'disabled', true );
+			self.$el.find('.cancel').prop( 'disabled', true );
+
+			
+			var terms = self.model.get("terms");
+			_.each( terms, function ( term ) {
+				if ( overwrite || term.get( 'name' ) === false ) {
+					term.save( name, slug, description );
+				}
+			});
+
+			self.close();			
+			
+		}
+		
+
+	});
+})(TaxonomyTranslation);

wp-content/plugins/sitepress-multilingual-cms/res/js/taxonomy-translation/views/filter-view.js

@@ -0,0 +1,129 @@
+/*globals TaxonomyTranslation, Backbone, WPML_core, labels, jQuery */
+
+(function () {
+	"use strict";
+	
+	TaxonomyTranslation.views.FilterView = Backbone.View.extend({
+
+		template: WPML_core[ 'templates/taxonomy-translation/filter.html' ],
+		model: TaxonomyTranslation.models.Taxonomy,
+		tag: "div",
+		untranslated: false,
+		parent: 0,
+		lang: 'all',
+		search: '',
+		updatingFilter: false,
+
+		events: {
+			"change #child_of": "updateFilter",
+			"change #status-select": "updateFilter",
+			"change #in-lang": "updateLangFilter",
+			"keyup #tax-search": "updateFilter",
+            "click #tax-apply": "updateTaxHierachy"
+		},
+
+		initialize: function () {
+			this.listenTo(this.model, 'newTaxonomySet', this.render);
+			this.listenTo(this.model, 'syncDataLoaded', this.render);
+			this.listenTo(this.model, 'modeChanged', this.modeChanged);
+			this.listenTo(TaxonomyTranslation.classes.taxonomy, 'syncDataLoaded', this.updateLangFilter);
+		},
+		render: function () {
+			var self = this;
+			
+			if ( ! self.updatingFilter ) {
+				var currentTaxonomy = self.model.get("taxonomy");
+	
+				if (!currentTaxonomy) {
+					return false;
+				} else {
+					currentTaxonomy = TaxonomyTranslation.data.taxonomies[currentTaxonomy];
+				}
+	
+				self.$el.html(self.template({
+					langs: TaxonomyTranslation.data.activeLanguages,
+					taxonomy: currentTaxonomy,
+					parents: self.model.get("parents"),
+					mode: TaxonomyTranslation.mainView.mode
+				}));
+			}
+
+			self.updatingFilter = false;
+			return self;
+		},
+		updateLangFilter: function () {
+			var self = this;
+
+			if (TaxonomyTranslation.mainView.mode === 'sync') {
+				var newLang = self.selectedLang();
+				if (self.lang !== newLang) {
+					self.lang = newLang;
+					self.updatingFilter = true;
+					TaxonomyTranslation.classes.taxonomy.loadSyncData(newLang);
+					TaxonomyTranslation.mainView.showLoadingSpinner();
+				}
+			} else {
+				self.updateFilter();
+			}
+
+			return self;
+		},
+		updateFilter: function () {
+			var self = this;
+
+			var parent = self.$el.find("#child_of").val();
+			self.parent = parent != undefined && parent != -1 ? parent : 0;
+			var untranslated = self.$el.find("#status-select").val();
+			self.untranslated = !!(untranslated != undefined && untranslated == 1);
+			self.setSelectVisibility();
+			var search = self.$el.find("#tax-search").val();
+			self.search = search != undefined && search.length > 1 ? search : 0;
+
+			self.trigger("updatedFilter");
+
+			return self;
+		},
+
+		selectedLang: function(){
+
+			var self = this;
+			var inLangSelect = self.$el.find("#in-lang");
+
+			return inLangSelect.val();
+		},
+		setSelectVisibility: function(){
+			var self = this;
+			var inLangLabel = jQuery('#in-lang-label');
+			var inLangSelect = self.$el.find("#in-lang");
+			if (self.untranslated || TaxonomyTranslation.mainView.mode === 'sync') {
+				var lang = self.selectedLang();
+				self.lang = lang != undefined && lang != 'all' ? lang : 'all';
+				inLangSelect.show();
+				inLangLabel.show();
+			} else {
+				self.lang = 'all';
+				inLangSelect.hide();
+				inLangLabel.hide();
+			}
+
+			return self;
+		},
+		modeChanged: function() {
+			var self = this;
+			if (TaxonomyTranslation.mainView.mode === 'translate') {
+				self.render();
+			}
+		},
+		updateTaxHierachy: function () {
+            var self = this;
+
+            if (TaxonomyTranslation.mainView.mode === 'sync') {
+                TaxonomyTranslation.mainView.model.doSync(self.selectedLang());
+            } else {
+                self.updateLangFilter();
+            }
+
+            return self;
+        }
+	});
+})(TaxonomyTranslation);

wp-content/plugins/sitepress-multilingual-cms/res/js/taxonomy-translation/views/label-popup-view.js

@@ -0,0 +1,148 @@
+(function () {
+	TaxonomyTranslation.views.LabelPopUpView = Backbone.View.extend({
+
+		tagName: "div",
+		template: WPML_core[ 'templates/taxonomy-translation/label-popup.html' ],
+		model: TaxonomyTranslation.models.Taxonomy,
+
+		events: {
+			"click .cancel": "close",
+			"click .js-label-save": "saveLabel",
+			"click .js-button-copy": "copyOriginal",
+			"keydown" : "handleEnter",
+			"input .js-translation": "updateUI"
+		},
+		initialize: function (data, options) {
+			var self = this;
+			self.lang = options.lang;
+			self.defLang = options.defLang;
+			self.listenTo(self.model, 'labelTranslationSaved', self.close);
+			self.listenTo(self.model, 'saveFailed', self.render);
+			return self;
+		},
+
+		open: function ( lang ) {
+			var self = this;
+			self.render();
+			var popUpDomEl = jQuery( '#popup-' + lang );
+			popUpDomEl.append( self.$el );
+				
+			self.dialog = jQuery( "#icl_tt_form_" + self.model.get( "taxonomy" ) );
+			self.dialog.dialog({
+				autoOpen: true,
+				modal: true,
+				minWidth: 800,
+				resizable: false,
+				draggable: false,
+				dialogClass: 'dialog-fixed otgs-ui-dialog'
+			});
+			self.setElement( self.dialog );
+			self.delegateEvents();
+			self.updateUI();
+		},
+		close: function () {
+			if ( this.dialog ) {
+				this.dialog.dialog( 'close' );
+				this.undelegateEvents();
+				this.remove();
+				this.dialog = null;
+			}
+		},
+		render: function () {
+			var self = this;
+			var taxonomy = self.model.get("taxonomy");
+			var labels = TaxonomyTranslation.data.translatedTaxonomyLabels[self.lang];
+			var originalLabels = TaxonomyTranslation.data.translatedTaxonomyLabels[self.model.get('stDefaultLang')];
+			var slugTranslationEnabled = originalLabels['globalSlugTranslationEnabled']
+				&& self.model.get('showSlugTranslationField');
+
+			if (!labels) {
+				labels = {
+					singular: undefined,
+					general: undefined
+				};
+			}
+
+			this.$el.html(
+				self.template({
+					langs: TaxonomyTranslation.data.allLanguages,
+					lang: self.lang,
+					source_lang: self.model.get('stDefaultLang'),
+					originalLabels: originalLabels,
+					translatedLabels: labels,
+					taxonomy: taxonomy,
+					slugTranslationEnabled: slugTranslationEnabled
+				})
+			);
+
+			self.delegateEvents();
+			
+			return self;
+		},
+
+		handleEnter: function(e){
+			var self = this;
+			if(self.$el.find('input:focus').length !== 0 && e.keyCode == 13){
+				self.saveLabel(e);
+			}
+			return self;
+		},
+		
+		updateUI: function ( e ) {
+			var self = this,
+				translationsEntered = true;
+				
+			self.$el.find( '.js-required-translation' ).each( function () {
+				if ( jQuery( this ).val() === '' ) {
+					translationsEntered = false;
+				}
+			});
+			
+			self.$el.find( '.js-label-save' ).prop( 'disabled', !translationsEntered );
+		},
+
+		saveLabel: function (e) {
+			var singularValueField, pluralValueField, slugValueField, singularValue, pluralValue, slugValue, self, inputPrefix;
+			self = this;
+
+			e.preventDefault();
+
+			inputPrefix = '#' + self.model.get("taxonomy") + '-';
+			singularValueField = self.$el.find(inputPrefix + 'singular');
+			pluralValueField = self.$el.find(inputPrefix + 'plural');
+			slugValueField = self.$el.find(inputPrefix + 'slug');
+
+			if (singularValueField.length > 0 && pluralValueField.length > 0) {
+				singularValue = singularValueField.val();
+				pluralValue = pluralValueField.val();
+			}
+
+			if (slugValueField.length > 0) {
+				slugValue = slugValueField.val();
+			}
+
+			if (singularValue && pluralValue) {
+				self.undelegateEvents();
+
+				self.$el.find(".spinner").show();
+				self.$el.find(".js-label-save").prop( 'disabled', true );
+				self.$el.find(".cancel").prop( 'disabled', true );
+
+				self.model.saveLabel(singularValue, pluralValue, slugValue, self.lang);
+
+			}
+
+			return self;
+
+		},
+		
+		copyOriginal: function ( e ) {
+			var self = this,
+				original = jQuery( e.currentTarget ).prev().val();
+			
+			jQuery( e.currentTarget ).next().val( original );
+			
+			self.updateUI();
+		}
+	});
+})(TaxonomyTranslation);

wp-content/plugins/sitepress-multilingual-cms/res/js/taxonomy-translation/views/label-row-view.js

@@ -0,0 +1,108 @@
+(function () {
+
+	TaxonomyTranslation.views.LabelRowView = Backbone.View.extend({
+
+		tagName: 'tbody',
+		model: TaxonomyTranslation.models.Taxonomy,
+		events: {
+			'click .icl_tt_label': 'openPopUPLabel',
+			'click .js-show-lang-selector': 'showLanguageSelector',
+			'change .js-tax-lang-selector': 'changeTaxStringsLanguage'
+		},
+		initialize: function () {
+			var self = this;
+			self.listenTo(self.model, 'labelTranslationSaved', self.render);
+		},
+
+		showLanguageSelector: function(e) {
+			e.preventDefault();
+			this.render( true );
+
+			if ( WPML_Core.SimpleLanguageSelector ) {
+				new WPML_Core.SimpleLanguageSelector();
+			}
+		},
+
+		render: function ( withLangSelector ) {
+			var self = this,
+				taxLabels = TaxonomyTranslation.data.translatedTaxonomyLabels,
+				langs = TaxonomyTranslation.util.langCodes,
+				taxonomy = self.model.get( 'taxonomy' ),
+				labelLang = TaxonomyTranslation.classes.taxonomy.get( 'stDefaultLang' ),
+				langSelector = withLangSelector ? TaxonomyTranslation.data.langSelector : '',
+				html = '<tr>';
+
+			
+			html += WPML_core[ 'templates/taxonomy-translation/original-label.html' ](
+				{
+					taxLabel    : taxLabels[labelLang],
+					flag        : TaxonomyTranslation.data.allLanguages[labelLang].flag,
+					langSelector: langSelector
+				}
+			);
+
+			html += '<td class="wpml-col-languages">';
+			
+			_.each(langs, function(lang, code) {
+				if( ! taxLabels[lang] ) {
+					html += WPML_core[ 'templates/taxonomy-translation/not-translated-label.html' ](
+						{
+							taxonomy: taxonomy,
+							lang    : lang,
+							langs   : TaxonomyTranslation.data.activeLanguages
+						}
+					);
+				} else {
+					if( taxLabels[lang].original ) {
+						html += WPML_core[ 'templates/taxonomy-translation/original-label-disabled.html' ](
+							{
+								lang : lang,
+								langs: TaxonomyTranslation.data.activeLanguages
+							}
+						);
+					} else {
+						html += WPML_core[ 'templates/taxonomy-translation/individual-label.html' ](
+							{
+								taxonomy: taxonomy,
+								lang    : lang,
+								langs   : TaxonomyTranslation.data.activeLanguages
+							}
+						);
+					}
+				}
+			});
+
+			html += '</td>';
+			html += '</tr>';
+			
+			self.$el.html( html );
+
+			self.delegateEvents();
+			return self;
+		},
+		openPopUPLabel: function (e) {
+
+			e.preventDefault();
+
+			var link = e.target.closest( '.icl_tt_label' ),
+				id = jQuery( link ).attr( 'id' ),
+				lang = id.split( '_' ).pop();
+
+			if (TaxonomyTranslation.classes.labelPopUpView && typeof TaxonomyTranslation.classes.labelPopUpView !== 'undefined') {
+				TaxonomyTranslation.classes.labelPopUpView.close();
+			}
+
+			TaxonomyTranslation.classes.labelPopUpView = new TaxonomyTranslation.views.LabelPopUpView({model: TaxonomyTranslation.classes.taxonomy}, {
+				lang: lang,
+				defLang: TaxonomyTranslation.classes.taxonomy.get( 'defaultLang' )
+			});
+			TaxonomyTranslation.classes.labelPopUpView.open( lang );
+		},
+
+		changeTaxStringsLanguage: function(e) {
+			var sourceLang = e.target.value;
+			this.$el.find('.js-tax-lang-selector').prepend( '<span class="spinner is-active">' );
+			this.model.changeTaxStringsLanguage(sourceLang);
+		}
+	});
+}(TaxonomyTranslation));

wp-content/plugins/sitepress-multilingual-cms/res/js/taxonomy-translation/views/nav-view.js

@@ -0,0 +1,73 @@
+(function () {
+	TaxonomyTranslation.views.NavView = Backbone.View.extend({
+
+		template: WPML_core[ 'templates/taxonomy-translation/nav.html' ],
+		model: TaxonomyTranslation.models.taxonomy,
+		events: {
+			"change .current-page": 'goToPage',
+			"click .next-page": 'nextPage',
+			"click .prev-page": 'prevPage',
+			"click .first-page": 'firstPage',
+			"click .last-page": 'lastPage'
+		},
+		initialize: function (data, options) {
+			this.page = 1;
+			this.perPage = options.perPage;
+		},
+		goToPage: function () {
+			var self = this;
+			var currentPageField = jQuery(".current-page");
+			var page = currentPageField.val();
+
+			if (page > 0 && page <= self.pages) {
+				self.page = parseInt(page);
+				self.trigger("newPage");
+			} else {
+				currentPageField.val(self.page);
+			}
+
+			return self;
+		},
+		nextPage: function(){
+			var self = this;
+			self.$el.find('.current-page').val(self.page + 1).change();
+		},
+		prevPage: function(){
+			var self = this;
+			self.$el.find('.current-page').val(self.page - 1).change();
+		},
+		firstPage: function(){
+			var self = this;
+			self.$el.find('.current-page').val(1).change();
+		},
+		lastPage: function(){
+			var self = this;
+			self.$el.find('.current-page').val(self.pages).change();
+		},
+		setCounts: function(){
+			var self = this;
+			var rows = TaxonomyTranslation.data.termRowsCollection.length;
+			var displayedCount = TaxonomyTranslation.mainView.termRowsView.getDisplayCount();
+			rows = displayedCount >= 0 ? displayedCount : rows;
+			rows = rows ? rows : 0;
+			self.rows = rows;
+			self.pages = Math.ceil(rows / self.perPage);
+		},
+		render: function () {
+			var self = this;
+			self.setCounts();
+			if (self.pages > 1) {
+				self.$el.html(self.template({
+					page: self.page,
+					pages: self.pages,
+					items: self.rows
+				}));
+				self.$el.show();
+			} else {
+				self.$el.hide();
+			}
+
+			return self;
+		}
+	});
+})(TaxonomyTranslation);

wp-content/plugins/sitepress-multilingual-cms/res/js/taxonomy-translation/views/original-term-popup-view.js

@@ -0,0 +1,11 @@
+/*globals labels */
+
+(function () {
+	TaxonomyTranslation.views.OriginalTermPopUpView = TaxonomyTranslation.views.TermPopUpView.extend({
+
+		template: WPML_core[ 'templates/taxonomy-translation/original-term-popup.html' ],
+		getMinDialogWidth: function ( ) {
+			return 400;
+		}
+	});
+})(TaxonomyTranslation);

wp-content/plugins/sitepress-multilingual-cms/res/js/taxonomy-translation/views/table-view.js

@@ -0,0 +1,48 @@
+/*globals labels */
+
+(function () {
+	TaxonomyTranslation.views.TableView = Backbone.View.extend({
+
+		template: WPML_core[ 'templates/taxonomy-translation/table.html' ],
+		tag: 'div',
+		termsView: {},
+
+		model: TaxonomyTranslation.models.Taxonomy,
+
+		initialize: function ( data, options ) {
+			this.type = options.type;
+		},
+
+		render: function () {
+
+			if ( ! TaxonomyTranslation.classes.taxonomy.get( "taxonomy" ) ) {
+				return false;
+			}
+
+			var self = this,
+				langs = TaxonomyTranslation.data.activeLanguages,
+				count = self.isTermTable() ? TaxonomyTranslation.data.termRowsCollection.length : 1,
+				tax = self.model.get( 'taxonomy' ),
+				firstColumnHeading = self.isTermTable() ? labels.firstColumnHeading.replace( '%taxonomy%', TaxonomyTranslation.data.taxonomies[ tax ].singularLabel ) : '';
+
+			this.$el.html(self.template({
+				langs: langs,
+				tableType: self.type,
+				count: count,
+				firstColumnHeading: firstColumnHeading,
+				mode: TaxonomyTranslation.mainView.mode
+			}));
+
+			return self;
+		},
+		isTermTable: function () {
+			return this.type === 'terms';
+		},
+		clear: function () {
+
+		}
+
+	});
+})(TaxonomyTranslation);
+
+

wp-content/plugins/sitepress-multilingual-cms/res/js/taxonomy-translation/views/taxonomy-view.js

@@ -0,0 +1,266 @@
+/*globals WPML_core, TaxonomyTranslation, Backbone, labels, jQuery, document */
+
+(function () {
+	"use strict";
+
+	TaxonomyTranslation.views.TaxonomyView = Backbone.View.extend({
+
+		el: "#taxonomy-translation",
+		model: TaxonomyTranslation.models.Taxonomy,
+		tag: "div",
+		termRowsView: {},
+		mode: 'translate',
+		initialMode: 'translate',
+		perPage: 10,
+		events: {
+			"click #term-table-sync-header": "setToSync",
+			"click #term-table-header": "setToTranslate",
+			"click #tax-apply": "doSync"
+		},
+		syncedLabel: labels.hieraAlreadySynced,
+		initialize: function (model, options) {
+			var self = this;
+			self.perPage = jQuery( '#wpml_tt_taxonomy_translation_wrap' ).data( 'items_per_page' );
+			self.initialMode = options.sync === true ? 'sync' : 'translate';
+			self.navView = new TaxonomyTranslation.views.NavView({model: self.model}, {perPage: self.perPage});
+			self.filterView = new TaxonomyTranslation.views.FilterView({model: self.model});
+			self.listenTo(self.filterView, 'updatedFilter', function () {
+				self.navView.page = 1;
+				self.renderRows();
+			});
+			self.termTableView = new TaxonomyTranslation.views.TableView({model: self.model}, {type: "terms"});
+			self.labelTableView = new TaxonomyTranslation.views.TableView({model: self.model}, {type: "labels"});
+			self.termRowsView = new TaxonomyTranslation.views.TermRowsView({collection: TaxonomyTranslation.data.termRowsCollection}, {
+				start: 0,
+				end: self.perPage
+			});
+			self.listenTo(self.model, 'newTaxonomySet', self.renderNewTaxonomy);
+			self.listenTo(self.model, 'syncDataLoaded', self.renderNewTaxonomy);
+
+			return self;
+		},
+		changeMode: function (mode) {
+			var self = this;
+			self.mode = mode === 'translate' || ( mode === 'sync' && self.model.isHierarchical() ) ? mode : 'translate';
+			self.navView.off();
+			self.navView = new TaxonomyTranslation.views.NavView({model: self.model}, {perPage: self.perPage});
+			self.listenTo(self.navView, 'newPage', self.render);
+
+			if (self.mode === "sync") {
+				self.model.loadSyncData(self.filterView.selectedLang());
+			} else {
+				self.renderRows();
+				self.render();
+			}
+			self.model.trigger('modeChanged');
+
+			self.syncedLabel = labels.hieraAlreadySynced;
+			
+			return self;
+		},
+		setToTranslate: function () {
+			var self = this;
+			if (self.mode !== 'translate') {
+				self.changeMode('translate');
+			}
+
+			return self;
+		},
+		setToSync: function () {
+			var self = this;
+			if (self.mode !== 'sync') {
+				self.changeMode('sync');
+				TaxonomyTranslation.mainView.showLoadingSpinner();
+			}
+
+			return self;
+		},
+		setLabels: function () {
+			var self = this,
+				tax = self.model.get("taxonomy"),
+				taxonomyPluralLabel = TaxonomyTranslation.data.taxonomies[tax].label,
+				taxonomySingularLabel = TaxonomyTranslation.data.taxonomies[tax].singularLabel;
+				
+			self.headerTerms = labels.translate.replace( '%taxonomy%', taxonomySingularLabel );
+			self.summaryTerms = labels.summaryTerms.replace( '%taxonomy%', '<strong>' + taxonomyPluralLabel + '</strong>' );
+			self.resultsTruncated = labels.resultsTruncated.replace( '%taxonomy%', '<strong>' + taxonomyPluralLabel + '</strong>' );
+			self.labelSummary = labels.summaryLabels.replace( '%taxonomy%', '<strong>' + taxonomySingularLabel + '</strong>' );
+
+			return self;
+		},
+		renderRows: function () {
+			var self = this;
+			if (TaxonomyTranslation.data.termRowsCollection.length > 0) {
+				self.termRowsView.start = (self.navView.page - 1 ) * self.perPage;
+				self.termRowsView.end = self.termRowsView.start + self.perPage;
+				var termRowsFragment = self.termRowsView.render().el;
+				jQuery("#tax-table-terms").first('tbody').append(termRowsFragment);
+			}
+			self.navView.render();
+
+			return self;
+		},
+		renderNewTaxonomy: function(){
+			var self = this;
+			self.navView.off();
+			self.navView = undefined;
+			self.navView = new TaxonomyTranslation.views.NavView({model: self.model}, {perPage: self.perPage});
+			this.listenTo(this.navView, 'newPage', this.render);
+			self.renderRows();
+			self.render();
+			if (self.initialMode === 'sync') {
+				self.initialMode = false;
+				self.setToSync();
+			}
+			return self;
+		},
+		getMainFragment: function () {
+			var self = this;
+
+			var mainFragment = document.createElement("div"),
+				mainTemplate = WPML_core[ 'templates/taxonomy-translation/taxonomy-main-wrap.html' ],
+				tabsTemplate = WPML_core[ 'templates/taxonomy-translation/tabs.html' ],
+				taxonomy = TaxonomyTranslation.data.taxonomies[ self.model.get( "taxonomy" ) ],
+				htmlTabs = tabsTemplate( {
+					taxonomy: taxonomy,
+					headerTerms: self.headerTerms,
+					syncLabel: labels.Synchronize,
+					mode: self.mode
+				}),
+				hasContent = self.termRowsView && self.termRowsView.getDisplayCount() !== 0,
+				htmlMain = mainTemplate({
+					taxonomy: taxonomy,
+					langs: TaxonomyTranslation.data.activeLanguages,
+					summaryTerms: self.summaryTerms,
+					resultsTruncated: self.resultsTruncated,
+					labelSummary: self.labelSummary,
+					mode: self.mode,
+					hasContent: hasContent,
+					labelSynced: self.syncedLabel
+				});
+
+			mainFragment.innerHTML = htmlTabs + htmlMain;
+
+			mainFragment = self.addMainElements( mainFragment, hasContent );
+
+			return mainFragment;
+		},
+		addMainElements: function ( mainFragment, hasContent ) {
+			var self = this;
+			self.filterFragment = self.filterFragment ? self.filterFragment : self.filterView.render().el;
+			mainFragment.querySelector("#wpml-taxonomy-translation-filters").appendChild(self.filterFragment);
+			if ( hasContent || self.mode === 'translate' ) {
+				var termTableFragment = self.termTableView.render().el;
+				mainFragment.querySelector("#wpml-taxonomy-translation-terms-table").appendChild(termTableFragment);
+				mainFragment = self.addTableRows(mainFragment);
+			}
+
+			var bottomContent = self.model.get( "bottomContent" );
+			if( typeof bottomContent != 'undefined' ){
+				mainFragment.appendChild( jQuery( bottomContent )[0] );
+			}
+
+			return mainFragment;
+		},
+		render: function () {
+			var self = this;
+
+			self.setLabels();
+			var renderedFragment = document.createDocumentFragment();
+			var mainFragment = self.getMainFragment();
+			renderedFragment.appendChild(mainFragment);
+
+			if (TaxonomyTranslation.data.termRowsCollection.length > self.perPage &&
+					renderedFragment.querySelector("#wpml-taxonomy-translation-terms-nav")) {
+				var navFragment = self.navView.render().el;
+				renderedFragment.querySelector("#wpml-taxonomy-translation-terms-nav").appendChild(navFragment);
+			}
+			self.addLabelTranslation(mainFragment, renderedFragment);
+			self.$el.html(renderedFragment);
+			jQuery(".icl_tt_label").on("click", self.openPopUPLabel);
+			self.showLoadingSpinner( false );
+			self.isRendered = true;
+			self.filterView.delegateEvents();
+			self.delegateEvents();
+			self.maybeHideHeader();
+			jQuery('.icl_tt_main_bottom').show();
+
+			var loading = jQuery( '.wpml-loading-taxonomy' );
+			if ( loading.length ) {
+				loading.hide();
+				var loaded = jQuery( '.wpml_taxonomy_loaded' );
+				if ( loaded.length ) {
+					loaded.show();
+					loaded.parent().children( '.wpml-loading-taxonomy' ).remove();
+				}
+				
+			}
+			
+			return self;
+		},
+		addLabelTranslation: function (mainFragment, renderedFragment) {
+			var self = this;
+
+			if (TaxonomyTranslation.data.translatedTaxonomyLabels && self.mode !== 'sync') {
+				var labelTableFragment = self.labelTableView.render().el;
+				mainFragment.querySelector("#wpml-taxonomy-translation-labels-table").appendChild(labelTableFragment);
+				if (renderedFragment.querySelector("#tax-table-labels")) {
+					var labelRowFragment = new TaxonomyTranslation.views.LabelRowView(({model: self.model})).render().el;
+					mainFragment.querySelector("#tax-table-labels").appendChild(labelRowFragment);
+				}
+			}
+
+			return mainFragment;
+		},
+		addTableRows: function (mainFragment) {
+			var self = this;
+			var termRowsFragment;
+
+			self.termRowsView.start = (self.navView.page - 1 ) * self.perPage;
+			self.termRowsView.end = self.termRowsView.start + self.perPage;
+			termRowsFragment = self.termRowsView.render().el;
+			mainFragment.querySelector("#tax-table-terms").appendChild(termRowsFragment);
+
+			return mainFragment;
+		},
+		/**
+		 * Used by WCML to hide the controls for changing the taxonomy
+		 */
+		maybeHideHeader: function () {
+			var taxonomySwitcher = jQuery("#icl_tt_tax_switch");
+			var potentialHiddenSelectInput = jQuery('#tax-selector-hidden');
+			var potentialHiddenTaxInput = jQuery('#tax-preselected');
+			if (potentialHiddenSelectInput.length !== 0 &&
+					potentialHiddenSelectInput.val() &&
+					potentialHiddenTaxInput.length !== 0 &&
+					potentialHiddenTaxInput.val()) {
+				taxonomySwitcher.closest('label').hide();
+				jQuery('[id="term-table-summary"]').hide();
+			}
+		},
+		selectTaxonomy: function () {
+			var self = this,
+				tax = jQuery("#icl_tt_tax_switch").val();
+				
+			if (tax !== undefined) {
+				self.mode = 'translate';
+				self.model.setTaxonomy(tax);
+			}
+		},
+		doSync: function () {
+			var self = this;
+			
+			self.$el.find( '#tax-apply' ).prop( 'disabled', true );
+			TaxonomyTranslation.mainView.model.doSync( self.$el.find("#in-lang").val() );
+			self.syncedLabel = labels.hieraSynced;
+		},
+		showLoadingSpinner: function( state ) {
+			if ( state === undefined || state ) {
+				jQuery('.wpml-loading-taxonomy').show();
+			} else {
+				jQuery('.wpml-loading-taxonomy').hide();
+			}
+		}
+
+	});
+})(TaxonomyTranslation);

wp-content/plugins/sitepress-multilingual-cms/res/js/taxonomy-translation/views/term-original-view.js

@@ -0,0 +1,30 @@
+/*globals labels */
+
+(function () {
+
+	TaxonomyTranslation.views.TermOriginalView = TaxonomyTranslation.views.TermView.extend({
+
+		tagName: "td",
+		className: "wpml-col-title wpml-col-title-flag",
+		template: WPML_core[ 'templates/taxonomy-translation/original-term.html' ],
+		render: function () {
+			var self = this;
+
+			self.needsCorrection = false;
+
+			self.$el.html(
+				self.template({
+					trid: self.model.get("trid"),
+					lang: self.model.get("language_code"),
+					name: self.model.get("name"),
+					level: self.model.get("level"),
+					correctedLevel: self.model.get("level"),
+					langs: TaxonomyTranslation.data.activeLanguages
+				})
+			);
+
+			self.delegateEvents();
+			return self;
+		}
+	});
+})(TaxonomyTranslation);

wp-content/plugins/sitepress-multilingual-cms/res/js/taxonomy-translation/views/term-popup-view.js

@@ -0,0 +1,156 @@
+/*globals labels */
+
+(function () {
+	TaxonomyTranslation.views.TermPopUpView = Backbone.View.extend({
+
+		tagName: 'div',
+		template: WPML_core[ 'templates/taxonomy-translation/term-popup.html' ],
+		model: TaxonomyTranslation.models.Term,
+
+		events: {
+			'click .cancel': 'close',
+			'click .term-save': 'saveTerm',
+			'click .js-button-copy': 'copyOriginal',
+			'keydown': 'handleEnter',
+			'input #term-name': 'updateUI',
+            'focusout input#term-name': 'generateSlug'
+		},
+		initialize: function () {
+			var self = this;
+			self.listenTo(self.model, 'translationSaved', self.close);
+			self.listenTo(self.model, 'saveFailed', self.render);
+			self.dialog = null;
+			return self;
+		},
+
+		render: function () {
+
+			var self = this,
+				trid = self.model.get('trid'),
+				term = self.model.getNameSlugAndDescription(),
+				term_meta = self.model.getMetaData(),
+				original_term_meta = TaxonomyTranslation.classes.taxonomy.getOriginalTermMeta( trid ),
+				original_term = TaxonomyTranslation.classes.taxonomy.getOriginalTerm( trid );
+
+			self.$el.html(
+				this.template({
+					trid: trid,
+					lang: self.model.get('language_code'),
+					source_lang: original_term.get( 'language_code' ),
+					langs: TaxonomyTranslation.data.activeLanguages,
+					ttid: self.model.get('term_taxonomy_id'),
+					term: term,
+					original_term: original_term.getNameSlugAndDescription(),
+					term_meta: term_meta,
+					original_term_meta: original_term_meta
+				})
+			);
+
+			self.delegateEvents();
+			return self;
+		},
+		handleEnter: function (e) {
+			var self = this;
+			if (self.$el.find('input:focus').length !== 0 && e.keyCode == 13) {
+				self.saveTerm(e);
+			}
+			return self;
+		},
+		saveTerm: function (e) {
+			var self = this,
+				meta_data = {};
+
+			self.undelegateEvents();
+
+			e.preventDefault();
+			var name = self.$el.find('#term-name').val(),
+				slug = self.$el.find('#term-slug').val(),
+				description = self.$el.find('#term-description').val();
+
+
+			var term_metas = self.$el.find('.term-meta');
+			_.each( term_metas, function ( meta_object ) {
+				meta_data[ meta_object.dataset.metaKey ] = meta_object.value;
+			});
+
+			if (name) {
+				self.$el.find('.spinner').show();
+				self.$el.find('.term-save').prop( 'disabled', true );
+				self.$el.find('.cancel').prop( 'disabled', true );
+				self.model.save(name, slug, description, meta_data);
+			}
+
+			return self;
+		},
+		open: function ( trid, lang ) {
+			var self = this;
+			self.render();
+			var popUpDomEl = jQuery('#' + trid + '-popup-' + lang);
+			popUpDomEl.append( self.$el );
+				
+			self.dialog = jQuery( '#icl_tt_form_' + trid + '_' + lang );
+			self.dialog.dialog({
+				autoOpen: true,
+				modal: true,
+				minWidth: self.getMinDialogWidth(),
+				resizable: false,
+				draggable: false,
+				dialogClass: 'dialog-fixed otgs-ui-dialog'
+			});
+			self.setElement( self.dialog );
+			self.delegateEvents();
+			self.updateUI();
+
+		},
+		getMinDialogWidth: function ( ) {
+			return 800;
+		},
+		close: function () {
+			if ( this.dialog ) {
+				this.dialog.dialog( 'close' );
+				this.undelegateEvents();
+				this.remove();
+				this.dialog = null;
+			}
+		},
+		copyOriginal: function ( e ) {
+			var self = this,
+				original = jQuery( e.currentTarget ).prev().val();
+			jQuery( e.currentTarget ).next().val( original );
+			self.generateSlug();
+			self.updateUI();
+		},
+		updateUI: function ( ) {
+			var self = this;
+			self.$el.find( '.term-save' ).prop( 'disabled', self.$el.find( '#term-name').val() === '' );
+		},
+		generateSlug: function() {
+            var self = this,
+				term_slug = self.$el.find( '#term-slug' ),
+				term_name = self.$el.find( '#term-name' );
+            if ('' === term_slug.val() && '' !== term_name.val()) {
+                term_slug.prop('disabled', true);
+                term_slug.css('background', 'url(' + window.icl_ajxloaderimg_src + ') no-repeat left center');
+                jQuery.ajax({
+                    url: ajaxurl,
+                    type: "POST",
+                    data: {
+                        action: 'wpml_generate_term_slug',
+                        term: term_name.val(),
+                        nonce: labels.wpml_generate_unique_slug_nonce,
+                        language_code: self.model.get('language_code'),
+                        taxonomy: TaxonomyTranslation.classes.taxonomy.get("taxonomy"),
+                    },
+                    success: function(response) {
+                    	if( true === response.success ) {
+                            term_slug.val( response.data.slug );
+                        }
+                        term_slug.prop('disabled', false);
+                        term_slug.css('background', '');
+                    }
+                });
+            }
+		}
+
+	});
+})(TaxonomyTranslation);

wp-content/plugins/sitepress-multilingual-cms/res/js/taxonomy-translation/views/term-row-view.js

@@ -0,0 +1,100 @@
+/*globals _, TaxonomyTranslation, document, Backbone, jQuery */
+
+(function () {
+	"use strict";
+
+	TaxonomyTranslation.views.TermRowView = Backbone.View.extend({
+
+		tagName: "tr",
+		model: TaxonomyTranslation.models.TermRow,
+		termViews: {},
+		className: '',
+		events: {
+			'click .js-copy-to-all-langs': 'copyToAllLangs'
+		},
+
+		initialize: function () {
+			var self = this;
+
+			self.listenTo(TaxonomyTranslation.classes.taxonomy, 'syncDataLoaded', self.maybeHide);
+		},
+		maybeHide: function () {
+			var self = this;
+			var visible = false;
+			var terms = self.model.get("terms");
+			_.each(TaxonomyTranslation.data.syncData, function (correction) {
+				_.each(terms, function (term) {
+					if (correction.translated_id == term.get("term_taxonomy_id")) {
+						visible = true;
+					}
+				});
+			});
+			if (visible) {
+				self.$el.show();
+			} else {
+				self.$el.hide();
+			}
+		},
+
+		render: function () {
+			var termsFragments = {};
+			var self  = this;
+			var langs = TaxonomyTranslation.util.langCodes;
+			var terms = self.model.get("terms");
+			var originalTerm = null;
+			
+			_.each(langs, function (lang) {
+				var term = terms[lang];
+				if (term === undefined) {
+					term = new TaxonomyTranslation.models.Term({language_code: lang, trid: self.model.get("trid")});
+					terms[lang] = term;
+					self.model.set("terms", terms, {silent: true});
+				}
+				if ( term.isOriginal() ) {
+					originalTerm = term;
+				}
+				var newView = new TaxonomyTranslation.views.TermView({model: term});
+				self.termViews[lang] = newView;
+				if (TaxonomyTranslation.mainView.mode === 'sync') {
+					termsFragments[lang] = newView.loadSyncData().el;
+				} else {
+					termsFragments[lang] = newView.render().el;
+				}
+			});
+
+			if ( originalTerm ) {
+				var newRowFragment = document.createDocumentFragment();
+	
+				if ( TaxonomyTranslation.mainView.mode !== 'sync' ) {
+					var originalView = new TaxonomyTranslation.views.TermOriginalView({model: originalTerm });
+					newRowFragment.appendChild( originalView.render().el );
+				
+					var newRowLangs = document.createElement( 'td' );
+					jQuery( newRowLangs ).addClass( 'wpml-col-languages' );
+					_.each(langs, function(lang){
+						newRowLangs.appendChild(termsFragments[lang]);
+					});
+		
+					newRowFragment.appendChild( newRowLangs );
+				} else {
+					_.each(langs, function(lang){
+						var newRowTD = document.createElement( 'td' );
+						newRowTD.appendChild(termsFragments[lang]);
+						newRowFragment.appendChild( newRowTD );
+					});
+				}
+				self.$el.html(newRowFragment);
+			}
+			
+			return self;
+
+		},
+		copyToAllLangs: function () {
+			var self = this;
+			TaxonomyTranslation.classes.copyAllPopUpView = new TaxonomyTranslation.views.CopyAllPopUpView( { model: self.model } );
+			TaxonomyTranslation.classes.copyAllPopUpView.open( );
+			
+		}
+	});
+}(TaxonomyTranslation));
+

wp-content/plugins/sitepress-multilingual-cms/res/js/taxonomy-translation/views/term-rows-view.js

@@ -0,0 +1,113 @@
+(function () {
+	TaxonomyTranslation.views.TermRowsView = Backbone.View.extend({
+
+		tagName: 'tbody',
+		collection: TaxonomyTranslation.data.termRowsCollection,
+		rowViews: [],
+		start: 0,
+		end: 10,
+		count: -1,
+		initialize: function (data, options) {
+			var self = this;
+			self.end = options.end;
+			self.start = options.start;
+		},
+		getDisplayedRows: function () {
+			var self = this;
+			var displayedRows = self.collection;
+
+			if (!displayedRows) {
+				self.count = -1;
+				return false;
+			}
+
+			if (TaxonomyTranslation.mainView.mode === 'sync') {
+				displayedRows = displayedRows.filter(function (row) {
+					"use strict";
+					return row.unSyncFilter();
+				});
+			}
+
+			var parentFilter = TaxonomyTranslation.mainView.filterView.parent ? TaxonomyTranslation.mainView.filterView.parent : false;
+
+			if (parentFilter) {
+				displayedRows = displayedRows.filter(function (row) {
+					return row.parentOf(parentFilter);
+				});
+			}
+
+			var untranslatedFilter = TaxonomyTranslation.mainView.filterView.untranslated ? TaxonomyTranslation.mainView.filterView.untranslated : false;
+
+			if (untranslatedFilter) {
+				displayedRows = displayedRows.filter(function (row) {
+					return !row.allTermsTranslated();
+				});
+			}
+
+			var langFilter = TaxonomyTranslation.mainView.filterView.lang && TaxonomyTranslation.mainView.filterView.lang !== 'all' ? TaxonomyTranslation.mainView.filterView.lang : false;
+
+			if (langFilter && langFilter != 'all' && (untranslatedFilter || parentFilter)) {
+				displayedRows = displayedRows.filter(function (row) {
+					return !row.translatedIn(langFilter);
+				});
+			}
+
+			var searchFilter = false;
+
+			if (TaxonomyTranslation.mainView.filterView.search && TaxonomyTranslation.mainView.filterView.search !== '') {
+				searchFilter = TaxonomyTranslation.mainView.filterView.search;
+			}
+
+			if (searchFilter) {
+				displayedRows = displayedRows.filter(function (row) {
+					if (langFilter && langFilter !== 'all') {
+						return row.matchesInLang(searchFilter, langFilter);
+					} else {
+						return row.matches(searchFilter);
+					}
+				});
+			}
+
+			self.count = displayedRows.length;
+
+			return displayedRows;
+		},
+		getDisplayCount: function(){
+			return this.count;
+		},
+		render: function () {
+
+			var self = this,
+				output = document.createDocumentFragment(),
+				displayedRows = self.getDisplayedRows();
+				
+			self.rowViews = [];
+
+			if ( displayedRows && displayedRows.length > 0 ) {
+				displayedRows = displayedRows.slice(self.start, self.end);
+
+				displayedRows.forEach(function (row) {
+					var newView = new TaxonomyTranslation.views.TermRowView({model: row });
+					self.rowViews.push(newView);
+					output.appendChild(newView.render().el);
+					newView.delegateEvents();
+					
+				});
+				self.$el.html(output);
+			} else {
+				var taxonomy = TaxonomyTranslation.classes.taxonomy.get("taxonomy"),
+					taxonomyPluralLabel = TaxonomyTranslation.data.taxonomies[taxonomy].label,
+					message = labels.noTermsFound.replace( '%taxonomy%', taxonomyPluralLabel );
+				
+				self.$el.html(
+					WPML_core[ 'templates/taxonomy-translation/no-terms-found.html' ] ({
+						message: message
+					})
+					);
+			}
+
+			return self;
+
+		}
+	});
+})(TaxonomyTranslation);

wp-content/plugins/sitepress-multilingual-cms/res/js/taxonomy-translation/views/term-view.js

@@ -0,0 +1,119 @@
+/*globals labels, TaxonomyTranslation, _, jQuery, WPML_core */
+
+(function () {
+
+	TaxonomyTranslation.views.TermView = Backbone.View.extend({
+
+		tagName: 'span',
+		template: WPML_core[ "templates/taxonomy-translation/term-translated.html" ],
+		model: TaxonomyTranslation.models.Term,
+		popUpView: false,
+		needsCorrection: false,
+		events: {
+			"click .icl_tt_term_name": "openPopUpTerm"
+		},
+
+		initialize: function () {
+			var self = this;
+			self.listenTo(self.model, 'translationSaved', self.render);
+			self.listenTo(self.model, 'translationSaved', function () {
+				jQuery('#tax-apply').prop('disabled', false);
+			});
+		},
+		loadSyncData: function () {
+			"use strict";
+			var self = this;
+
+			var syncData = TaxonomyTranslation.data.syncData;
+			var ttid = self.model.get('term_taxonomy_id');
+			var parent = self.model.get('parent');
+			var found = false;
+			var needsCorrection = false;
+			var correctParentText = false;
+			var parentName = TaxonomyTranslation.classes.taxonomy.getTermName(parent);
+			_.each(syncData, function (correction) {
+				if (correction.translated_id == ttid) {
+					found = true;
+
+					var oldParent = '';
+					if (parent !== 0) {
+						oldParent = '<span style="background-color:#F55959;">-' + TaxonomyTranslation.classes.taxonomy.getTermName(parent) + '</span>';
+						jQuery('.wpml-parent-removed').show();
+					}
+					var newParent = '';
+					if (correction.correct_parent !== 0) {
+						newParent = '<span style="background-color:#CCFF99;">+' + TaxonomyTranslation.classes.taxonomy.getTermName(correction.correct_parent) + '</span>';
+						jQuery('.wpml-parent-added').show();
+					}
+					parentName = oldParent + '   ' + newParent;
+					needsCorrection = true;
+				}
+			});
+
+			if (needsCorrection === true) {
+				self.template = WPML_core[ 'templates/taxonomy-translation/term-not-synced.html' ];
+			} else {
+				self.template = WPML_core[ 'templates/taxonomy-translation/term-synced.html' ];
+			}
+
+			self.$el.html(
+				self.template({
+					trid: self.model.get("trid"),
+					lang: self.model.get("language_code"),
+					name: self.model.get("name"),
+					level: self.model.get("level"),
+					correctedLevel: self.model.get("level"),
+					correctParent: correctParentText,
+					parent: parentName
+				})
+			);
+
+			self.needsCorrection = needsCorrection;
+
+			return self;
+		},
+
+		render: function () {
+			var self = this;
+
+			self.needsCorrection = false;
+			if ( ! self.model.get( "name" ) ) {
+				self.template = WPML_core[ "templates/taxonomy-translation/term-not-translated.html" ];
+			} else if ( self.model.isOriginal() ) {
+				self.template = WPML_core[ "templates/taxonomy-translation/term-original-disabled.html" ];
+			} else {
+				self.template = WPML_core[ "templates/taxonomy-translation/term-translated.html" ];
+			}
+
+			var html = self.template({
+					trid: self.model.get("trid"),
+					lang: self.model.get("language_code"),
+					name: self.model.get("name"),
+					level: self.model.get("level"),
+					correctedLevel: self.model.get("level"),
+					langs: TaxonomyTranslation.data.activeLanguages
+				});
+			self.$el.html( html );
+
+			return self;
+		},
+		openPopUpTerm: function (e) {
+			var self = this;
+
+			e.preventDefault();
+			var trid = self.model.get("trid");
+			var lang = self.model.get("language_code");
+			if (trid && lang) {
+				if (TaxonomyTranslation.classes.termPopUpView && typeof TaxonomyTranslation.classes.termPopUpView !== 'undefined') {
+					TaxonomyTranslation.classes.termPopUpView.close();
+				}
+				if ( self.model.isOriginal() ) {
+					TaxonomyTranslation.classes.termPopUpView = new TaxonomyTranslation.views.OriginalTermPopUpView( { model: self.model } );
+				} else {
+					TaxonomyTranslation.classes.termPopUpView = new TaxonomyTranslation.views.TermPopUpView( { model: self.model } );
+				}
+				TaxonomyTranslation.classes.termPopUpView.open( trid, lang );
+			}
+		}
+	});
+})(TaxonomyTranslation);