/* exported
    nitem itemsHTML m_bUpdated countindex codeEditor sortUnorderedList
    loadClass deleteClassFromFile refreshClassManager Help clone
    getJDEF nameNewJDEF setJDEF
  */

var type, className, beforeChangeClassName, selector, cssFile, codeEditor, index, skin, notimooManager;
var nitem = 1,
  itemsHTML = [],
  countindex = 1,
  m_bUpdated = false, // Flag per avviso di salvare
  allStyles = [], // Tutti gli stili del css
  loadedObj = '',
  newObj = '', // Oggetti visualizzati
  w = 480, // width di default dell'oggetto
  h = 240; // height di default dell'oggetto
var tool = "cssclass";

var font_list = ['',
  'Coustard', 'Antic Slab', 'Quattrocento',
  'Cinzel', 'Josefin Slab', 'Merriweather', 'Lora',
  'Nunito', 'Abel', 'Fjalla One', 'Dosis', 'Economica',
  'Raleway', 'Montserrat', 'Roboto Condensed', 'Oswald',
  'Special Elite', 'Fredoka One', 'Comfortaa', 'Bangers',
  'Righteous', 'Sigmar One', 'Patua One', 'Poiret One', 'Lobster',
  'Nova Mono', 'Inconsolata', 'Source Code Pro', 'Anonymous Pro', 'Roboto Mono',
  'Amatic SC', 'Shadows Into Light', 'Dancing Script', 'Pacifico', 'Indie Flower'
];

/**
 * [newClass creo gli elementi necessari per creare un nuovo file]
 * @param  {[event]}  e        [evento]
 * @param  {[string]} skinName [nome della skin]
 * @param  {[string]} tn       [tipo dell'elemento]
 * @param  {[string]} cn       [nome dell'elemento]
 * @param  {[string]} cf       [file in cui salvare l'elemento]
 */
function newClass(e, skinName, tn, cn, cf) {
  b_reload = false;
  skin = skinName;
  type = tn.toLowerCase();
  className = cn;
  selector = !Empty(cn) ? '.' + cn : '';
  cssFile = cf.replace('.ce.css', ''); // mi assicuro che non ci sia l'estensione
  notimooManager = new Notimoo({});
  document.body.onhelp = CancelHelp;
  newObj = createTypedObj();
  newObj.class_name = className;
  newObj.selector = selector;

  // creo gli elementi dell'editor
  generateProperties();
  generateFileManager();
  addShortcut();
  Ctrl('toolbar-top').innerHTML = generateTitle(true);

  if (!Empty(className)) {
    var portalClasses = eval(new JSURL('../servlet/CssParser?name=portalstudio', true).Response());
    if (portalClasses.indexOf(className) > -1) {
      notimooManager.show({
        title: 'Skin class detected!',
        message: "You're trying to modify a skin class. Go to skin editor if you want change it.",
        visibleTime: 4500,
        width: 220
      });
    } else {
      Ctrl('general_class_name').value = className;
    }
  } else if (!Empty(cssFile)) {
    Ctrl('general_class_name').focus();
    notimooManager.show({
      title: 'New class created!',
      message: 'Insert a name and save the class to add it in current position. \n \n Path: ' + (cssFile == 'portlet' ? cssFile : cssFile + '.ce.css') + '\n\n',
      visibleTime: 4500,
      width: 220
    });
  }
  writeHTML();
}

window.addEventListener("load", (e) => {
  if (e.target.location.href.contains("editor.jsp")) {
    Ctrl("edit_description").addEventListener("click", () => {
      editDesc("general_description", true, "description");
    });
    Ctrl("general_description").addEventListener("blur", function () {
      formProp.description = this.value;
    });
  }
});

/**
 * [loadClass carica la classe gia' esistente, se non viene trovata esegue la funzione newClass]
 * @param  {[event]}  e        [evento]
 * @param  {[string]} skinName [nome della skin]
 * @param  {[string]} tn       [tipo dell'elemento]
 * @param  {[string]} cn       [nome dell'elemento]
 * @param  {[string]} sl       [seleettore dell'elemento]
 * @param  {[string]} cf       [file in cui salvare l'elemento]
 */
function loadClass(e, skinName, tn, cn, sl, cf) {
  reload_(e, skinName, tn, cn, sl, cf);
}
/**
 * [deleteClass cancella la classe corrente]
 * @return {[type]} [true se e' stata trovata la classe da cancellare]
 */
function deleteClass(name, selector) {
  var found = false;
  var list = cssFile != 'portlet' ? allStyles : GetOpener().classCssObj;

  if (Empty(name)) {
    name = newObj.class_name;
    selector = newObj.selector;
  }

  for (var i = 0; list && i < list.length && !found; i++) {
    var class_name = Empty(list[i].version) ? list[i].name : list[i].class_name;
    if (class_name == name && list[i].selector == selector) {
      list.splice(i, 1);
      found = true;
    }
  }

  if (found) {
    if (cssFile != 'portlet') { // rigenero il file se la classe era esterna al file
      saveClass({
        notAddCurrent: true,
        actionType: 'delete'
      });
    }
    if (notimooManager.elements.length > 0) {
      notimooManager.close(notimooManager.elements[0]);
    }
    notimooManager.show({
      title: 'Operation completed!',
      message: 'Class deleted.',
      visibleTime: 2000,
      width: 220
    });
    newClass('event', skin, type, className, cssFile);
  }
  return found;
}

/**
 * [deleteClassFromFile permette di cancellare una classe da un file .ce.css specificando il nome e il selettore]
 * @param  {[string]} fileName  [nome del file dal quale cancellare la classe]
 * @param  {[string]} className [nome della classe da cancellare]
 * @param  {[string]} selector  [selettore della classe da cancellare]
 * @return {[bool]}           [se la classe viene trovata e cancellata, ritorna true]
 */
function deleteClassFromFile(fileName, className, selector) {
  var found = false,
    classList = restoreClassFromFile(fileName).items;
  for (var i = 0; classList && i < classList.length && !found; i++) {
    var class_name = Empty(classList[i].version) ? classList[i].name : classList[i].class_name;
    if (class_name == className && classList[i].selector == selector) {
      classList.splice(i, 1);
      found = true;
    }
  }
  if (found) {
    generateCssFile(classList, fileName);
  }
  return found;
}

/**
 * [saveClass salva nella posizione corrente]
 * @param  {[obj]} options  [oggetto contenente la configurazione del metodo saveClass]
 */
function saveClass(options) {
  var removeOld = false;
  if (!Empty(options)) {
    var newPosition = options.newPosition, // nuova posizione in cui salvare la classe
      notAddCurrent = options.notAddCurrent, // a true se nel salvataggio non voglio venga aggiunto l'elemento corrente
      savePortlet = options.savePortlet, // se a true oltre a salvare la classe salva anche il portlet
      actionType = options.actionType; // l'azione che richiama la funzione di salvataggio
  }

  if (Empty(newObj.class_name)) {
    // se nome non presente mostro messaggio
    PSAlert.alert("Name of class can't be empty.");
    Ctrl('general_class_name').focus();
    return;
  }
  if (!checkIfValidName(newObj.class_name) && actionType != 'delete') {
    PSAlert.alert('Name of class not valid.<br /> The class name to be valid it must begin with a char and can contain only:<b> - _ a-z</b>');
    Ctrl('general_class_name').focus();
    return;
  }

  if (Empty(newObj.selector)) {
    // compatibilita' con oggetti senza selettore di vecchie versioni ClassEditor
    newObj.selector = '.' + newObj.class_name;
    removeOld = true;
  }

  var temp_font_list = [];
  for (var i = 0; i < newObj.font_list.length; i++) {
    if (font_list.indexOf(newObj.font_list[i]) == -1) {
      temp_font_list.push(newObj.font_list[i]);
    }
  }
  newObj.font_list = temp_font_list;

  var replace;
  if (newPosition == 'portlet' || cssFile == 'portlet' && Empty(newPosition)) {
    replace = checkIfReplace(GetOpener().classCssObj);
    if (replace === undefined) {
      return;
    }

    GetOpener().classCssObj.push(JSON.parse(createElementForSave(newObj)));
    if (savePortlet) {
      GetOpener().save();
    }
    notimooManager.show({
      title: 'Operation completed!',
      message: 'Class saved in portlet.',
      visibleTime: 1500,
      width: 220
    });
    if (GetOpener().visualMode) {
      GetOpener().writeHTML();
    }
  } else {
    // se si salva in un file esterno diverso da quello di partenza
    if (newPosition && cssFile != newPosition) {
      allStyles = restoreClassFromFile(newPosition)?.items;
      cssFile = newPosition;
    } else if (Empty(allStyles) || !cssFile) {
      // il foglio stile non e' ancora stato salvato una volta
      // apro la maschera di salva con nome
      saveAsLayer();
      return;
    }

    replace = checkIfReplace(allStyles);
    if (replace === undefined) {
      return;
    }

    // Salvo il file senza l'elemento corrente (necessario per l'eliminazione)
    if (Empty(notAddCurrent)) {
      if(typeof allStyles == 'undefined' ) {
        allStyles = [];
      }
      allStyles.push(JSON.parse(createElementForSave(newObj)));
    }

    generateCssFile(allStyles);
    if (loadedObj && Empty(notAddCurrent)) {
      var css_list = GetOpener().formProp.css ? GetOpener().formProp.css.split(',') : [];
      var found = false;
      for(i = 0; i < css_list.length && !found; i++) {
        var patt = new RegExp('.*styles\/(.*)');
        var compare = patt.exec(cssFile); // mantego solo il nome del file senza percorso
        if (compare[1].replace('.ce.css', '') == css_list[i].replace('styles/', '').replace('.ce.css', '')) {
          found = true;
        }
      }
      if (!found) {
        // foglio non e' gia' presente
        css_list.push(cssFile + '.ce.css');
        GetOpener().formProp.css = css_list.join(',');
        GetOpener().Ctrl('Form_style_css').value = GetOpener().formProp.css; // aggiorno l'input a display
      }
    }
  }
  if (removeOld) {
    deleteClass(newObj.class_name, undefined);
  }
  generateFileManager();
  //if (className != newObj.class_name || selector != newObj.selector || removeOld) {
  //  location.href = '../classeditor/editor.jsp?name=' + encodeURIComponent(newObj.class_name) + '&type=' + newObj.type.toLowerCase() +
  //    '&selector=' + encodeURIComponent(newObj.selector) + '&css=' + encodeURIComponent(cssFile);
  //}
  m_bUpdated = false;
}

/**
 * [writeHTML rigenera il codice HTML per l'oggetto corrente]
 */
function writeHTML() {
  //
  var ctrl = Ctrl('container-item');
  ctrl.style.width = w + 'px';
  ctrl.style.height = h + 'px';

  var objClass = newObj[newObj.type + 'Class'] || newObj.objClass;
  if (objClass.wireframe) {
    ctrl.innerHTML = objClass.wireframe(newObj);
  }
}

/**
 * [previewCss apre il layer di visualizzazione di preview del codice generato]
 */
function previewCss() {
  if (Empty(newObj.class_name)) {
    PSAlert.alert('To show properly the preview you must first fill the field of name.');
    Ctrl('general_class_name').focus();
    return;
  }
  window.layerOpenForeground('../classeditor/preview.jsp', '', '', 480, 320, false, 1);
}

/**
 * [refreshClassManager aggiorna il class manager dell'editor]
 */
function refreshClassManager() {
  generateFileManager();
  notimooManager.show({
    title: 'Operation completed!',
    message: 'Class manager updated.',
    visibleTime: 2500,
    width: 220
  });
}

/**
 * [createTypedObj creo un oggetto vuoto in base al tipo]
 * @return {[obj]} [oggetto di default crerato in base al tipo]
 */
function createTypedObj() {
  var tmpObj, value;
  switch(type.toLowerCase()) {
  case 'box':
    tmpObj = new ZTObjects.boxObj(newObj.class_name, 'box', '240', '120');
    break;
  case 'label':
    value = loadedObj ? loadedObj.value : 'Label text';
    tmpObj = new ZTObjects.labelObj(newObj.class_name, 'label', '200', '480', value);
    break;
  case 'image':
    var src = loadedObj && !Empty(loadedObj.src) ? loadedObj.src : './images/default.jpg';
    tmpObj = new ZTObjects.imageObj(newObj.class_name, 'image', '480', '240', src);
    // Preset delle immagini con stili predefiniti
    if (loadedObj) {
      switch (loadedObj.class_Css) {
      case 'image-circle':
        tmpObj.border_radius_tl = '50';
        tmpObj.border_radius_tr = '50';
        tmpObj.border_radius_br = '50';
        tmpObj.border_radius_bl = '50';
        tmpObj.border_radius_unit = ' %';
        break;
      case 'image-thumbnail':
        tmpObj.border_radius_tl = '5';
        tmpObj.border_radius_tr = '5';
        tmpObj.border_radius_br = '5';
        tmpObj.border_radius_bl = '5';
        tmpObj.pad_top = '5';
        tmpObj.pad_right = '5';
        tmpObj.pad_bottom = '5';
        tmpObj.pad_left = '5';
        tmpObj.bg_color = '#FFFFFF';
        break;
      }
    }
    break;
  case 'textbox':
    value = loadedObj ? loadedObj.value : 'Textbox text';
    tmpObj = new ZTObjects.textboxObj(newObj.class_name, 'textbox', '480', '240', value);
    break;
  case 'button':
    value = loadedObj ? loadedObj.value : 'Button';
    tmpObj = new ZTObjects.buttonObj(newObj.class_name, 'button', '480', '240', value);
    break;
  default:
    tmpObj = new ZTObjects.stdObj(newObj.class_name, 'undefined_type', '480', '240');
    break;
  }
  return tmpObj;
}

/**
 * [generateTitle genero il titolo della barra superiore del ClassEditor]
 * @param  {[bool]}   found [se true e' stata trovata la classe fra quelle gia' presenti]
 * @return {[string]}       [titolo del class editor]
 */
function generateTitle(found) {
  var title_string = 'Class Editor';
  if (found) {
    if (cssFile == 'portlet') {
      title_string = '(portlet) | ' + title_string;
    } else if (cssFile != '') {
      title_string = '(' + cssFile + '.ce.css) | ' + title_string;
    }
    if (newObj.selector) {
      title_string = newObj.selector + ' ' + title_string;
    } else if (className) {
      title_string = '.' + className + ' ' + title_string;
    }
  }
  return title_string;
}

/**
 * [addShortcut aggiungo shortcut rapidi da tastiera]
 */
function addShortcut() {
  document.onkeydown = function (e) {
    if (e.ctrlKey && e.shiftKey && e.keyCode === 83) { // CTRL+SHIFT+S: salva
      document.activeElement.blur();
      e.preventDefault();
      saveClass({
        savePortlet: true
      });
      return false;
    } else if (e.ctrlKey && e.keyCode === 83) { // CTRL+S: salva
      document.activeElement.blur();
      e.preventDefault();
      saveClass();
      return false;
    } else if (e.keyCode === 27) { // ESC: chiudi finestra
      window.close();
    } else if (e.ctrlKey && e.keyCode === 66) { // CTRL+B: anteprima
      previewCss();
    }
  };

  Ctrl('general_class_name').addEvents({ // il nome deve essere sempre presente
    blur: function () {
      if (beforeChangeClassName != this.value) {
        if (Empty(newObj.selector)) { // non c'e' nessun selettore, lo genero in automatico
          newObj.selector = !Empty(this.value) ? '.' + this.value : '';
        } else { // aggiorno il nome della classe presente nel selettore
          newObj.selector = !Empty(this.value) ?
            newObj.selector.replace('.' + beforeChangeClassName, '.' + this.value) : '';
        }
        Ctrl('advanced_selector').value = newObj.selector;
      }
    },
    focus: function () {
      beforeChangeClassName = this.value;
    }
  });

  Ctrl('advanced_selector').addEvents({
    blur: function () {
      if (Empty(this.value)) { // non c'e' nessun selettore, lo genero in automatico
        if (!Empty(newObj.class_name)) { // e' gia' stato scritto il nome della classe
          newObj.selector = '.' + newObj.class_name;
          this.value = newObj.selector;
        }
      } else if (newObj.selector.search('.' + newObj.class_name) == -1) { // nel selettore non e' stato inserito il nome della classe
        PSAlert.alert('There is no class name in selector.');
        this.focus();
      }
    }
  });
}

/**
 * [checkIfReplace controllo se e' gia' presente una classe con il nome scelto]
 * @param  {[obj]}  obj [elemento corrente]
 * @return {[bool]}     [true se si decide di sostituire l'elemento]
 */
function checkIfReplace(obj) {
  var replace = false;
  for (var i = 0; obj && i < obj.length && !replace; i++) {
    var class_name = Empty(obj[i].version) ? obj[i].name : obj[i].class_name;
    if (class_name == newObj.class_name && obj[i].selector == newObj.selector) {
      if (newObj.selector != selector) {
        replace = confirm('There is already a class with this name, do you want to replace it?');
        if (replace) { // l'utente ha confermato che vuole sovrascrivere la classe
          obj.splice(i, 1);
        } else {
          Ctrl('general_class_name').focus();
          return;
        }
      } else {
        obj.splice(i, 1);
      }
    }
  }
  return replace;
}

/**
 * [checkIfValidName controllo che il nome della classe css sia valido]
 * @param  {[string]}  classname [nome della classe da controllare]
 * @return {[bool]}              [true se il nome e' valido]
 */
function checkIfValidName(classname) {
  /* Il nome della classe per essere valido deve cominciare con un [a-z] e
   * puo' contenere solo (-), (_) e a-z.
   **/
  if (!/^([a-z])[a-z\d_-]*$/i.test(classname)) {
    return false;
  }
  return true;
}

/**
 * [generateCssFile genero il foglio stile completo]
 * @param  {[array]}  allStyles [contiene tutti gli elementi che verranno generati nel foglio stile]
 */
function generateCssFile(allStyles, fileName, getDef) {
  if(getDef == undefined){
    var file = !Empty(fileName) ? fileName : cssFile,
    folder_path = '';
    folder_path = cssFile.substring(0, cssFile.lastIndexOf("/") + 1);
    file = Strtran(file, folder_path, "");
    var url = new JSURL( '../servlet/JSPSave?type=classeditor'+
      '&name=' + file +
      '&folder_path=' + folder_path +
      '&def=' + URLenc(JSON.stringify({ description: formProp.description, items: allStyles})) +
      '&m_cID=' + cmdhash
      , true);
    checkOutput(url.Response(), file, folder_path);
  } else if(getDef == "getJDEF") {
    return JSON.stringify({ description: formProp.description, items: allStyles});
  }

}

/**
 * [checkOutput controllo del corretto salvataggio del file]
 * @param  {[string]} output      [risultato del salvataggio]
 * @param  {[string]} file        [file di cui si controlla il corretto salvataggio]
 * @param  {[string]} folder_path [percorso del file di cui si controlla il corretto salvataggio]
 */
function checkOutput(output, file, folder_path) {
  if (Empty(notimooManager)) {
    notimooManager = new Notimoo({});
  }
  if (window.parent.changeName) {
    window.parent.changeName(file, folder_path, Strtran(window.frameElement.id, 'portalstudioframe', ''));
  }
  if (output == null) {
    output = '';
  }
  switch (output) {
  case 'true':
    for (var i = 0; i < notimooManager.elements.length; i++) {
      notimooManager.close(notimooManager.elements[i]);
    }
    notimooManager.show({
      title: 'Operation completed!',
      message: 'File saved!',
      visibleTime: 2500,
      width: 220
    });
    break;
  case 'ACCESS DENIED':
    //notimooManager.close(notimooManager.elements[0]);
    if(window.parent.location.href.indexOf("portalstudio.jsp") < 0){
      accessDeniedStandaloneRefresh({ name : cssFile});
    } else {
      parent.jsonConfirmAccessDenied({ name : cssFile});
    }
    //alert('Access Denied.');
    break;
  case 'LICENSE LIMIT':
    notimooManager.close(notimooManager.elements[0]);
    alert('Licensed User Limit Reached.');
    break;
  default:
    notimooManager.close(notimooManager.elements[0]);
    alert('Save routine failed.');
    break;
  }
}

/**
 * [saveAsLayer se nome non presente mostro messaggio, altrimenti mostro finestra di dialogo per il salvataggio su file]
 */
function saveAsLayer() {
  if (Empty(newObj.class_name)) {
    PSAlert.alert("Name of class can't be empty.");
    Ctrl('general_class_name').focus();
    return;
  }
        window.layerOpenForeground('../portalstudio/saveas.jsp?tool=classeditor', 'SaveCSSFile', '', 530, 360, true, 1);
}

/**
 * [Help funzione per la documentazione, apre la pagina relativa alla proprieta' selezionata]
 * @param {[string]} the_property [proprieta' della quale si chiede la documentazione]
 */
function Help(the_property) {
  var i,
    prop = '';
  if (typeof anchorToFeature != 'undefined') {
    if (typeof the_property != 'undefined') {
      prop += 'csseditor_' + the_property.toLowerCase();
    }

    if (prop.indexOf('undefined') > 9) {
      prop = Strtran(prop, 'undefined_type', 'css');
    }

    if (prop != '' && prop in anchorToFeature) {
      i = anchorToFeature[prop];
    } else if (index != null && 'classeditor_' + newObj.type.toLowerCase() in anchorToFeature) {
      i = anchorToFeature['classeditor_' + newObj.type.toLowerCase()];
    } else {
      i = anchorToFeature.csseditor;
    }

    windowOpenForeground(
      m_cHelpUrl + 'help/portalstudio/ps_urg_navigator.htm?' + URLenc(i + (prop != '' ? '||' + prop + '' : '')), '',
      'toolbar=0, menubar=0, directories=0, width=720, height=600, resizable=1, scrollbars=1'
    );
  }
}

/**
 * [clone funzione per la copia profonda di oggetti e array]
 * @param  {[type]} obj [l'oggetto da clonare]
 * @return {[type]}     [l'oggetto clonato]
 */
function clone(obj) {
  var copy;

  // Handle the 3 simple types, and null or undefined
  if (null == obj || "object" != typeof obj) return obj;

  // Handle Date
  if (obj instanceof Date) {
    copy = new Date();
    copy.setTime(obj.getTime());
    return copy;
  }

  // Handle Array
  if (obj instanceof Array) {
    copy = [];
    for (var i = 0, len = obj.length; i < len; i++) {
      copy[i] = clone(obj[i]);
    }
    return copy;
  }

  // Handle Object
  if (obj instanceof Object) {
    copy = {};
    for (var attr in obj) {
      if (obj.hasOwnProperty(attr)) copy[attr] = clone(obj[attr]);
    }
    return copy;
  }

  throw new Error("Unable to copy obj! Its type isn't supported.");
}

/**
 * Sovrascrive i valori di obj1 con quelli di obj2, e se non esistono li aggiunge
 * @param obj1
 * @param obj2
 * @returns obj3 un nuovo oggetto basato su obj1 e obj2
 */
function merge(obj1, obj2){
  var attrname;
  var obj3 = {};
  for (attrname in obj1) { obj3[attrname] = obj1[attrname]; }
  for (attrname in obj2) { obj3[attrname] = obj2[attrname]; }
  return obj3;
}

function compareText(a1, a2) {
  var t1 = a1.innerText,
    t2 = a2.innerText;
  return t1 > t2 ? 1 : (t1 < t2 ? -1 : 0);
}

/**
 * [sortUnorderedList ordina una lista di elementi ul/li]
 * @param  {[Object]} ul              [l'id della lista o la lista stessa]
 * @param  {[bool]} sortDescending    [true per ordinare la lista in ordine decrescente]
 */
function sortUnorderedList(ul, sortDescending) {
  if (typeof ul == "string") {
    ul = document.getElementById(ul);
  }

  var lis = ul.getElementsByTagName("li");
  var vals = [];

  for (var i = 0, l = lis.length; i < l; i++) {
    vals.push(lis[i]);
  }

  vals.sort(compareText);

  if (sortDescending) {
    vals.reverse();
  }

  ul.innerHTML = '';
  for (i = 0, l = vals.length; i < l; i++) {
    ul.appendChild(vals[i]);
  }
}



function reload_(e, skinName, tn, cn, sl, cf){
  b_reload = false;
  skin = skinName;
  type = tn.toLowerCase();
  className = cn;
  selector = sl == 'undefined' ? undefined : sl;
  cssFile = cf.replace('.ce.css', ''); // mi assicuro che non ci sia l'estensione
  notimooManager = new Notimoo({});
  document.body.onhelp = CancelHelp;
  let impExp = false;
  let autoSaveIE = false;
  
  // se definito l'indice del GetOpener carico l'intero oggetto del portlet
  if (GetOpener() && GetOpener().index >= 0) {
    loadedObj = GetOpener().itemsHTML[GetOpener().index];
    if (loadedObj) {
      w = loadedObj.w;
      h = loadedObj.h;
    }
  }

  var list;
  if (cssFile != 'portlet') {
    var def;
    if( c_ripristino && sessionStorage.getItem(c_ripristino)){
      /**
       * parent.is_Saving a False, perchè se fosse True i vari tab 
       * non sarebbero più cliccabili e quindi non si potrebbe lavorare 
       * sugli altri Tab
       */
      parent.is_Saving = false;
      def = JSON.parse(sessionStorage.getItem(c_ripristino))["def"];
      cssFile = JSON.parse(sessionStorage.getItem(c_ripristino))["name"];
      selector = JSON.parse(sessionStorage.getItem(c_ripristino))["selectors"].selector;
      className = JSON.parse(sessionStorage.getItem(c_ripristino))["selectors"].class_name;
      sessionStorage.removeItem(c_ripristino);
      if(window.parent.location.href.indexOf("portalstudio.jsp") < 0){
        autoSaveIE = true;
      }
    } else if(window.frameElement?.jdef){
      parent.is_Saving = false;
      def = JSON.parse(window.frameElement.jdef);
      cssFile = JSON.parse(window.frameElement.nomeFile);
      window.frameElement.jdef = undefined;
      window.frameElement.nomeFile = undefined;
      impExp = true;
    } else {
      def = restoreClassFromFile(cssFile);
    }
    
    
    if(def){
      Ctrl('general_description').value = def.description || '';
      formProp.description = def.description || '';
      allStyles = def.items; // ripristino le classi all'interno del foglio stile caricato
    }
    else{
      list = [];
    }
    if(Empty(allStyles)) {
      allStyles = [];
    }
    list = allStyles;
  } else if (Empty(GetOpener().classCssObj)) {
    list = [];
  } else {
    list = GetOpener().classCssObj;
  }

  var found = false;
  // controllo se e' gia' presente
  for (var i = 0; i < list.length && !found; i++) {
    var class_name = Empty(list[i].version) ? list[i].name : list[i].class_name;
    if (class_name == className) {
      if (Empty(selector) || list[i].selector == selector) {
        found = true;
        if (!Empty(list[i].version)) {
          newObj = list[i];
        } else {
          // mantenuto per retrocompatibilita'
          newObj = JSON.parse(list[i].obj);
          newObj.selector = list[i].selector;
        }
      }
    }
  }

  if (found) {
    // creo un oggetto vuoto in base al tipo
    var tmpObj = createTypedObj();
    newObj = merge(tmpObj, newObj); // ricreo newObj con le proprieta' standard
    newObj = merge(newObj, newObj.specific_states_value[newObj.current_state]); // imposto i valori dello stato corrente
    updateStates(newObj.current_state, 'normal'); // apro l'editor nello stile normal
    newObj.current_state = 'normal';
    if (!Empty(tmpObj.value)) {
      newObj.value = tmpObj.value;
    } else if (!Empty(tmpObj.src)) {
      newObj.src = tmpObj.src;
    }
    newObj.font_list = newObj.font_list.concat(font_list).unique();
    if (Empty(selector)) {
      selector = newObj.selector;
    }
  } else {
    newClass('event', skin, type, className, cssFile); // non esiste nessuna classe, ne creo una nuova
  }
    // creo gli elementi dell'editor
    generateProperties();
    if(impExp){
      generateFileManager(def, cf);
      impExp = false;
    } else {
      generateFileManager();
    }
    if(cssFile && autoSaveIE){
      saveClass();
      autoSaveIE = false;
    } else if(!cssFile && autoSaveIE){
      saveClass();
      autoSaveIE = false;
    }
    
    addShortcut();
    Ctrl('toolbar-top').innerHTML = generateTitle(found);
    writeHTML();
}



// --------- EXPORT ----------- // 
/**
 * Ottiene JDEF e aggiunge Versione e Tool
 */
function getJDEF(){
  let nomeFile = cssFile;
  let found = false;
  if (newObj.class_name != "") {
    for (var i = 0; i < allStyles.length; i++) {
      if (allStyles[i].class_name == newObj.class_name) {
        allStyles[i]  = JSON.parse(createElementForSave(newObj));
        found = true;
      }
    } 
    if(found == false){
      allStyles.push(JSON.parse(createElementForSave(newObj)));
    }
  }
  var getJDef = generateCssFile(allStyles, undefined, "getJDEF");
  let toolType = tool;
  let versionTool = formProp.version;
  let newJDefStringify = {
    tool: toolType,
    version: versionTool,
    nomeFile: nomeFile,
    def: JSON.parse(getJDef),
    selectors: newObj,
    name : cssFile
  }
  return newJDefStringify;
}