/* global myZtCharts  */
/* exported applyChartMenuFnc getZFChartMacroType setFont drawLegendItems getPathBetweenXCoord
    optimizeFontSize setDefaultChart getList getListBySeries getDuplicatesList getDuplicatesListXYZ
    getAbsList getValues getGeneralMarginsObject getMargin notifyDraw getTreemapDataset
    getWaterfallDifferenceDataset getRadarDataset getParetoLineDataset getWordMinMaxIndex
    getMeasureMinMax howManyDigits isNumberFloat estimateMaximumTickLabel getLargerTickUnit
    getCeilingTickUnit getStandardTickUnits setTicks setColorSeriesArray getWizardPlotColors
    getDomNodeSizes recursivediv getStackDataset accumulateValuesOnColumn getMaxValueStack
    get3DColor setOtherChartsArray getImgSrc getY getX replaceSpecialCharsForFileName
    replaceSpecialCharsForID replaceIconFontWithUnicode replaceIconFontWithCharCode
    trasposeMatrix getDefaultRangeBands getRangeContOrDisc getIntervalRange getRangeBandsWithValues
    getListFromObjectArray getColorsArrayDarker getRangeColor getPercentDataset btwn
    line_line_intersect zeroFilledArray getTreemapLayout convertCsv convertXml
    getFilterType recursiveNodePattern getTimeTickFormat calcTimeOffset getTimingDivisor
    calcTimeOffsetBtw2Date calcDistanceDifferentTimeUnit setTimeTicks numRoundTo
    getMagnitudeOrder fileExists invertColor makeParameterStringFromLinkObj canDrawInContainer
    getAlternativeChartType wrapspace getD3TimeObject getMaxWordLengthForWrap
    getTimeFormatSeparator isNumeric getHieDataset getForceDataset getMatrixLinksDataset
    getMatrixDependencies getAllFonts getDuplicatesListCAT getSankeyNodesDataset getChartFunctionGroup
    getChartFamilyGroup mergeDeep getScrollTop makeParameterStringFromOverlapLinkObj arrayCompare
    decodeConditionalFormatting getMultichromaticRangeColorPV getAllDefaultColors
  */
function getAllCharts(subdivide) {
  // riportata in PortalCommonsJS
  if (subdivide) {
    return {
            category: {
              vbars: ["VBAR","VBAR3D","PARETO","WATERF","LAYEREDBAR"],
              pies: ["PIE","PIE3D","RING","RINGPERC"],
              line: ["LINES","AREA","STACKEDAREA","RADARLINE","RADARAREA"],
              stackedbars: ["HSTACKBAR","HSTACKBAR3D","VSTACKBAR","VSTACKBAR3D"],
              hbars: ["HBAR","HBAR3D","PYRAMID","LAYEREDBARH"],
              maps: ["TREEMAP","TREEMAPBAR","TREEMAPBARH","WORDCLOUD"],
              meter: ["ARCDIAL","THERMO"],
              state: ["LIGHTS","IMAGES"],
              counters: ["DISPLAY","COUNTER","PADDLE"]
            },
            xyz: {
              xy: ["SCATTER","ASTER","AREABAR","VORONOI"],
              yz: ["BUBBLE"]
            },
            geo: {
              gmap: ["GEOMAP"]
            },
            hie: {
              structure: ["SUNBSTR", "TREESTR", "CPACKSTR", "FORCESTR"],
              values: ["SUNB", "TREE", "CPACK", "FORCE", "MARIMEKKO"]
            },
            dep: {
              rel: ["MATRIX", "CHORD", "SANKEY"]
            },
            classif: {
              map: ["BCMATRIX"]
            }
          };
  }
  return { category: [ "HBAR","HBAR3D","PYRAMID","LAYEREDBARH",
                      "PIE","PIE3D","RING","RINGPERC",
                      "WORDCLOUD",
                      "HSTACKBAR","HSTACKBAR3D","VSTACKBAR","VSTACKBAR3D",
                      "LINES","AREA","STACKEDAREA","RADARLINE","RADARAREA",
                      "VBAR","VBAR3D","PARETO","WATERF","LAYEREDBAR",
                      "ARCDIAL","THERMO",
                      "LIGHTS","IMAGES",
                      "DISPLAY","COUNTER","PADDLE",
                      "CAL",
                      "PYR", "NECKEDPYR", "PYRSTR", "NECKEDPYRSTR", "FUNNEL",
                      "PCOORDS"
                    ],
           xyz: ["SCATTER", "BUBBLE", "ASTER", "AREABAR","VORONOI"],
           geo: ["GEOMAP"],
           hie: ["SUNB", "SUNBSTR", "TREE", "TREESTR", "CPACK", "CPACKSTR", "FORCE", "FORCESTR",
                  "TREEMAP","TREEMAPBAR","TREEMAPBARH", "MARIMEKKO"
                ],
           dep: ["MATRIX", "CHORD", "SANKEY"],
           classif: ["BCMATRIX"]
         };
}

function getZFChartMacroType(type) {
  // riportata in PortalCommonsJS
  var mtypes = getAllCharts(),
      mkeys = Object.keys(mtypes),
      found = false,
      rt = "";
  for (var t = 0; !found && t < mkeys.length; t++) {
    if (mtypes[mkeys[t]].indexOf(type) >= 0) {
      rt = mkeys[t];
      found = true;
    }
  }
  return rt;
}

function getChartFunctionGroup(type) {
  var fncs = {
    comp: ["LINES","RADARLINE","RADARAREA","AREA","STACKEDAREA",
                  "PCOORDS","VBAR","HBAR","VSTACKBAR","HSTACKBAR",
                  "LAYEREDBAR","LAYEREDBARH","TREEMAPBAR","TREEMAPBARH",
                  "PYRAMID","ARCDIAL","THERMO","DISPLAY","COUNTER","PADDLE",
                  "LIGHTS","IMAGES"],
    distr: ["LINES","AREA","STACKEDAREA","VBAR","HBAR","WATERF",
                    "PYRAMID","AREABAR","SCATTER","BUBBLE","PARETO",
                    "FUNNEL","ASTER","VORONOI"],
    rel: ["RADARLINE","RADARAREA","PCOORDS","SCATTER","BUBBLE",
                    "SUNB","SUNBSTR","TREE","TREESTR","CPACK","CPACKSTR",
                    "FORCE","FORCESTR","TREEMAP","TREEMAPBAR","TREEMAPBARH",
                    "CHORD","MATRIX","BCMATRIX","VORONOI"],
    ovtime: ["LINES","RADARLINE","RADARAREA","AREA","STACKEDAREA",
                       "VBAR","HBAR","WATERF","CAL"],
    fhie: ["MARIMEKKO","SUNB","SUNBSTR","TREE","TREESTR","CPACK","CPACKSTR",
                "FORCE","FORCESTR","TREEMAP","TREEMAPBAR","TREEMAPBARH"],
    ptw: ["MARIMEKKO","PIE","RING","ASTER","PYR","PYRSTR",
                      "WORDCLOUD","SUNB","SUNBSTR","TREE","TREESTR",
                      "CPACK","CPACKSTR","FORCE","FORCESTR","TREEMAP",
                      "TREEMAPBAR","TREEMAPBARH", "RINGPERC"],
    con: ["WORDCLOUD","TREE","TREESTR","FORCE","FORCESTR"],
    loc: ["GEOMAP"]
  };

  var kfnc = Object.keys(fncs),
  rets = [];
  for (var i = 0; i < kfnc.length; i++) {
    if (fncs[kfnc[i]].indexOf(type) >= 0)
      rets.push(kfnc[i]);
  }

  return rets;
}

function getChartFamilyGroup(type) {
  var fams = {
    car: ["LINES","RADARLINE","RADARAREA","AREA","STACKEDAREA",
          "PCOORDS","VBAR","HBAR","VSTACKBAR","HSTACKBAR",
          "LAYEREDBAR","LAYEREDBARH","TREEMAPBAR","TREEMAPBARH",
          "WATERF","PYRAMID","AREABAR","SCATTER","BUBBLE","ARCDIAL",
          "THERMO","PARETO","MARIMEKKO","FUNNEL","BCMATRIX"],
    ind: ["ARCDIAL","THERMO","LIGHTS","IMAGES","DISPLAY","COUNTER","PADDLE","BCMATRIX"],
    aer: ["MARIMEKKO","PIE","RING","ASTER","PYR","PYRSTR","WORDCLOUD",
          "SUNB","SUNBSTR","CPACK","CPACKSTR","TREEMAP","CHORD","RINGPERC"],
    gra: ["TREE","TREESTR","FORCE","FORCESTR","CHORD","VORONOI"],
    tab: ["MATRIX","CAL"],
    gsp: ["GEOMAP"]
  };

  var kfam = Object.keys(fams),
  rets = [];
  for (var i = 0; i < kfam.length; i++) {
    if (fams[kfam[i]].indexOf(type) >= 0)
      rets.push(kfam[i]);
  }

  return rets;
}

function setFont(item, itemFont, chart) {
  if (!(item))
    return;
  if (item._groups.length == 0)
    return;
  if (item._groups[0][0] == null)
    return;

  var stObj = {
    font9family : itemFont.name,
    font9size : itemFont.size + "px"
  }

  if (Empty(itemFont.color))
    stObj.fill = "#000000";
  else
    stObj.fill = itemFont.color;

  if (itemFont.style == "B")
    stObj.font9weight = "bold";
  else if (itemFont.style == "I")
    stObj.font9style = "italic";
  else if (itemFont.style == "BI") {
    stObj.font9style = "italic";
    stObj.font9weight = "bold";
  }
  else
    stObj.font9style = "normal";

  item.attr("style", makeStyleHTMLString(stObj, item.attr("style")));

  if (chart)
    chart.SetUsedFont(itemFont);
}

function drawLegendItems(container, icon, list, idicon, idtext, hexCode, stdChart, isRange) {
  var legendGroup,
  legendItem,
  isNeg,
  isAgg;
  for (var i = 0; i < list.length; i++) {
    isNeg = list[i] == stdChart.Translate("ZTC_NEGVAL");
    isAgg = (stdChart.aggregateData && list[i] == stdChart.aggregateData.label);
    legendGroup = container.append("g");
    var check = isRange ? true : stdChart._IsNotExcluded(i);

    if (!isNeg && !isRange) {
      if (stdChart._ZtChart.enableExclude) {
        legendItem = legendGroup.append("text")
        .attr("id", idtext + 'filter_' + i)
        .attr("class", "ztchart_legend_icon_small")
        .attr("data-font", check ? stdChart.GetCheckIconCode() : stdChart.GetUncheckIconCode())
        .attr("data-index", i)
        .attr("data-check", check)
        .attr("data-text", list[i])
        .style("cursor", "pointer")
        .style("font-family", stdChart.GetDefaultIconFont().name)
        .style("font-size", stdChart.GetDefaultIconFont().size)
        .style("fill", stdChart.GetDefaultIconFont().color)
        .text(getIconFromCode(check ? stdChart.GetCheckIconCode() : stdChart.GetUncheckIconCode()))
        .on("click", function () {
          stdChart._ApplyLegendExclude(this);
        });
      }
    }

    legendItem = legendGroup.append("text")
      .attr("id", idicon + i)
      .attr("class", "ztchartfonticon legendItem" + (isRange ? "range" : ""))
      .attr("data-font", (hexCode.constructor != Array) ? hexCode : hexCode[i])
      .attr("data-index", i)
      .attr("data-text", list[i])
      .attr("data-negative", isNeg)
      .attr("data-aggregate", isAgg)
      .attr("data-range", isRange || false)
      .style("font-family", stdChart.GetDefaultIconFont().name)
      .style("font-size", stdChart.GetLegendIconSize())
      .text((icon.constructor != Array) ? icon : icon[i]);

    if (!isNeg) {
      legendItem.style("cursor",function(){
        if (!stdChart._ZtChart.enableLegendClick)
          return "default";
        return "pointer"
      })
      .on("mouseover", function() {
        if (!stdChart._ZtChart.enableLegendEffect)
          return;
        stdChart._ApplyLegendMouseOver(this);
      })
      .on("mouseout", function() {
        if (!stdChart._ZtChart.enableLegendEffect)
          return;
        stdChart._ApplyLegendMouseOut(this);
      })
      .on("click", function() {
        if (!stdChart._ZtChart.enableLegendClick)
          return;
        stdChart._ApplyLegendClick(this);
      })
    }
    else
      legendItem.style("cursor", "default");

    legendItem = legendGroup.append("text")
      .attr("id", idtext + i)
      .attr("class", "legendItem" + (isRange ? "range" : ""))
      .attr("data-index", i)
      .attr("data-range", isRange || false)
      .attr("data-text", list[i])
      .style("cursor", "default")
      .text(list[i]);

    if (!isNeg) {
      legendItem.style("cursor",function(){
        if(!stdChart._ZtChart.enableLegendClick)
          return "default";
        return "pointer"
      })
      .on("mouseover", function() {
        if(!stdChart._ZtChart.enableLegendEffect)
          return;
        stdChart._ApplyLegendMouseOver(this);
      })
      .on("mouseout", function() {
        if(!stdChart._ZtChart.enableLegendEffect)
          return;
        stdChart._ApplyLegendMouseOut(this);
      })
      .on("click", function() {
        if(!stdChart._ZtChart.enableLegendClick)
          return;
        stdChart._ApplyLegendClick(this);
      })
    }
    else
      legendItem.style("cursor", "default");
  }
}

function getPathBetweenXCoord(x1, x2, line, lastLen, reverse) {
  var tmppts = [];
  var f = false;
  var i = lastLen;
  while (!f) {
    var point = line.getPointAtLength(i);
    if (point.x >= x1)
      tmppts.push(point.x + "," + point.y);
    f = point.x >= x2;
    i++;
  }
  if (reverse)
    return {path: "L" + tmppts.reverse().join("L"), lastLen: i-2, lastY: point.y};
  return {path: "L" + tmppts.join("L"), lastLen: i-2, lastY: point.y};
}

function optimizeFontSize(pos, txt, initFont, item, fontRed, chartId) {
  var retobj = {},
  orgsize = initFont.size,
  txtW = getOffsetWidth(txt, initFont, chartId),
  txtH = getOffsetHeight(txt, initFont, chartId),
  mbox,
  mmb,
  isOK;
  retobj.txt = txt;
  if (item.r) {
    mmb = item.itm.getBBox();
    mbox = { x : mmb.x,
             y : mmb.y,
             width : 2 * item.r,
             height : 2 * item.r
           };
  }
  else if (Empty(item.x + "") || Empty(item.y + "") || Empty(item.width + "") || Empty(item.height + ""))
    mbox = item.itm.getBBox();
  else
    mbox = { x: item.x,
             y: item.y,
             width: item.width,
             height: item.height
           };
  if (pos == "in") {
    // ci provo in H
    isOK = false;
    if (txtW < mbox.width && txtH < mbox.height) {
      isOK = true;
    }
    else {
      initFont.size = initFont.size - initFont.size * fontRed;
      txtW = getOffsetWidth(retobj.txt, initFont, chartId);
      txtH = getOffsetHeight(retobj.txt, initFont, chartId);
      if (txtW < mbox.width && txtH < mbox.height) {
        isOK = true;
      }
    }
    // ora in V
    if (!isOK) {
      initFont.size = orgsize;
      txtW = getOffsetWidth(retobj.txt, initFont, chartId);
      txtH = getOffsetHeight(retobj.txt, initFont, chartId);
      if (txtW < mbox.height && txtH < mbox.width) {
        retobj.isV = true;
        isOK = true;
      }
      else {
        initFont.size = initFont.size - initFont.size * fontRed;
        txtW = getOffsetWidth(retobj.txt, initFont, chartId);
        txtH = getOffsetHeight(retobj.txt, initFont, chartId);
        if(txtW < mbox.height && txtH < mbox.width) {
          retobj.isV = true;
          isOK = true;
        }
      }
    }
    if (!isOK)
      retobj.txt = "";
  }
  else {
    if (txtW > mbox.width) {
      initFont.size = initFont.size - initFont.size * fontRed;
      txtW = getOffsetWidth(retobj.txt, initFont, chartId);
      if (txtW > mbox.width)
        retobj.txt = "";
    }
    if (txtH > mbox.height && !Empty(retobj.txt)) {
      initFont.size = initFont.size - initFont.size * fontRed;
      txtH = getOffsetHeight(retobj.txt, initFont, chartId);
      if (txtH > mbox.height)
        retobj.txt = "";
    }
  }
  retobj.font = JSON.stringify(initFont);
  retobj.txtH = getOffsetHeight(retobj.txt, initFont, chartId);
  retobj.txtW = getOffsetWidth(retobj.txt, initFont, chartId);
  return retobj;
}

function getChartMacroCategoryType(type) {
  switch (type) {
    case "SCATTER":
    case "BUBBLE":
    case "ASTER":
    case "AREABAR":
      return "xyz";
      break;
    case "GEOMAP":
      return "geo";
      break;
    case "SUNB":
    case "SUNBSTR":
    case "TREE":
    case "TREESTR":
    case "CPACK":
    case "CPACKSTR":
    case "FORCE":
    case "MARIMEKKO":
      return "hie";
      break;
    case "FORCESTR":
    case "MATRIX":
      return "dep";
    default:
      return "category";
      break;
  }
}

function setDefaultChart(o1, webroot) {
  var o2 = getDefaultObjChartDef(webroot);
  var ret = mergeDeep (o1, o2);
  if (o2 && o2.globalSettings)
    ret.globalSettings.fileVersion = o2.globalSettings.fileVersion;
  return ret;
}

function getDefaultObjChartDef(webroot) {
  if (Empty(webroot)) {
    if (ZtVWeb && !Empty(ZtVWeb.SPWebRootURL))
      webroot = ZtVWeb.SPWebRootURL;
    else 
      webroot = '..';
  }
  var def = new JSURL(webroot + "/servlet/SPChartServlet?action=getDefault", true);
  def = def.Response();
  if (def.charAt(0) != "{" || def == "ACCESS DENIED")
    return {};
  return JSON.parse(def);
}

function mergeDeep (o1, o2) {
    var tempNewObj = o1;
    if(o1==null) return o2;
    //if o1 is an object - {}
    if(o1.length === undefined && typeof o1 !== "number" && typeof o1 != "function") {
      for(var key in o2){
        if(typeof o2[key]=="function")
          continue;
        var value = o2[key];
        if(o1[key] === undefined) {
          tempNewObj[key] = value;
        } else {
          tempNewObj[key] = mergeDeep(o1[key], o2[key]);
        }
      }
    }
    //else if o1 is an array - []
    else if(o1.length > 0 && typeof o1 !== "string" && typeof o1 != "function") {
      for(var indexc in o2){
        if(typeof o2[indexc] == "function")
          continue;
        if(o1[indexc] === undefined){
          tempNewObj.push(o2[indexc]);
        }
        else{
          var tmp = mergeDeep(o1[indexc], o2[indexc]);
          tempNewObj[indexc] = tmp;
        }
      };
    }
    //handling other types like string or number
    else if(typeof o1 != "function"){
      //taking value from the second object o2
      //could be modified to keep o1 value with tempNewObj = o1;
      //if(typeof o1 !== "undefined") -- corretto EG
      if(/*(Empty(o2+"") && !Empty(o1+"")) || (!Empty(o2+"") && !Empty(o1+"") && */o1!==o2)
        tempNewObj = o1;
      else
        tempNewObj = o2;
    }
    return tempNewObj;
}

function getList(index, dataSet, dup) {
	var array = [];
	if (index >= 0) {
		dataSet.forEach(function (record) {
      if( record != null ) {
        if (dup)
          array.push(record[index]);
        else if (array.indexOf(record[index]) < 0)
          array.push(record[index]);
      }
		});
	}
	return array;
}

function getListBySeries(index, dataSet, seriesIndex, dup) {
  var array = [],
  value;
	if (index >= 0 && seriesIndex >= 0) {
		dataSet.forEach(function (record) {
      if( record != null ) {
        if(!array[record[seriesIndex]])
          array[record[seriesIndex]] = [];
        value = parseFloat(record[index]);
        if (dup)
          array[record[seriesIndex]].push(value);
        else if (array[record[seriesIndex]].indexOf(value) < 0)
          array[record[seriesIndex]].push(value);
      }
		});
	}
	return array;
}

function getDuplicatesList(index, dataSet, mcounter) {
	var array = [];
	var count = [];
  var setCount = false;
	if(index!=-1){
		dataSet.forEach(function(record){
      if( record !=null ) {
        if((Empty(mcounter) || (mcounter && !mcounter[record[index].toString()])) && array.indexOf(record[index])<0 && array.indexOf(record[index].toString() + " ("+count[record[index].toString()]+")")<0){
          array.push(record[index].toString());
          count[record[index].toString()] = 1;
        }
        else {
          if (mcounter && mcounter[record[index].toString()] && !setCount) {
            count[record[index].toString()] = mcounter[record[index].toString()];
            setCount = true;
          }
          if (count[record[index].toString()]==1)
            array[array.indexOf(record[index].toString())] = record[index].toString() + " ("+count[record[index].toString()]+")";
          count[record[index].toString()]++;
          array.push(record[index].toString() + " ("+count[record[index].toString()]+")");
        }
     }
		});
	}
	return {array:array, countobj:count};
}

function getDuplicatesListXYZ(keyidx, dupidx, dataSet, mcounter) {
	var array = [];
	var karray = [];
	var count = [];
  var setCount = false;
	if (keyidx != -1) {
		dataSet.forEach(function(record) {
      if( record !=null ) {
        if (karray.indexOf(record[keyidx]) < 0) {
          karray.push(record[keyidx].toString());
          if ((Empty(mcounter) || (mcounter && !mcounter[record[dupidx].toString()])) && !count[record[dupidx].toString()]) {
            count[record[dupidx].toString()] = 1;
            array.push(record[dupidx].toString());
          }
          else {
            if (mcounter && mcounter[record[dupidx].toString()] && !setCount) {
              count[record[dupidx].toString()] = mcounter[record[dupidx].toString()];
              setCount = true;
            }
            if(count[record[dupidx].toString()]==1)
              array[array.indexOf(record[dupidx].toString())] = record[dupidx].toString() + " ("+count[record[dupidx].toString()]+")";
            count[record[dupidx].toString()] ++;
            array.push(record[dupidx].toString() + " (" + count[record[dupidx].toString()] + ")");
          }
        }
      }
		});
	}
	return {array:array, countobj:count};
}

function getAbsList(index, dataSet, dup) {
	var array = [];
	if (index >= 0) {
		dataSet.forEach(function (record) {
      if( record != null ) {
        if (dup)
          array.push(Math.abs(record[index]));
        else if (array.indexOf(record[index]) < 0)
          array.push(Math.abs(record[index]));
      }
		});
	}
	return array;
}

function getValues(valueFields, propertyName, dataSet) {
	var ret = [];
	valueFields.forEach(function (values) {
    if (!Empty(values)) {
      var indexVal = propertyName.indexOf(values);
      dataSet.forEach(function(record) {
        if( record!= null )
        ret.push(parseFloat(record[indexVal]));
      });
    }
	});
	return ret;
}

function decimalPlaces(num) {
  var match = ('' + num).match(/(?:\.(\d+))?(?:[eE]([+-]?\d+))?$/);
  if (!match) { return 0; }
  return Math.max(
          0,
          // Number of digits right of decimal point.
          (match[1] ? match[1].length : 0)
          // Adjust for scientific notation.
          - (match[2] ? +match[2] : 0)
        );
}

function getLegendSize(chartId, list, settings, chartLegendObj, gradient, isrange) {
	var h = 0,
  w = 0,
	offset = 5,
	check = false,
  icon = isrange ? 0 : 14,
  font = appliedFont(settings, chartLegendObj.obj, chartLegendObj.obj.textFont),
  sum = 0;

  if (!isrange || gradient == "none" || Empty(gradient)) {
    var i;
    switch (chartLegendObj.position) {
      case "top":
      case "bottom":
        for (i = 0; i < list.length; i++) {
          h = Math.max(14, getOffsetHeight(list[i], font, chartId));
          w += icon + 16 + getOffsetWidth(list[i], font, chartId);
          sum += w;
        }
        h = h + offset;
        if (sum >= settings.globals.width)
          check = true;
        break;
      case "left":
      case "right":
        w = (4 * offset) + icon + 16 + getOffsetWidth(getMaxWordLengthString(list), font, chartId);
        h = 5;
        for (i = 0; i < list.length; i++) {
          h += getOffsetHeight(list[i], font, chartId) + offset;
        }
        break;
      case "hide":
        break;
    }
  }
  else if (isrange) {
    switch (chartLegendObj.position) {
      case "top":
      case "bottom":
        w = settings.globals.width * 0.75;
        h = 14 + 15 + getOffsetHeight(getMaxWordLengthString(list), font, chartId);
        break;
      case "left":
      case "right":
        h = settings.globals.height * 0.75;
        w = 14 + 15 + getOffsetWidth(getMaxWordLength(list), font, chartId);
        break;
      case "hide":
        break;
    }
  }
	return {width: Math.round(w), height: Math.round(h), tooLong: check};
}

function appliedFont(chartSettings, labelObj, objFont) {
	var ret = objFont;
  if (labelObj.useLegendFont)
    ret = appliedFont(chartSettings, chartSettings.chartLegend, chartSettings.chartLegend.textFont);
	else if (labelObj.useValueFont)
    ret = appliedFont(chartSettings, chartSettings.valueAxis, chartSettings.valueAxis.valueFont);
  else if (labelObj.useGlobalFont)
    ret = chartSettings.globalFont;
	return ret;
}

function getOffsetHeight(labelText, labelFont, chartId) {
	var mySpan = getSpanTag(chartId);
	if (labelText != "") {
		mySpan.innerHTML = labelText;
		mySpan.style.fontFamily = labelFont.name;
		mySpan.style.fontStyle = labelFont.style;
		mySpan.style.fontWeight = labelFont.weight;
		mySpan.style.fontSize = labelFont.size+'px';
		return mySpan.offsetHeight;
	}
	else
		return 0;
}

function getOffsetWidth(labelText, labelFont, chartId) {
	var mySpan = getSpanTag(chartId);
	if (labelText != "") {
		mySpan.innerHTML = labelText;
		mySpan.style.fontFamily = labelFont.name;
		mySpan.style.fontStyle = labelFont.style;
		mySpan.style.fontWeight = labelFont.weight;
		mySpan.style.fontSize = labelFont.size+'px';
		return mySpan.offsetWidth;
	}
	else
		return 0;
}

function getSpanTag(chartId) {
	var spanId = chartId+"myspan";
	var mySpan = document.getElementById(spanId);
	if(Empty(mySpan)){
		mySpan = document.createElement("span");
		mySpan.id = spanId;
		mySpan.className = "ztchart_span";
		document.body.appendChild(mySpan);
    if (spanId != "serverchart_myspan")
		  mySpan.style.visibility='hidden';
		mySpan.style.display='inline-block';
	}
	return mySpan;
}

function getGeneralMarginsObject(chartId, settings, chartLegends, title, legendList) {
  var ret = {};
  ret.top = [];
  ret.bottom = [];
  ret.left = [];
  ret.right = [];

  var myM={};

  //titolo
  myM = setMarginObject(title, settings.chartTitle.textFont, settings.chartTitle.useGlobalFont, settings.globalFont);
  if (myM != 0) {
    myM.type = "title";
    ret[settings.chartTitle.position].push(myM);
  }

  //legenda
  var ml, stroke;
  if (chartLegends.series && chartLegends.series.position != 'hide' && !chartLegends.series.hide) {
    myM = setMarginObject(getMaxWordLength(legendList), chartLegends.series.obj.textFont, chartLegends.series.obj.useGlobalFont, settings.globalFont);
    ml = getLegendSize(chartId, legendList, settings, chartLegends.series);
    myM.addH = ml.height;
    myM.addW = ml.width;
    stroke = chartLegends.series.obj.extendLine.stroke?chartLegends.series.obj.extendLine.stroke:1;
    if (myM != 0) {
      myM.type = "legend_series";
      myM.offset = 5;
      if (chartLegends.series.position == 'left') {
        myM.textorientation = 0;
        myM.offset = 10;
        myM.addW = myM.addW + 2 * stroke;
        ret.left.push(myM);
      }
      else if (chartLegends.series.position == 'right') {
        myM.textorientation = 0;
        myM.offset = 10;
        myM.addW = myM.addW + 2 * stroke;
        ret.right.push(myM);
      }
      else if (chartLegends.series.position == 'bottom')
        ret.bottom.push(myM);
      else
        ret.top.push(myM);
    }
  }

  //sottotitolo
  if(settings.chartSubtitle){
    myM = setMarginObject(settings.chartSubtitle.text, settings.chartSubtitle.textFont, settings.chartSubtitle.useGlobalFont, settings.globalFont);
    if (myM != 0) {
      myM.type = "subtitle";
      myM.offset = 5;
      ret[settings.chartSubtitle.position].push(myM);
    }
  }

  //legenda range
  if (chartLegends.range && chartLegends.range.position != 'hide' && !chartLegends.range.hide) {
    myM = setMarginObject(getMaxWordLengthString(settings.range.labels), chartLegends.range.obj.textFont, chartLegends.range.obj.useGlobalFont, settings.globalFont);
    ml = getLegendSize(chartId, settings.range.labels, settings, chartLegends.range, settings.range.gradient, true);
    myM.addH = ml.height;
    myM.addW = ml.width;

    stroke = chartLegends.range.obj.extendLine.stroke ? chartLegends.range.obj.extendLine.stroke : 1;
    if (myM != 0) {
      myM.type = "legend_range";
      if (chartLegends.range.position == 'left') {
        myM.textorientation = 0;
        myM.addW = myM.addW + 2 * stroke;
        ret.left.push(myM);
      }
      else if (chartLegends.range.position == 'right') {
        myM.textorientation = 0;
        myM.addW = myM.addW + 2 * stroke;
        ret.right.push(myM);
      }
      else if (chartLegends.range.position == 'bottom')
        ret.bottom.push(myM);
      else
        ret.top.push(myM);
    }
  }

  return ret;
}

function setMarginObject(item, itemFont, useGlobalFont, globalFont) {
	var obj;
	if(item && item.length>0){
		if(useGlobalFont == true)
			obj = getGenericLabelConf(itemFont, globalFont);
		else
			obj = getGenericLabelConf(itemFont);
		obj.textorientation = 90;
		obj.text = item;
		return obj;
	}
	else
		return 0;
}

function getMaxWordLength(myList, precision, fnc) {
  if (precision == undefined)
    precision = 0;
	var myMax = LRTrim(setPrecision(myList[0]));
	for(var i=1; i<myList.length; i++){
    var m = LRTrim(setPrecision(myList[i]));
		if(m.length > myMax.length)
			myMax = m;
	}
	return myMax;

  function setPrecision(mval){
    var msval = mval + "";
    if (Empty(msval))
      return "";
    var mm = msval.toString();
    var isNumber = !isNaN(parseFloat(msval));
    if(isNumber){
      mm = parseFloat(mm).toFixed(precision);
    }
    if(fnc) {
      mm = fnc(mm);
    }
    if(isNumber) mm = mm + "W"; //spacing per i numeri
    return mm;
  }
}

function getMaxWordLengthString(myList/*, fnc*/) {
	var myMax = LRTrim(myList[0] + "");
	for(var i=1; i<myList.length; i++){
		var m = LRTrim(myList[i] + "");
		if(m.length >= myMax.length)
			myMax = m;
	}
	return myMax;
}

function getGenericLabelConf(labeljson, globalfont) {
	var myM={};
	if(Empty(globalfont)){
		myM.fontname = labeljson.name;
		myM.fontsize = labeljson.size;
		myM.fontstyle = labeljson.style;
	}
	else{
		myM.fontname = globalfont.name;
		myM.fontsize = globalfont.size;
		myM.fontstyle = globalfont.style;
	}

	// selezione per id
	if(myM.fontstyle=="B"){
		myM.fontstyle = 'normal';
		myM.fontweight = 'bold';
	}
	else if(myM.fontstyle=="I"){
		myM.fontstyle = 'italic';
		myM.fontweight = '';
	}
	else if(myM.fontstyle=="BI"){
		myM.fontstyle = 'italic';
		myM.fontweight = 'bold';
	}
	else{
		myM.fontstyle = 'normal';
		myM.fontweight = '';
	}

	return myM;
}

function getMargin(myMzone, spanTag) {
	var ret = 0;
	var h=0;
	for(var i=0; i<myMzone.length; i++){
		h=0;
		spanTag.innerHTML = myMzone[i].text;
		spanTag.style.fontFamily = myMzone[i].fontname;
		spanTag.style.fontStyle = myMzone[i].fontstyle;
		spanTag.style.fontWeight = myMzone[i].fontweight;
		spanTag.style.fontSize = myMzone[i].fontsize+'px';
		if(myMzone[i].textorientation == 90) { //top + bottom
			if(myMzone[i].offset)
				h+=myMzone[i].offset;
			if(myMzone[i].addH)
				h+=myMzone[i].addH;
			else
				h+=spanTag.offsetHeight;
		}
		else if(myMzone[i].textorientation == 45 || myMzone[i].textorientation == -45) {
			if(myMzone[i].offset)
				h+=myMzone[i].offset;
			if(myMzone[i].addW)
				h+=myMzone[i].addW;
			else
				 //h+=(spanTag.offsetWidth*Math.cos(45*Math.PI/180));
				//h += Math.sqrt(Math.pow(spanTag.offsetHeight, 2) + Math.pow(spanTag.offsetWidth, 2));
				h += Math.max(spanTag.offsetWidth, spanTag.offsetHeight) - Math.min(spanTag.offsetWidth, spanTag.offsetHeight);
		}
		else { //left + right
			if(myMzone[i].offset)
				h+=myMzone[i].offset;
			if(myMzone[i].addW)
				h+=myMzone[i].addW;
			else
				h+=spanTag.offsetWidth;
		}
		ret+=h;
		myMzone[i].height=h
	}
	return ret;
}

var notifyDraw = function(obj, fn) {
	if (obj.drawingState) {
		obj.lastDrawFnc = fn;
		obj.lastDrawArgs = arguments;
		obj.lastDrawCounters ++;
	}
	else {
		obj.drawingState = true;
		var _arguments = arguments;
		if (obj.lastDrawTimer) clearTimeout(obj.lastDrawTimer);
		obj.lastDrawTimer = setTimeout(function (_arguments) {
            var args=[], i, l;
			obj.drawingState = false;
			if (obj.lastDrawFnc) {
				for(i=2,l=obj.lastDrawArgs.length; i<l; args.push(obj.lastDrawArgs[i++]));
					obj[obj.lastDrawFnc].apply(obj,args);
			}
			else {
				for(i=2,l=_arguments.length; i<l; args.push(_arguments[i++]));
					obj[fn].apply(obj,args);
			}
			obj.lastDrawCounters=0
			obj.lastDrawFnc=null;
			obj.lastDrawArgs=null;
		}, (!obj.drawStatic || obj.lastDrawCounters == 0) ? 0 : (obj.defSettings.animation.animate ? 2 * obj.defSettings.animation.duration : 500), _arguments);
	}
}

function getIconFromCode(hexcode) {
  return String.fromCharCode(parseInt(hexcode, 16));
}

function getTreemapDataset(data, indexCat, valueFields, propertyName, seriesList, keyF, categoryCodeIndex, byCategory, noGroup) {
  var treeMapData = { children : [], name : "root" },
  key = !Empty(keyF) ? propertyName.indexOf(keyF) : -1,
  catLab,
  serLab,
  i, j,
  //keyList,
  arrayData,
  idx;

  if (byCategory) {
    for (i = 0; i < data.length; i++) {
      arrayData = [];
      catLab = data[i][indexCat];
      for (j = 0; j < valueFields.length; j++) {
        idx = propertyName.indexOf(valueFields[j]);
        serLab = seriesList[j];
        arrayData.push({
          name : catLab,
          size : Math.abs(data[i][idx]),
          realValue : data[i][idx],
          serie : serLab,
          keyF : data[i][key],
          categoryCode : data[i][categoryCodeIndex],
          index : i,
          vIndex : j
        });
      }
      treeMapData.children.push({
        name : catLab,
        keyF : data[i][key],
        categoryCode : data[i][categoryCodeIndex],
        children : arrayData
      });
    }
  }
  else if (noGroup) {
    arrayData = [];
    for (i = 0; i < data.length; i++) {
      catLab = data[i][indexCat];
      for (j = 0; j < valueFields.length; j++) {
        idx = propertyName.indexOf(valueFields[j]);
        serLab = seriesList[j];
        arrayData.push({
          name : catLab,
          size : Math.abs(data[i][idx]),
          realValue : data[i][idx],
          serie : serLab,
          keyF : data[i][key],
          categoryCode : data[i][categoryCodeIndex],
          index : i,
          vIndex : j
        });
      }
    }
    treeMapData.children = arrayData;
  }
  else {
    for (j = 0; j < valueFields.length; j++) {
      arrayData = [];
      idx = propertyName.indexOf(valueFields[j]);
      for (i = 0; i < data.length; i++) {
        catLab = data[i][indexCat];
        serLab = seriesList[j];
        arrayData.push({
          name : catLab,
          size : Math.abs(data[i][idx]),
          realValue : data[i][idx],
          serie : serLab,
          keyF : data[i][key],
          categoryCode : data[i][categoryCodeIndex],
          index : i,
          vIndex : j
        });
      }
      treeMapData.children.push({
        name : valueFields[j],
        children : arrayData
      });
    }
  }

  return treeMapData;
}

function getWaterfallDifferenceDataset(dataset, withTotal) {
  if (Empty(dataset))
    return [];
  var ret = [];
  dataset.forEach(function (data, index) {
    ret.push(data.slice());
    if (!withTotal || index <= dataset.length - 2) {
      if (index == 0)
        ret[index][1] = 0;
      else
        ret[index][1] = dataset[index - 1][1];
    }
  });
  return ret;
}

function getRadarDataset(dataset, scaleY, width, height, angleRange, valueFields, propertyName) {
  if (Empty(dataset) || !scaleY)
    return [];
  var ret = [],
  obj = {},
  yIndex = -1,
  scale;
  dataset.forEach(function (data/*, index*/) {
    ret.push([]);
    for (var i = 0; i < valueFields.length; i++) {
      yIndex = propertyName.indexOf(valueFields[i]);
      scale = scaleY[valueFields[i]];
      obj = {};
      obj.x = width / 2 - (((height / 2 - scale(data[yIndex])) - height / 2) * Math.sin(angleRange[i] * Math.PI / 180));
      obj.y = height / 2 + (((height / 2 - scale(data[yIndex])) - height / 2) * Math.cos(angleRange[i] * Math.PI / 180));
      obj.yIndex = yIndex;
      ret[ret.length-1].push(obj);
    }
  });
  return ret;
}

function getParetoDataset(dataset) {
  if (Empty(dataset))
    return {data: [], sum: 0};
  var ret = [],
  sum = 0,
  val;
  dataset.forEach(
    function (record) {
      val = record.slice();
      val[1] = Math.abs(val[1]);
      ret.push(val.slice());
      sum = sum + val[1];
    }
  );
  ret.sort(
    function (a, b) {
      return d3.descending(a[1], b[1]);
    }
  );
  return {data: ret, sum: sum};
}

function getParetoLineDataset(dataset) {
  if (Empty(dataset))
    return [];
  var ret = [],
  pdata = getParetoDataset(dataset),
  sup = pdata.data,
  tmp = 0;
  sup.forEach( function (record/*, index*/) {
    ret.push(record.slice());
    tmp = tmp + record[1];
    ret[ret.length-1][1] = tmp;
  });
  return ret;
}

function getWordMinMaxIndex(valueFields, propertyName, dataSet, indexCat){
  var mval = 0,
  ret = {min: 0, max: 0, index: -1},
  y_index;
  for (var i = 0; i < valueFields.length; i++) {
    y_index = propertyName.indexOf(valueFields[i]);
    for (var j = 0; j < dataSet.length; j++) {
      ret.min = Math.min(ret.min, Math.abs(dataSet[j][y_index]));
      ret.max = Math.max(ret.max, Math.abs(dataSet[j][y_index]));
      if (mval < (dataSet[j][indexCat].length * Math.abs(dataSet[j][y_index]))){   // replace with W*len
        /** siccome la parola piu' lunga potrebbe non essere quella con valore dato maggiore
          * valuto la massima parola rapportando la sua lunghezza con il suo valore
         **/
        mval = dataSet[j][indexCat].length * Math.abs(dataSet[j][y_index]);
        ret.index = j;
      }
    }
  }
  return ret;
}

function getMeasureMinMax(valueFields, dataSet, propertyName) {
  // suppongo siano gli stessi per ogni categoria - se fossero diversi, avrei piu' assi
	var ret = [],
  indexVal;
	valueFields.forEach( function (values) {
		indexVal = propertyName.indexOf(values);
    if (indexVal >= 0 && indexVal < dataSet[0].length)
      ret.push(dataSet[0][indexVal]);
	});
	return ret;
}

function howManyDigits(num) {
  if (typeof num != "number")
    return num.length;
	var i=-1;
	var tmp=10;
	while(tmp>=1){
		i++;
		tmp=Math.abs(num)/Math.pow(10,i);
	}
	return i;
}

function isNumberFloat(n) {
  return n===Number(n) && n%1!==0;
}

function estimateMaximumTickLabel(type, minR, maxR, chartId, font, precision) {
	precision = Empty(precision) ? 0 : precision;
  var result = 8.0,
  min = minR.toFixed(precision),
  max = maxR.toFixed(precision);

	switch (type) {
		case "width":
			result += Math.max(getOffsetWidth(min, font, chartId), getOffsetWidth(max, font, chartId));
			break;
		case "height":
			result += getOffsetHeight(min, font, chartId);
			break;
	}
  result += 1;  // aggiungo +1 offset per non avere le etichette dell'asse appiccicate tra loro
	return result;
}

Array.prototype.binarySearch=function(searchElement) {
	var minIndex = 0;
	var maxIndex = this.length - 1;
	var currentIndex;
	var currentElement;

	while (minIndex <= maxIndex) {
		currentIndex = (minIndex + maxIndex) / 2 | 0;
		currentElement = this[currentIndex];

		if(currentElement < searchElement) {
			minIndex = currentIndex + 1;
		}
		else if(currentElement > searchElement) {
			maxIndex = currentIndex - 1;
		}
		else {
			return currentIndex;
		}
	}

	return -1;
}

function getLargerTickUnit(tickUts,unit){	// ritorna l'indice del valore maggiore rispetto all'unita'  passata
	var index = tickUts.binarySearch(unit);
	if(index >= 0) {
		index = index + 1;
	}
	else {
		index = -index;
	}

	return Math.min(index,tickUts.length-1);
}

function getCeilingTickUnit(tickUts, unit) {	// ritorna l'indice del valore maggiore o uguale dell'unita' passata per parametro
	for(var i=0; i<tickUts.length; i++){
		if(tickUts[i]>=unit)
			return i;
	}
	return tickUts.length-1;
}

function getStandardTickUnits(maxLen, isFloat, isPerc) {
	if (isFloat)
		return getFloatStandardTickUnits(maxLen,isPerc);
	else
		return getIntStandardTickUnits(maxLen,isPerc);
}

function getFloatStandardTickUnits(maxLen, isPerc) {	//unità di misura tick di deafult
	var ret=[], pow=0, i;
	for(i=-1; i<maxLen; i++){
		pow=Math.pow(10,i);
		ret.push(1*pow);
    if(i>=0)
      ret[ret.length-1]+=0.5;
		ret.push(2*pow);
		if(i>=0)
      ret[ret.length-1]+=0.5;
		ret.push(5*pow);
	}
	ret.push(1*Math.pow(10,maxLen));
	if(isPerc){
		for(i=0; i<ret.length; i++)
			ret[i]=ret[i]/100;
	}
	return ret;
}

function getIntStandardTickUnits(maxLen, isPerc) {	//unita' di misura tick di deafult
	var ret=[], pow=0, i;
	for(i=0; i<maxLen; i++){
		pow=Math.pow(10,i);
		ret.push(1*pow);
		ret.push(2*pow);
		ret.push(5*pow);
	}
	ret.push(1*Math.pow(10,maxLen));
	if(isPerc){
		for(i=0; i<ret.length; i++)
			ret[i]=ret[i]/100;
	}
	return ret;
}

function setTicks(min, max, tUnit, precision, bypassPrecision) {
  var tickCount = [],
  tmp = min;
  var tmp2;
  while (tmp <= max) {
    if (!bypassPrecision && (precision || precision == 0))
      tmp2 = parseFloat(tmp.toFixed(precision));
    else
      tmp2 = tmp;
    if (Empty(tmp2))
      tmp2 = Math.abs(tmp2);
    if (tickCount.indexOf(tmp2) < 0)
      tickCount.push(tmp2);
    tmp = parseFloat(tmp) + parseFloat(tUnit);
  }
  return tickCount;
}

function makeStyleHTMLString(stObj, orgStyle) {
	var ret = "",
  rret = "";
	for (var key in stObj) {
    ret = "";
    var prop = key,
    value = stObj[key];
		if (key.indexOf("ms") == 0 || key.indexOf("moz") == 0 || key.indexOf("webkit") == 0)
      prop = ("-" + key);
		if (key.indexOf("9") >= 0)
      prop = prop.replace(/9/g, "-");
		if (stObj[key] == 'transparent' || (Empty(stObj[key]) && (key == 'fill' || key == 'stroke'))) {
      prop += "-opacity";
      value = 0;
    }
    else if ((stObj[key] + "").indexOf("rgba") >= 0) {
      var tmpcol = "";
      value = Strtran(value, "rgba(", "");
      value = Strtran(value, ")", "");
      value = Strtran(value, " ", "");
      value = value.split(",");
      tmpcol = (prop + "-opacity:" + value[value.length - 1] + ";");
      ret += tmpcol;
      value.pop();
      value = "rgb(" + value.toString() + ")";
    }

    ret += (prop + ":" + value + ";");

    if (orgStyle) {
      orgStyle = Strtran(orgStyle, "; ", ";");
      orgStyle = Strtran(orgStyle, ": ", ":");
      ret = Strtran(ret, "; ", ";");
      ret = Strtran(ret, ": ", ":");
      if (orgStyle.indexOf(ret) >= 0)
        orgStyle = Strtran(orgStyle, ret, "");
    }

    rret += ret;
	}
	if (!orgStyle)
		return rret;
	else
		return orgStyle + rret;
}

function setColorSeriesArray(colors, list, reuseColor, onlyOrg) {
	var ret = [], i;
  if (colors && (!Empty(colors) || colors.length > 0))
    ret = ret.concat(colors);
  if (reuseColor && ret.length > 0) {
    var diff = Math.abs(ret.length - list.length);
    var coln = ret.length;
    var k = Math.ceil(diff / coln);
    for (i = 0; i < k; i++) {
      for (var j = 0; j < coln; j++)
        ret.push(ret[j]);
    }
  }
  else if (!onlyOrg) {
    ret = ret.concat(getAllDefaultColors());
		var listColor = [];
    var d3Color = d3.scaleOrdinal(d3.schemeCategory20);
    for (i = 0; i < 20; i++) {
      listColor[i] = {color:d3Color(i), gradient:""};
		}
		d3Color = d3.scaleOrdinal(d3.schemeCategory20b);
		for (i = 0; i < 20; i++) {
      listColor[i + 20] = {color:d3Color(i), gradient:""};
		}
		d3Color = d3.scaleOrdinal(d3.schemeCategory20c);
		for (i = 0; i < 20; i++) {
      listColor[i + 40] = {color:d3Color(i), gradient:""};
		}
    ret = ret.concat(listColor);
    var dupes = getDupColors(ret).sort(function(a, b){ return b-a; });
    for(i = 0; i < dupes.length; i++)
      ret.splice(dupes[i], 1);
    if (list && ret.length < list.length) {
      var coldiff = list.length - ret.length;
      for (i = 0; i < coldiff; i++)
        ret.push( {color:getRandomColor(), gradient:""} );
    }
  }
	return ret;
}

function getAllDefaultColors(onlyColor) {
  var ret = [],
  oColors = getWizardSeriesColor(),
  key;
  for (key in oColors) {
    ret = ret.concat(oColors[key].graphSettings.colorSeries.map(function(c_obj){
      if (onlyColor)
        return c_obj.color;
      return c_obj;
    }));
  }
  oColors = getZSeriesColor();
  for (key in oColors) {
    ret = ret.concat(oColors[key].graphSettings.colorSeries.map(function(c_obj){
      if (onlyColor)
        return c_obj.color;
      return c_obj;
    }));
  }
  return ret;
}

function getWizardSeriesColor() {
  var wizardSeriesColor = {
    simple: {
      graphSettings:{
        colorSeries:[
          {color:'#1BA1E2',gradient:''},
          {color:'#E51400',gradient:''},
          {color:'#FA6800',gradient:''},
          {color:'#F0A30A',gradient:''},
          {color:'#A4C400',gradient:''},
          {color:'#60A917',gradient:''},
          {color:'#008A00',gradient:''},
          {color:'#647687',gradient:''}
        ]
      }
    },
    deep: {
      graphSettings:{
        colorSeries:[
          {color:'#2196F3',gradient:''},
          {color:'#A20021',gradient:''},
          {color:'#FB5607',gradient:''},
          {color:'#FBBE0b',gradient:''},
          {color:'#99C24D',gradient:''},
          {color:'#53A548',gradient:''},
          {color:'#28502E',gradient:''},
          {color:'#706F6F',gradient:''}
        ]
      }
    },
    flat: {
      graphSettings:{
        colorSeries:[
          {color:'#2980B9',gradient:''},
          {color:'#E74C3C',gradient:''},
          {color:'#E67E22',gradient:''},
          {color:'#F1C40F',gradient:''},
          {color:'#2ECC71',gradient:''},
          {color:'#1ABC9C',gradient:''},
          {color:'#7F8C8D',gradient:''},
          {color:'#2C3E50',gradient:''}
        ]
      }
    }
    /*google: {
      graphSettings:{
        colorSeries:[
          {color:'#3284FF',gradient:''},
          {color:'#FF3424',gradient:''},
          {color:'#FF8200',gradient:''},
          {color:'#FFBB00',gradient:''},
          {color:'#26B14C',gradient:''},
          {color:'#656565',gradient:''},
          {color:'#E6E6E6',gradient:''},
          {color:'#1A1A1A',gradient:''}
        ]
      }
    },
    evidence: {
      graphSettings:{
        colorSeries:[
          {color:'#09DDBC',gradient:''},
          {color:'#6BA5C1',gradient:''},
          {color:'#1C31E8',gradient:''},
          {color:'#360F35',gradient:''},
          {color:'#A20025',gradient:''},
          {color:'#FF4900',gradient:''},
          {color:'#FE8A62',gradient:''},
          {color:'#FFDE00',gradient:''}
        ]
      }
    },
    precision: {
      graphSettings:{
        colorSeries:[
          {color:'#00ABA9',gradient:''},
          {color:'#004387',gradient:''},
          {color:'#E3C300',gradient:''},
          {color:'#46CF00',gradient:''},
          {color:'#7DA7D9',gradient:''},
          {color:'#6DCFF6',gradient:''},
          {color:'#D4547B',gradient:''},
          {color:'#34495E',gradient:''}
        ]
      }
    },
    original: {
      graphSettings:{
        colorSeries:[
          {color:'#0050EF',gradient:''},
          {color:'#F2477F',gradient:''},
          {color:'#F472D0',gradient:''},
          {color:'#BD8CBF',gradient:''},
          {color:'#AA00FF',gradient:''},
          {color:'#D80073',gradient:''},
          {color:'#6A00FF',gradient:''},
          {color:'#76608A',gradient:''}
        ]
      }
    }*/
  };
  return wizardSeriesColor;
}

function getWizardPlotColors() {
  var wizardPlotColors = {
    simple: { text:"#0D0F12", background:"transparent" },
    snow: { text:"#95A5A6", background:"#FFFFFF" },
    deep: { text:"#F5F5F5", background:"#2E393E" }
  };
  return wizardPlotColors;
}

function getZSeriesColor() {
  var zSeriesColor = {
    blue: { graphSettings:{
              colorSeries:[
                {color:'#003D81',gradient:''},
                {color:'#005FCC',gradient:''},
                {color:'#001E5A',gradient:''},
                {color:'#1F87FF',gradient:''},
                {color:'#70B3FF',gradient:''},
                {color:'#C2DEFF',gradient:''},
                {color:'#9EB5CF',gradient:''},
                {color:'#5981AD',gradient:''}
              ]
            }
          },
    red: { graphSettings:{
              colorSeries:[
                {color:'#72000F',gradient:''},
                {color:'#F40020',gradient:''},
                {color:'#F48449',gradient:''},
                {color:'#720600',gradient:''},
                {color:'#F25300',gradient:''},
                {color:'#F20D00',gradient:''},
                {color:'#722700',gradient:''},
                {color:'#F46C64',gradient:''}
              ]
            }
          },
    yellow: { graphSettings:{
              colorSeries:[
                {color:'#D98B0B',gradient:''},
                {color:'#E3E10B',gradient:''},
                {color:'#4C4A00',gradient:''},
                {color:'#B58C00',gradient:''},
                {color:'#FFF800',gradient:''},
                {color:'#D9A50A',gradient:''},
                {color:'#4C3B00',gradient:''},
                {color:'#CCB64A',gradient:''}
              ]
            }
          },
    green: { graphSettings:{
              colorSeries:[
                {color:'#004C1D',gradient:''},
                {color:'#43B200',gradient:''},
                {color:'#364C40',gradient:''},
                {color:'#31952D',gradient:''},
                {color:'#A6CC52',gradient:''},
                {color:'#51D900',gradient:''},
                {color:'#008C36',gradient:''},
                {color:'#63D496',gradient:''}
              ]
            }
          },
    grey: { graphSettings:{
        colorSeries:[
          {color:'#D8D1D6',gradient:''},
          {color:'#7D7D7D',gradient:''},
          {color:'#2A303C',gradient:''},
          {color:'#BBBBBB',gradient:''},
          {color:'#726068',gradient:''},
          {color:'#CACECF',gradient:''},
          {color:'#D8B5C4',gradient:''},
          {color:'#595959',gradient:''}
        ]
      }
    }
  };
  return zSeriesColor;
}

Array.prototype.unique = function () {
  var a = this.concat();
  for(var i=0; i<a.length; ++i) {
      for(var j=i+1; j<a.length; ++j) {
          if(a[i] === a[j])
              a.splice(j--, 1);
      }
  }
  return a;
}

function getDupColors(colors) {
  var idxs = [];
  for(var i=0; i<colors.length; i++) {
    for(var j=i+1; j<colors.length; j++) {
      if(colors[i].color.toLowerCase() === colors[j].color.toLowerCase()){
        if(colors[i].gradient && colors[j].gradient){
          if(colors[i].gradient.toLowerCase() === colors[j].gradient.toLowerCase())
            idxs.push(j);
        }
        else
          idxs.push(j);
      }
    }
  }
  return idxs.unique();
}

function getDomNodeWidth(node) {
  var w = 0;
  if (node.width && node.width.baseVal && node.width.baseVal[0])
    w = node.width.baseVal[0].value;
  else if (node.offsetWidth)
    w = node.offsetWidth;
  else if (node.getAttribute("width"))
    w = node.getAttribute("width");
  else if (node.getBBox)
    w = node.getBBox().width;
  return parseFloat(w);
}

function getDomNodeHeight(node) {
  var h = 0;
  if (node.height && node.height.baseVal && node.height.baseVal[0])
    h = node.height.baseVal[0].value;
  else if (node.offsetHeight)
    h = node.offsetHeight;
  else if (node.getAttribute("height"))
    h = node.getAttribute("height");
  else if (node.getBBox)
    h = node.getBBox().height;
  return parseFloat(h);
}

function getDomNodeTop(node) {
  var y = 0;
  if (node.y && node.y.baseVal && node.y.baseVal[0])
    y = node.y.baseVal[0].value;
  else if (node.offsetTop)
    y = node.offsetTop;
  else if (node.getAttribute("y"))
    y = node.getAttribute("y");
  else if (node.getBBox)
    y = node.getBBox().y;
  return parseFloat(y);
}

function getDomNodeLeft(node) {
  var x = 0;
  if (node.x && node.x.baseVal && node.x.baseVal[0])
    x = node.x.baseVal[0].value;
  else if (node.offsetLeft)
    x = node.offsetLeft;
  else if (node.getAttribute("x"))
    x = node.getAttribute("x");
  else if (node.getBBox)
    x = node.getBBox().x;
  return parseFloat(x);
}

function getDomNodeSizes(node) {
  return  { x : getDomNodeLeft(node),
            y : getDomNodeTop(node),
            width : getDomNodeWidth(node),
            height : getDomNodeHeight(node)
          };
}

function recursivediv(min, max, divmax, divmin, olddivmax) {
	if((max/divmax)>=(min/divmin)) return divmax;
	olddivmax = divmax;
	var t = divmax*divmin;
	divmin++;
	divmax=Math.ceil(t/divmin);
	if(olddivmax<=divmax) return olddivmax;
	return recursivediv(min, max, divmax, divmin, olddivmax);
}

function getStackDataset(valueFields, propertyName, dataSet, accumulate) {
  // accumulate indica se scindere le parti negative da positive (false) es. barre e non area
  var ret = [],
  tmp = 0,
  totP = 0,
  totN = 0,
  prec = 0;

  dataSet.forEach( function (record) {
    tmp = 0;
    totP = 0;
    totN = 0;
    ret.push(record.slice());
    var value;
    valueFields.forEach( function (values/*, index*/) {
      var indexVal = propertyName.indexOf(values);
      value = parseFloat(record[indexVal]);
      if (isNaN(value))
        value = 0;
      prec = Math.max(prec, decimalPlaces(value));
      if (!accumulate) {
        if (value >= 0) {
          totP = totP + value;
          ret[ret.length-1][indexVal] = totP;
        }
        else {
          totN = totN + value;
          ret[ret.length-1][indexVal] = totN;
        }
      }
      else {
        tmp = tmp + value;
        ret[ret.length-1][indexVal] = tmp;
      }
    });
  });

  ret.forEach( function (record) {
    valueFields.forEach( function (values/*, index*/) {
      var indexVal = propertyName.indexOf(values);
      record[indexVal] = parseFloat(record[indexVal]);
      record[indexVal] = parseFloat(record[indexVal].toFixed(prec));
    });
  });

  return ret;
}

function accumulateValuesOnColumn(dataSet, index) {
  var ret = [],
  tmp = 0;
  dataSet.forEach( function (record) {
    tmp = tmp + parseFloat(record[index]);
    ret.push(record.slice());
    ret[ret.length - 1][index] = tmp;
  });

  return ret;
}

function getMaxValueStack(indexCat, valueFields, dataSet, propertyName, abs) {
	var ret=[];
	var tmpCat=[];
  var va = valueFields;
  if( !Array.isArray(va)) va = va.split(',');
	va.forEach( function(values){
		var indexVal = propertyName.indexOf(values);
		dataSet.forEach( function(record){
			if (record[indexVal]>0 || abs) {
				if(tmpCat.indexOf(record[indexCat])>=0){
					ret[tmpCat.indexOf(record[indexCat])] += Math.abs(record[indexVal]);
				}
				else {
					tmpCat.push(record[indexCat]);
					ret.push(Math.abs(record[indexVal]));
				}
			}
		});
	});
	return ret;
}

function get3DColor(color) {
	return {  color: Empty(color.color) ? '' : d3.rgb(color.color).darker().toString(),
            gradient: Empty(color.gradient) ? '' : d3.rgb(color.gradient).darker().toString()
         }
}

function setOtherChartsArray(otherChart, mtype) {
  var ret = [];
  if (!Empty(otherChart)) {
    otherChart.split(",").forEach(function(type) {
      if (ret.indexOf(type) < 0 && (getChartMacroCategoryType(mtype) == getChartMacroCategoryType(type)))
        ret.push(type);
    });
  }
  return ret;
}

function getImgSrc(imgname, webRoot, applySpTheme) {
  var rootUrl;
	if (Empty(webRoot))
		rootUrl = ZtVWeb.SPWebRootURL;
	else
		rootUrl = webRoot;
	var ret;
	if (applySpTheme)
		ret = "url(" + rootUrl + "/" + ZtVWeb.theme + "/formPage/";
	else
		ret = "url(" + rootUrl + "/portalstudio/formPage/";
	ret += imgname;
	return ret + ")";
}

function getScrollTop(oElement) {
  var iReturnValue = 0;
  while (oElement != null && iReturnValue == 0 && oElement.tagName.toLowerCase() != "body") {
    iReturnValue += oElement.scrollTop;
    oElement = oElement.parentElement;
  }
  return iReturnValue;
}

function getY(oElement) {
  var iReturnValue = 0;
  while (oElement != null) {
    iReturnValue += oElement.offsetTop;
    oElement = oElement.offsetParent;
  }
  return iReturnValue;
}

function getX(oElement) {
  var iReturnValue = 0;
  while (oElement != null) {
    iReturnValue += oElement.offsetLeft;
    oElement = oElement.offsetParent;
  }
  return iReturnValue;
}

function applyChartMenuFnc(type, chartId, isdownload) {
	if (myZtCharts[chartId]) {
		if (CharToBool(isdownload))
			myZtCharts[chartId].downloadChart(type, chartId);
		else
      myZtCharts[chartId].changeChartType(type, chartId);

    if (window[myZtCharts[chartId].chartId + "onMenuClick"])
        window[myZtCharts[chartId].chartId + "onMenuClick"]({ action : CharToBool(isdownload) ? "downloadChart" : "changeChartType" });
    else if (myZtCharts[chartId].parentCtrl && myZtCharts[chartId].parentCtrl.dispatchEvent)
      myZtCharts[chartId].parentCtrl.dispatchEvent("onMenuClick", d3.event, { action : CharToBool(isdownload) ? "downloadChart" : "changeChartType" });

	}
}

function replaceSpecialCharsForFileName(mtext) {
  var ret = mtext + "";
  ret = Strtran(ret, "\\", "");
  ret = Strtran(ret, "/", "");
  ret = Strtran(ret, ":", "");
  ret = Strtran(ret, "*", "");
  ret = Strtran(ret, "?", "");
  ret = Strtran(ret, "\"", "");
  ret = Strtran(ret, "<", "");
  ret = Strtran(ret, ">", "");
  ret = Strtran(ret, "|", "");
  return ret;
}

function replaceSpecialCharsForID(mtext) {
  var ret = encodeURIComponent(mtext) + "";
  ret = Strtran(ret, " ", "_");
  ret = Strtran(ret, "\\", "_");
  ret = Strtran(ret, "/", "_");
  ret = Strtran(ret, ":", "_");
  ret = Strtran(ret, "*", "_");
  ret = Strtran(ret, "?", "_");
  ret = Strtran(ret, "\"", "_");
  ret = Strtran(ret, "<", "_");
  ret = Strtran(ret, ">", "_");
  ret = Strtran(ret, ".", "_");
  ret = Strtran(ret, "+", "_");
  ret = Strtran(ret, ")", "_");
  ret = Strtran(ret, "(", "_");
  ret = Strtran(ret, "%", "_");
  ret = Strtran(ret, "'", "_");
  ret = Strtran(ret, "\"", "_");
  return ret;
}

function replaceIconFontWithUnicode(imgType, printmode) {
  if (imgType == "svg" && !printmode)
    return;
  var ifonts = d3.selectAll(".ztchartfonticon")._groups[0];
  for (var i = 0; i < ifonts.length; i++)
    ifonts[i].textContent = "'" + ifonts[i].getAttribute("data-font") + "'";
}

function replaceIconFontWithCharCode(imgType, printmode) {
  if (imgType == "svg" && !printmode)
    return;
  var ifonts = d3.selectAll(".ztchartfonticon")._groups[0];
  for (var i = 0; i < ifonts.length; i++)
    ifonts[i].textContent = getIconFromCode(ifonts[i].getAttribute("data-font"));
}

function trasposeMatrix(array) {
	var trasposeArray = array[0].map(function(col, i) {
		return array.map(function(row) {
			return row[i];
		})
	});
	return trasposeArray;
}

function getDefaultRangeBands() {
  var rb =  [  
              {minValue: 0, maxValue: 33, color: "#E51400", label: "0-33%", percent: true, imageUrl: "images/chart_red.svg", iconCode: "eca2"},
              {minValue: 33, maxValue: 66, color: "#E3C800", label: "33-66%", percent: true, imageUrl: "images/chart_yellow.svg", iconCode: "edb2"},
              {minValue: 66, maxValue: 100, color: "#60A917", label: "66-100%", percent: true, imageUrl: "images/chart_green.svg", iconCode: "eee5"}
            ];
  return rb;
}

function getRangeOrd(range){  // ritorna range bands ordinate
  var ret = [];
  var mmax = [];
  var found = false;
  var i;
  for(i=0; i<range.length; i++){
    mmax.push(range[i].maxValue);
  }
  mmax.sort(function(a,b){ return a-b;});
  for(var k=0; k<mmax.length; k++){
    found = false;
    for(i=0; i<range.length && !found; i++){
      if(mmax[k]==range[i].maxValue){
        ret.push(range[i]);
        found = true;
      }
    }
  }
  return ret;
}

function getRangeContOrDisc(range) { // ritorna un booleano: se range bands sono discontinue o no
  var ret = getRangeCalc(range);
  return (ret.length > range.length);
}

function getRangeCalc(range) { // calcolo delle range bands discontinue solo con min e max
  var minunit = 0, i;
  for (i = 0; i < range.length; i++) {
    minunit = Math.max(minunit, decimalPlaces(range[i].minValue));
    minunit = Math.max(minunit, decimalPlaces(range[i].maxValue));
  }
  var unit = (minunit>0)?(1/Math.pow(10,minunit)):(1/Math.pow(10,minunit));
  var mrange = getRangeOrd(range);
  var ret = [];
  ret.push(mrange[0]);
  if(mrange.length>1){
    for(i=1; i<mrange.length; i++){
      if(mrange[i-1].maxValue==(mrange[i].minValue-unit) || mrange[i-1].maxValue==mrange[i].minValue){ // continuo
      }
      else{ // non e' piu' continuo
        ret.push({  minValue: mrange[i-1].maxValue+unit,
                    maxValue: mrange[i].minValue-unit,
                    isDisc: true
                });
      }
      ret.push(mrange[i]);
    }
  }
  return ret;
}

function getIntervalRange(range){ // ritorno range bands complete discontinue o no
  if (Empty(range) || range.length == 0)
    return [];
  var irange = getRangeCalc(range);
  var retrange = [];
  var mcolors = [];
  mcolors.push(irange[0].color);
  for(var i=0; i<irange.length; i++){
    if(irange[i].isDisc){
      retrange.push({ minValue: irange[i].minValue,
                      maxValue: irange[i].maxValue,
                      percent: true,
                      color: "#FFFFFF",
                      label: "",
                      discontinue: true
                    });
    }
    else
      retrange.push(irange[i]);
  }
  return retrange;
}

function getRangeBandsWithValues(range, minv, maxv) {
  var rret = [];
  var mmin,mmax;
  var tdiff = Math.abs(minv - maxv);
  var mymin = minv;
  if(tdiff==0){
    tdiff = maxv;
    mymin = 0;
  }

  for(var i=0; i<range.length; i++){
    if (range[i].percent) {
      mmin = tdiff*(range[i].minValue/100)+mymin;
      mmax = tdiff*(range[i].maxValue/100)+mymin;
    }
    else {
      mmin = range[i].minValue;
      mmax = range[i].maxValue;
    }

    rret.push(
      { minValue: mmin,
        maxValue: mmax,
        percent: false,
        color: range[i].color,
        label: range[i].label,
        imageUrl: range[i].imageUrl,
        iconCode: range[i].iconCode,
        percMin: (range[i].percent ? range[i].minValue : (mmin*100)/maxv),
        percMax: (range[i].percent ? range[i].maxValue : (mmax*100)/maxv)
      }
    );
  }
  return rret;
}

function getListFromObjectArray(mobjarray, prop) {
  var ret = [],
  props = prop.split(".");
  for(var i=0; i<mobjarray.length; i++) {
    if (props.length > 1)
      ret.push(props.reduce(function index(obj,i) { return obj[i]}, mobjarray[i]));
    else
      ret.push(mobjarray[i][prop]);
  }
  return ret;
}

function getColorsArrayLighter(colorstring, mlength) {
  var mton = 20,
  rgbcolor = colorstring;
  if (colorstring.indexOf(",") < 0)
		rgbcolor = d3.rgb(colorstring);
  var rl = Math.round((255 - rgbcolor.r) / mton),
  gl = Math.round((255 - rgbcolor.g) / mton),
  bl = Math.round((255 - rgbcolor.b) / mton),
  ret = [];

  ret.push({ color: colorstring, gradient: ""});
  for (var i = 0; i < mlength - 1; i++) {
    rgbcolor = d3.rgb(rgbcolor.r + rl, rgbcolor.g + gl, rgbcolor.b + bl);
    ret.push({ color: rgbcolor.toString(), gradient: "" });
  }
  return ret;
}

function getColorsArrayDarker(colorstring,mlength){
  var mton = 20;
  var rgbcolor = colorstring;
  if(colorstring.indexOf(",")<0)
		rgbcolor = d3.rgb(colorstring);
  var rl = Math.round((0-rgbcolor.r)/mton);
  var gl = Math.round((0-rgbcolor.g)/mton);
  var bl = Math.round((0-rgbcolor.b)/mton);
  var ret = [];
  ret.push({color:colorstring,gradient:""});
  for(var i=0; i<mlength-1; i++){
    rgbcolor = d3.rgb(rgbcolor.r+rl,rgbcolor.g+gl,rgbcolor.b+bl);
    ret.push({color:rgbcolor.toString(),gradient:""});
  }
  return ret;
}

function getRangeColor(type, bands, color, rbMin, rbMax, value, forprint) {
  if (type == "mono")
    return getMonochromaticRangeColor(color, rbMin, rbMax, value);
  else if (type == "multi") {
    if ((rbMax - rbMin) == 0)
      return color;
    var col = getMultichromaticRangeColor(bands, rbMin, rbMax, value, forprint);
    return col;
  }
  else
    return color;
}

function getMonochromaticRangeColor(color, minv, maxv, val) {
  if ((maxv - minv) == 0)
    return color;
  var monoc = getColorsArrayLighter(color, 8).reverse();
  var qcol = d3.scaleQuantize()
              .domain([minv, maxv])
              .range(monoc);
  return qcol(val).color;
}

function getMultichromaticRangeColor(ranges, minv, maxv, val, forprint) {
  var multic = [], i;
  if (forprint) {
    for (i = 0; i < ranges.length; i++)
      multic.push(ranges[i].color);

    var cols = d3.interpolateRgbBasis(multic);
    var coll = d3.scaleSequential().domain([minv, maxv]).interpolator(cols)
    return coll(val)//cols(scale(val))
  }
  else {
    for (i = 0; i < ranges.length; i++)
      multic.push({ stop: ((100 / ranges.length) * i) / 100,
                    color: ranges[i].color
      });

    var gr = new GradientReader(multic);
    var col = gr.getColor(((val - minv) * 100) / Math.abs(minv - maxv));
    return d3.rgb(col[0], col[1], col[2]).toString();
  }
}

function getMultichromaticRangeColorPV(ranges, val) {
  var multic = [];
  if( ranges.length == 1 )
    return getMonochromaticRangeColor(ranges[0].color, 0, ranges[0].value, val);
  var minv = ranges[0].value;
  var maxv = ranges[ranges.length-1].value;
  var prop = 0;
  for (var i = 0; i < ranges.length; i++) {
    var z = 1;
    if( maxv - minv != 0) {
      if( i > 0 ) {
        z = ranges[i].value - ranges[i-1].value;
        z = z/(maxv - minv);
        prop += z;
      }
    }
    else {
      prop = 1;
    }
    multic.push({ stop: ((100 / (ranges.length-1)) * i * prop) / 100,
                  color: ranges[i].color 
                });
    }
  var gr = new GradientReader(multic);
  return gr.getColor(((val - minv) * 100) / Math.abs(minv - maxv));
}

function GradientReader(colorStops) {
  var canvas = document.createElement('canvas'),
      ctx = canvas.getContext('2d'),
      gr = ctx.createLinearGradient(0, 0, 101, 0),
      i = 0, cs;

  canvas.width = 101;
  canvas.height = 1;
  // eslint-disable-next-line no-cond-assign
  for (; cs = colorStops[i++];)
      gr.addColorStop(cs.stop, cs.color);

  ctx.fillStyle = gr;
  ctx.fillRect(0, 0, 101, 1);

  this.getColor = function(pst) {
    return ctx.getImageData(pst, 0, 1, 1).data;
  };
}

function getPercentDataset(valueFields, propertyName, dataSet, totalsobj, isSeries) {
  // totalsobj deve contenere la chiave in base a record[indexVal] se serie, altrimenti posizione in dataset
  var ret = [],
  indexVal = -1;

  dataSet.forEach ( function (record, index) {
    ret.push(record.slice());
    valueFields.forEach( function (values) {
      indexVal = propertyName.indexOf(values);
      if (!isSeries)
        ret[ret.length-1][indexVal] = ret[ret.length-1][indexVal] / totalsobj.categoriesT[index];
      else
        ret[ret.length-1][indexVal] = ret[ret.length-1][indexVal] / totalsobj[values];
      ret[ret.length-1][indexVal] = parseFloat(ret[ret.length-1][indexVal].toFixed(2));
    });
  });

  return ret;
}

function btwn(a, b1, b2) {
  if ((a >= b1) && (a <= b2)) { return true; }
  if ((a >= b2) && (a <= b1)) { return true; }
  return false;
}

function line_line_intersect(line1, line2) {
  var x1 = line1.x1, x2 = line1.x2, x3 = line2.x1, x4 = line2.x2;
  var y1 = line1.y1, y2 = line1.y2, y3 = line2.y1, y4 = line2.y2,
  pt_denom = (x1 - x2) * (y3 - y4) - (y1 - y2) * (x3 - x4),
  pt_x_num = (x1*y2 - y1*x2) * (x3 - x4) - (x1 - x2) * (x3*y4 - y3*x4),
  pt_y_num = (x1*y2 - y1*x2) * (y3 - y4) - (y1 - y2) * (x3*y4 - y3*x4);
  if (pt_denom == 0)
    return [];
  return { x : pt_x_num / pt_denom, y : pt_y_num / pt_denom };
}

function zeroFilledArray(element/*, index, array*/) {
  return element == 0;
}

function getTreemapLayout(tileStyle) {
  var d3treemap = d3.treemap();
  switch (tileStyle) {
    case 'binary':
      d3treemap.tile(d3.treemapBinary);
      break;
    case 'squarify':
      d3treemap.tile(d3.treemapSquarify);
      break;
    case 'squarifyV1':
      d3treemap.tile(d3.treemapSquarify.ratio(1));
      break;
    case 'squarifyV2':
      d3treemap.tile(d3.treemapSquarify.ratio(2));
      break;
    case 'resquarify':
      d3treemap.tile(d3.treemapResquarify);
      break;
    case 'resquarifyV1':
      d3treemap.tile(d3.treemapResquarify.ratio(1));
      break;
    case 'resquarifyV2':
      d3treemap.tile(d3.treemapResquarify.ratio(2));
      break;
    case 'dice':
      d3treemap.tile(d3.treemapDice);
      break;
    case 'slice':
      d3treemap.tile(d3.treemapSlice);
      break;
    case 'slicedice':
      d3treemap.tile(d3.treemapSliceDice);
      break;
  }
  return d3treemap;
}

function encodeSpecialCharsXML(myString){
  var ret = myString;
  ret = Strtran(ret, " ", "");
  ret = Strtran(ret, "&", "");
  ret = Strtran(ret, "<", "");
  ret = Strtran(ret, ">", "");
  ret = Strtran(ret, "\"", "");
  ret = Strtran(ret, "'", "");
  ret = Strtran(ret, "\\r", "");
  ret = Strtran(ret, "(", "");
  ret = Strtran(ret, ")", "");
  ret = Strtran(ret, "=", "");
  ret = Strtran(ret, ",", "");
  ret = Strtran(ret, ":", "");
  ret = Strtran(ret, "*", "");
  ret = Strtran(ret, "%", "");
  ret = Strtran(ret, "_", "");
  ret = Strtran(ret, "+", "");
  ret = Strtran(ret, "/", "");
  ret = Strtran(ret, "\\", "");
  return ret.toUpperCase();
}

function convertCsv(tmp,separator){
	var newLineWin="\n";
	var newLineLin="\r";
	if(tmp.indexOf(newLineWin)>=0)
		tmp=tmp.replace(newLineWin,"");
	if(tmp.indexOf(newLineLin)>=0)
		tmp=tmp.replace(newLineLin,"");
	if(tmp.indexOf(separator)>=0)
		tmp=JSON.stringify(tmp);
	return tmp;
}

function convertXml(tag, value){
  var txt = "";
  var ttag = encodeSpecialCharsXML(tag);
  txt+="<"+ttag+">";
  txt+=value;
  txt+="</"+ttag+">";
  return txt;
}

function getFilterType(type){
  type = type.toLowerCase();
	if(type.indexOf("area")>=0)
		 return "AREA";
	else if(type.indexOf("bar")>=0 || type=="pareto")
		return "VBAR";
	else if(type=='scatter' || type=='bubble')
		return "SCATTER";
	else
		return "LINES";
}

function recursiveNodePattern(node, fcolor) {
  for (var j = 0; node.attributes && j < node.attributes.length; j++) {
    if(node.attributes[j].value.indexOf('varPatternColor') > -1)
      node.attributes[j].value = Strtran(node.attributes[j].value, "varPatternColor", fcolor);
  }
  if (!node.children || node.children.length == 0)
    return;
  for (var i = 0; node.children && i < node.children.length; i++)
    recursiveNodePattern(node.children[i], fcolor);
}

Array.prototype.hasElement=function(searchElement){
	for(var i=0; i<this.length; i++){
		if(this[i].valueOf()==searchElement.valueOf())
			return i;
	}
	return -1;
}

Array.prototype.hasObject=function(searchElement){
  //var objectConstructor = {}.constructor;
	for(var i=0; i<this.length; i++){
    if(isEquivalent(this[i],searchElement))
      return i;
	}
	return -1;
}

function isEquivalent(a, b) {
  // Create arrays of property names
  var aProps = Object.getOwnPropertyNames(a);
  var bProps = Object.getOwnPropertyNames(b);

  // If number of properties is different,
  // objects are not equivalent
  if (aProps.length != bProps.length) {
    return false;
  }

  for (var i = 0; i < aProps.length; i++) {
    var propName = aProps[i];
    if (typeof a[propName] !== typeof b[propName])
      return false;
    var check_obj = false;
    if ((typeof a[propName]).toLowerCase() === "object") {
      var eq_obj = isEquivalent(a[propName], b[propName]);
      check_obj = true;
      if (!eq_obj)
        return false;
      if (i == aProps.length - 1)
        return eq_obj;
    }
    // If values of same property are not equal,
    // objects are not equivalent
    if (!check_obj && (a[propName] !== b[propName])) {
      return false;
    }
  }

  // If we made it this far, objects
  // are considered equivalent
  return true;
}

function getTimeTickFormat(localeLangFormat, format) {
  var rformat;
	switch (format) {
		case "":
			break;
		case "yyyy-mm-dd":
			rformat = localeLangFormat.timeFormat("%Y-%m-%d");
			break;
		case "dd-mm-yyyy":
		case "dd-MM-yyyy":
			rformat = localeLangFormat.timeFormat("%d-%m-%Y");
			break;
		case "dd-MMM-yyyy":
			rformat = localeLangFormat.timeFormat("%d-%b-%Y");
			break;
		case "MMM-yyyy":
			rformat =  localeLangFormat.timeFormat("%b-%Y");
			break;
		case "yyyy":
			rformat = localeLangFormat.timeFormat("%Y");
			break;
		case "yyyy-mm-dd hh:mm:ss":
			rformat = localeLangFormat.timeFormat("%Y-%m-%d %X");
			break;
		case "yyyy-mm-dd hh:mm":
			rformat = localeLangFormat.timeFormat("%Y-%m-%d %H:%M");
			break;
		case "hh:mm:ss":
			rformat = localeLangFormat.timeFormat("%X");
			break;
		case "hh:mm":
			rformat = localeLangFormat.timeFormat("%H:%M");
			break;
		default:
			rformat = localeLangFormat.timeFormat(format);
			break;
	}
  return rformat;
}

function calcTimeOffset(list) {
	var timeIntervals = {
		s: [1, 59],
		m: [60, 3599],
		h: [3600, 86399],
		d: [86400, 2591999],
		M: [2592000, 31103999],	// media di 30days
		y: [31104000, 1.7976931348623157E+10308]
	},
	timeIntervTicks = {
		s: [1, 15, 30, 45],
		m: [1, 15, 30, 45],
		h: [1, 6, 12, 18],
		d: [1, 7, 15, 21],
		M: [1, 3, 6, 9],
		y: [1, 5, 10, 15]
	},
  keys = ["s", "m", "h", "d", "M", "y"];

	if (list.length > 1) {
		var maxL = (list.length >= 200) ? 200 : list.length,
		dstart = new Date(list[0]),
		offset = 0,
    diff = timeIntervals.y[1],
    check = false,
    unit = "",
    step = 0,
    i;

		for (i = 1; i < maxL; i++) {
      if (dstart.getTimezoneOffset() == list[i].getTimezoneOffset()) {
        offset = (list[i].getTime() - dstart.getTime()) / 1000;
        if (diff != 0)
          diff = Math.min(diff, offset);
      }
      dstart = list[i];
		}

    for (i = 0; i < keys.length && !check; i++) {
			if (diff >= timeIntervals[keys[i]][0] && diff <= timeIntervals[keys[i]][1]){
				unit = keys[i];
				check = true;
			}
		}

    if (Empty(unit) || diff == 0) {
      // imposto il default
      return { unit : "d", step : 1 };
    }

    check = false;
    diff = diff / timeIntervals[unit][0];
    for (i = 0; i < timeIntervTicks[unit].length && !check; i++) {
			if (diff < timeIntervTicks[unit][i]) {
				step = timeIntervTicks[unit][i - 1];
				check = true;
			}
		}

    if (step == 0)
      step = timeIntervTicks[unit][timeIntervTicks[unit].length - 1];

		return { unit : unit, step : step };
	}
	else
		return { unit : "d", step : 1 };
}

function getTimingDivisor(unit) {
  var timeIntervals = {
		s: 30,
		m: 30,
		h: 12,
		d: 14,
		M: 6,	// media di 30days
		y: 1
  }

  var keys = Object.keys(timeIntervals),
  midx = keys.indexOf(unit);
  if (midx > 0)
    return { unit : keys[midx - 1], step : timeIntervals[keys[midx - 1]] }
  return { unit : unit, step : 1 };
}

function calcTimeOffsetBtw2Date(date1, date2) {
	var timeIntervals = {
		s: [1, 59],
		m: [60, 3599],
		h: [3600, 86399],
		d: [86400, 2591999],
		M: [2592000, 31103999],	// media di 30days
		y: [31104000, 1.7976931348623157E+10308]
  },
  keys = ["s", "m", "h", "d", "M", "y"],
  offset = (date2.getTime() - date1.getTime()) / 1000,
  f = false,
  unit = "d",
  step = 1;

  for (var i = 0; !f && i < keys.length; i++) {
    if (offset >= timeIntervals[keys[i]][0] && offset <= timeIntervals[keys[i]][1]) {
      f = true;
      unit = keys[i];
      step = Math.floor(offset / timeIntervals[keys[i]][0]);
    }
  }

  return { unit : unit, step : step };
}

function calcDistanceDifferentTimeUnit(tu1, tu2) {
	var timeIntervals = {
		s: [1, 59],
		m: [60, 3599],
		h: [3600, 86399],
		d: [86400, 2591999],
		M: [2592000, 31103999],	// media di 30days
		y: [31104000, 1.7976931348623157E+10308]
  },
  keys = ["s", "m", "h", "d", "M", "y"],
  dist = 0,
  tk1 = keys.indexOf(tu1.unit),
  tk2 = keys.indexOf(tu2.unit);

  if (tk1 > tk2)
    dist = (timeIntervals[tu1.unit][0] * tu1.step) / (timeIntervals[tu2.unit][0] * tu2.step);
  else
    dist = (timeIntervals[tu2.unit][0] * tu2.step) / (timeIntervals[tu1.unit][0] * tu1.step);
  return dist;
}

function setTimeTicks(start, end, unit, step) {
  var timeUnits = {
		s: 1000,
		m: 60 * 1000,
		h: 3600 * 1000,
		d: 86400 * 1000,
		M: 2592000 * 1000,
		y: 31104000 * 1000
	},
  ret = [];

  for (var i = start; i <= end; i = i + (timeUnits[unit] * step))
    ret.push(new Date(i));

  return ret;
}

function numRoundTo(num, mult) {
  var resto = num%mult;
  if (resto <= (mult/2)) {
      return num-resto;
  } else {
      return num+mult-resto;
  }
}

function getMagnitudeOrder(n) {
  if (n == undefined || n == null || Empty(n))
    n = 1;
  n = Math.abs(parseFloat(n));
  var order = Math.floor(Math.log(n) / Math.LN10 + 0.000000001);
  return order;
}

function fileExists(url) {
  var http = new XMLHttpRequest();
  http.open('HEAD', url, false);
  http.send();
  return http.status != 404;
}

function invertColor(hexTripletColor) {
	var color = hexTripletColor;
	if (Empty(color))
    return "";
	color = color.substring(1); // remove #
	color = parseInt(color, 16); // convert to integer
	color = 0xFFFFFF ^ color; // invert three bytes
	color = color.toString(16); // convert to hex
	color = ("000000" + color).slice(-6); // pad with leading zeros
	color = "#" + color; // prepend #
	return color;
}

function makeParameterStringFromLinkObj(url, type, linkObj, itemObj, chart) {
  var murl = url,
  mcp,
  seriesName = Empty(linkObj.seriesname) ? "series" : linkObj.seriesname,
  categoryName = Empty(linkObj.categoryname) ? "category" : linkObj.categoryname,
  categoryKeyName = Empty(linkObj.categoryKeyName) ? "categoryKey" : linkObj.categoryKeyName,
  valueName = Empty(linkObj.valuename) ? "value" : linkObj.valuename,
  valueZName = Empty(linkObj.valuezname) ? "valuez" : linkObj.valuezname,
  multidimKeyName = Empty(linkObj.multidimKeyName) ? "multidimKeyName" : linkObj.multidimKeyName,
  geocountryName = Empty(linkObj.geocountryName) ? "geocountryName" : linkObj.geocountryName,
  geosubdivisionName = Empty(linkObj.geosubdivisionName) ? "geosubdivisionName" : linkObj.geosubdivisionName;
  if (type == "link") {
    murl += (murl.indexOf("?") < 0 ? "?" : "&");
    murl += chart._GetParametersStringForLink(itemObj);
    murl += "&" + multidimKeyName + "=" + itemObj.multidimCurrentKey;
    if (!Empty(linkObj.genericParam))
      murl += "&" + linkObj.genericParam;
  }
  else {  // func
    if (itemObj.cname) {
      mcp = itemObj.cname.split("_");
      murl = Strtran(murl, geocountryName, "'" + mcp[0] + "'");
      murl = Strtran(murl, geosubdivisionName, "'" + mcp[1] + "'");
      murl = Strtran(murl, seriesName, "'" + itemObj.series + "'");
      murl = Strtran(murl, multidimKeyName, "'" + itemObj.multidimCurrentKey + "'");
    }
    else if (itemObj.x) {
      murl = Strtran(murl, categoryKeyName, "'" + itemObj.keyF + "'");
      murl = Strtran(murl, seriesName, "'" + itemObj.series + "'");
      murl = Strtran(murl, categoryName, "'" + itemObj.x + "'");
      murl = Strtran(murl, valueName, "'" + itemObj.y + "'");
      murl = Strtran(murl, valueZName, "'" + itemObj.z + "'");
      murl = Strtran(murl, multidimKeyName, "'" + itemObj.multidimCurrentKey + "'");
    }
    else {
      murl = Strtran(murl, categoryKeyName, "'" + itemObj.keyF + "'");
      murl = Strtran(murl, categoryName, "'" + itemObj.category + "'");
      murl = Strtran(murl, seriesName, "'" + itemObj.series + "'");
      murl = Strtran(murl, valueName, "'" + itemObj.value + "'");
      murl = Strtran(murl, multidimKeyName, "'" + itemObj.multidimCurrentKey + "'");
    }
  }

  return murl;
}

function makeParameterStringFromOverlapLinkObj(url, type, linkObj, itemObj, chart) {
  var murl = url,
  itms_i = chart._GetOverlapObject(itemObj),
  all_itms = chart._GetItems(),
  ser = "",
  cols = "";

  if (type == "link") {
    murl += (murl.indexOf("?") < 0 ? "?" : "&");
    for (var i = 0; i < itms_i.length; i++) {
      ser += ("::" + all_itms[itms_i[i]].category);
      cols += ("::" + all_itms[itms_i[i]].color.color)
    }
    murl += "&category=" + URLenc(ser.slice(2));
    murl += "&colors=" + URLenc(Strtran(cols.slice(2), "#", ""));
    murl += "&serie=" + URLenc(itemObj.quadrant);
    murl += "&x=" + URLenc(itemObj.x);
    murl += "&y=" + URLenc(itemObj.y);
    if ("sub_x" in itemObj)
      murl += "&sub_x=" + URLenc(itemObj.sub_x);
    if ("sub_y" in itemObj)
      murl += "&sub_y=" + URLenc(itemObj.sub_y);
    murl += "&num=" + URLenc(itms_i.length);

    if (!Empty(linkObj.genericParam))
      murl += "&" + linkObj.genericParam;
  }
  else {  // func
    // category serie x y num
  }

  return murl;
}

function canDrawInContainer(type) {
  var draw = false;
  switch (type) {
    case "LINES":
    case "VBAR":
    case "VBAR3D":
    case "VSTACKBAR":
    case "VSTACKBAR3D":
    case "LAYEREDBAR":
    case "TREEMAPBAR":
    case "AREA":
    case "STACKEDAREA":
      draw = true;
      break;
    default:
      draw = false;
      break;
  }
  return draw;
}

function getAlternativeChartType(type) {
  // tutela per disegno dei grafici con serie diversa
  var rtype = "";
  switch (type) {
    case "HBAR":
    case "PYRAMID":
    case "PIE":
    case "PIE3D":
    case "RING":
    case "RINGPERC":
    case "PARETO":
    case "WATERF":
    case "WORDCLOUD":
    case "GEOMAP":
    case "ARCDIAL":
    case "COUNTER":
    case "DISPLAY":
    case "PADDLE":
    case "LIGHTS":
    case "IMAGES":
      rtype = "VBAR";
      break;
    case "HBAR3D":
      rtype = "VBAR3D";
      break;
    case "HSTACKBAR":
      rtype = "VSTACKBAR";
      break;
    case "HSTACKBAR3D":
      rtype = "VSTACKBAR3D";
      break;
    case "THERMO":
    case "LAYEREDBARH":
      rtype = "LAYEREDBAR";
      break;
    case "TREEMAP":
    case "TREEMAPBARH":
      rtype = "TREEMAPBAR";
      break;
    case "RADARAREA":
      rtype = "AREA";
      break;
    case "RADARLINE":
    case "SCATTER":
    case "BUBBLE":
    default:
      rtype = "LINES";  // default quando apro editor
      break;
  }
  return rtype;
}

function wrapspace(elem, configObj) {
  elem = d3.select(elem);

  var text = configObj.text,
  textSplit = configObj.textSplit,
  width = configObj.width,
  nlines = configObj.nlines,
  font = configObj.font,
  chartId = configObj.chartId,
  keyapplied = configObj.keyapplied,
  keyText = configObj.keyText,
  axisPos = configObj.axisPos,
  sep = configObj.separator,
  words = (textSplit || text.split(sep)).reverse(),
  word,
  lineHeight,
  line = [],
  x = elem.attr("x"),
  y = axisPos == "left" ? parseFloat(elem.attr("y")) : elem.attr("y"),
  dy = axisPos == "left" ? elem.attr("dy") : parseFloat(elem.attr("dy")),
  tspan,
  plusLine = false,
  progrLine = 1,
  underwrap = false,
  ljoin = "";

  elem.text(null);
  // eslint-disable-next-line no-cond-assign
  while (word = words.pop()) {
    line.push(word);
    if (getOffsetWidth(line.join(configObj.cjoin), font, chartId) > width) {
      line.pop();
      line = [word];
      ljoin = line.join(configObj.cjoin);
      if (getOffsetWidth(ljoin, font, chartId) > width) {
        underwrap = true;
        nlines = Math.max(nlines, Math.round(getOffsetWidth(ljoin, font, chartId) / width));
      }
      lineHeight = axisPos == "left" ? getOffsetHeight(ljoin, font, chartId) : 1.1;
      tspan = elem.append("tspan")
                .attr("x", 0)//x)
                .attr("y", axisPos == "left" ? (y + (progrLine - 1) * lineHeight) : y)
                .attr("dy", axisPos == "left" ? dy : ((progrLine - 1) * lineHeight + dy + "em"))
                .text(word);
      progrLine++;
      plusLine = true;
    }
    else {
      if (Empty(tspan)) {
        tspan = elem.append("tspan").attr("x", x).attr("y", axisPos == "left" ? 0 : y).attr("dy", axisPos == "left" ? 0 : (dy + "em"));
        progrLine++;
      }
      tspan.text(line.join(configObj.cjoin));
    }
  }

  if (keyapplied)
    elem.append("desc").text("key_field:" + keyText);

  return { wrap : plusLine, underwrap : underwrap, lines : nlines };
}

function getD3TimeObject(timing) {
  var obj;
  switch (timing) {
    case "s" :
      obj = d3.timeSecond;
      break;
    case "m" :
      obj = d3.timeMinute;
      break;
    case "h" :
      obj = d3.timeHour;
      break;
    case "d" :
      obj = d3.timeDay;
      break;
    case "M" :
    case "month" :
      obj = d3.timeMonth;
      break;
    case "y" :
    case "year" :
      obj = d3.timeYear;
      break;
    default :
      obj = d3.timeDay;
      break;
  }
  return obj;
}

function getMaxWordLengthForWrap(list, precision, fnc) {
  var tmplist = [],
  tmpsplit = [],
  splitobj = {};
  for (var i = 0; i < list.length; i++) {
    if ((list[i]+"").indexOf(" ") < 0)
      tmplist.push(list[i]);
    else if (Object.prototype.toString.call(list[i]) !== "[object Date]") {
      var ssplit = list[i].split(/\s+/);
      splitobj["_" + i] = ssplit.slice();
      tmpsplit = tmpsplit.concat(ssplit);
    }
  }

  if (!Empty(tmplist))
    return { obj : null, word : getMaxWordLength(tmplist, precision, fnc) };
  return { obj : splitobj, word : getMaxWordLength(tmpsplit, precision, fnc) };
}

function getTimeFormatSeparator(format) {
  var ret = {};
  if (format.indexOf(" ") >= 0) {
    ret.separator = /\s+/;
    ret.cjoin = " ";
    return ret;
  }
  if (format.indexOf("-") >= 0){
    ret.separator = /\-+/;
    ret.cjoin = "-";
    return ret;
  }
  if (format.indexOf("/") >= 0){
    ret.separator = /\/+/;
    ret.cjoin = "/";
    return ret;
  }
  if (format.indexOf(":") >= 0) {
    ret.separator = /\:+/;
    ret.cjoin = ":";
    return ret;
  }
  ret.separator = /\s+/;
  ret.cjoin = " ";
  return ret;
}
/* da rivalutare - implementazione tipologia
function isNumeric(num){
  return !isNaN(+num)
}
*/
function getHieDataset(data, hFields, valueFields, labelSeries, propertyName, addfields, singleRoot, noGroup, kFields) {
  var mapData = { children: [], name: "" },
  startIndex = singleRoot ? 1 : 0,
  pname,
  fidx;

  if (startIndex != 0)
    mapData.name = data[0][propertyName.indexOf(hFields[0])];

  // costruisco la gerarchia con oggetti come chiavi
  /*for (var i = 0; i < data.length; i++) {
    fidx = propertyName.indexOf(hFields[1]);
    if (!levelsList[data[i][fidx]])
      levelsList[data[i][fidx]] = { };
    obj = levelsList[data[i][fidx]];
    for (var j = 2; j < hFields.length; j++) {
      fidx = propertyName.indexOf(hFields[j]);
      if (!obj[data[i][fidx]])
        obj[data[i][fidx]] = { };
      obj = obj[data[i][fidx]];
      if (j == hFields.length - 1 && yidx >= 0)
        obj.value = data[i][yidx];
    }
  }*/

  if (noGroup) {
    for (var i = 0; i < data.length; i++) {
      var f = false;
      for (var j = hFields.length - 1; !f && j >= startIndex; j--) {
        fidx = propertyName.indexOf(hFields[j]);
        pname = "";
        if (j >= 1)
          pname = data[i][propertyName.indexOf(hFields[j - 1])];
        if (Empty(data[i][fidx]))
          continue;
        mapData.children.push({ name : data[i][fidx],
                                size : data[i][propertyName.indexOf(valueFields)],
                                parentName : pname,
                                data_idx : i });
        if (!Empty(addfields)) {
          for (var ff = 0; ff < addfields.length; ff++) {
            mapData.children[mapData.children.length - 1][addfields[ff].prop] = data[i][addfields[ff].index];
          }
        }
        f = true;
      }
    }
  }
  else
    mapData = recursiveTree(mapData, hFields, startIndex, propertyName, valueFields, labelSeries, data, addfields, kFields);

  return mapData;
}

function getForceDataset(data, hFields, valueFields, propertyName, cFields, lFields, addfields) {
  var nodesNames = [],
  nodesObj = [],
  nodesLabels = [],
  links = [],
  obj,
  fidx,
  cfidx,
  lidx,
  val,
  lab,
  ff;

  for (var i = 0; i < data.length; i++) {
    fidx = propertyName.indexOf(hFields[0]);
    cfidx = -1;
    if (cFields && !Empty(cFields[0]))
      cfidx = propertyName.indexOf(cFields[0]);
    lidx = -1;
    if (lFields && !Empty(lFields[0]))
      lidx = propertyName.indexOf(lFields[0]);
    val = data[i][propertyName.indexOf(valueFields)];

    if (!Empty(data[i][fidx]) && nodesNames.indexOf(data[i][fidx]) < 0) {
      nodesNames.push(data[i][fidx]);
      lab = lidx < 0 ? "" : data[i][lidx];
      nodesLabels.push(lab);
      nodesObj.push( { name: data[i][fidx], class: cfidx < 0 ? "" : data[i][cfidx], desc: lab } );
      if (!Empty(addfields)) {
        for (ff = 0; ff < addfields.length; ff++) {
          nodesObj[nodesObj.length - 1][addfields[ff].prop] = data[i][addfields[ff].index];
        }
      }
    }
    obj = {};
    obj.source = nodesNames.indexOf(data[i][fidx]);

    for (var j = 1; j < hFields.length; j++) {
      fidx = propertyName.indexOf(hFields[j]);
      cfidx = -1;
      if (cFields && !Empty(cFields[j]))
        cfidx = propertyName.indexOf(cFields[j]);
      lidx = -1;
      if (lFields && !Empty(lFields[j]))
        lidx = propertyName.indexOf(lFields[j]);
      if (!Empty(data[i][fidx])) {  // percorso a catena - non singolo
        if (j > 1) {
          obj = {};
          obj.source = nodesNames.indexOf(data[i][propertyName.indexOf(hFields[j - 1])])
        }
        if (nodesNames.indexOf(data[i][fidx]) < 0) {
          nodesNames.push(data[i][fidx]);
          lab = lidx < 0 ? "" : data[i][lidx];
          nodesLabels.push(lab);
          nodesObj.push( { name: data[i][fidx], value: val, class: cfidx < 0 ? "" : data[i][cfidx], desc: lab } );
          if (!Empty(addfields)) {
            for (ff = 0; ff < addfields.length; ff++) {
              nodesObj[nodesObj.length - 1][addfields[ff].prop] = data[i][addfields[ff].index];
            }
          }
        }
        if (obj) {
          obj.target = nodesNames.indexOf(data[i][fidx]);
          links.push(obj);
        }
      }
    }
  }

  var dupes = getDupLinks(links).sort(function(a, b){ return b-a; });
  for(i = 0; i < dupes.length; i++)
    links.splice(dupes[i], 1);

  return {nodes: nodesObj, links: links, array: nodesNames, labels: nodesLabels };

  function getDupLinks(lnks) {
    var idxs = [];
    for(var i=0; i<lnks.length; i++) {
      for(var j=i+1; j<lnks.length; j++) {
        if(lnks[i].source === lnks[j].source){
          if(lnks[i].target === lnks[j].target)
            idxs.push(j);
        }
      }
    }
    return idxs.unique();
  }
}

function recursiveTree(mapData, hFields, idx, propertyName, valueFields, labelSeries, data, addfields, kFields) {
  var fidx = propertyName.indexOf(hFields[idx]),
  list = getList(fidx, data),
  datatmp,
  obj,
    value,
  serie,
  kidx,
  klist,
  keyf;
  if (!Empty(kFields)) {
    kidx = propertyName.indexOf(kFields[idx]);
    klist = getList(kidx, data);
  }
  else {
    kidx = fidx;
    klist = list;
  }
  
  for (var i = 0; i < klist.length; i++) {
    datatmp = data.filter( function (record) { if (record[kidx] == klist[i]) return record; } );
    value = datatmp[0][propertyName.indexOf(valueFields)];
    serie = datatmp[0][propertyName.indexOf(labelSeries)];
    keyf = Empty(kFields) ? "" : klist[i];
    obj = { name: list[i], serie: serie, keyF: keyf };
    if (!Empty(addfields)) {
      for (var ff = 0; ff < addfields.length; ff++) {
        obj[addfields[ff].prop] = datatmp[0][addfields[ff].index];
      }
    }
    if (idx < hFields.length - 1) {
      obj.children = []; 
      recursiveTree(obj, hFields, idx + 1, propertyName, valueFields, labelSeries, datatmp, addfields, kFields);
    }
    else if (!Empty(list[i]) || list[i] === 0) {
      // è un solo livello -> se ci sono più record devo aggregare i valori
      if (datatmp.length > 1) {
        value = d3.sum(datatmp.map(function(record){ return record[propertyName.indexOf(valueFields)] }))
      }
      obj.size = value;
      obj.value = value;
    }

    if (Empty(obj.children)) {
      delete obj.children;
      obj.size = value;
      obj.value = value;
    }

    if (!Empty(list[i]) || list[i] === 0)
      mapData.children.push(obj);
  }
  return mapData;
}

function getMatrixLinksDataset(data, hFields, valueFields, propertyName, identity, addfields) {
  var list_1 = getList(propertyName.indexOf(hFields[0]), data),
  list_2 = getList(propertyName.indexOf(hFields[1]), data),
  el_1,
  el_2,
  links = [],
  obj,
  val,
  ff;

  if (identity) { // devo uniformare le liste
    list_1 = list_1.concat(list_2);
    list_1 = list_1.unique();
    list_2 = list_1.slice();
  }

  for (var i = 0; i < data.length; i++) {
    val = data[i][propertyName.indexOf(valueFields)];
    el_1 = data[i][propertyName.indexOf(hFields[0])];
    el_2 = data[i][propertyName.indexOf(hFields[1])];
    obj = {};
    obj.source = list_1.indexOf(el_1);
    obj.target = list_2.indexOf(el_2);
    obj.value = val;
    obj.data_index = i;
    if (!Empty(addfields)) {
      for (ff = 0; ff < addfields.length; ff++) {
        obj[addfields[ff].prop] = data[i][addfields[ff].index];
      }
    }
    links.push(obj);
  }

  var dupes = getDupLinks(links).sort(function(a, b){ return b-a; });
  for (i = 0; i < dupes.length; i++)
    links.splice(dupes[i], 1);

  if (identity) {
    // aggiungo i rovesci
    var len = links.length;
    for (i = 0; i < len; i++) {
      links.push( { source: links[i].target, target: links[i].source, value: links[i].value, data_index: links[i].data_index } );
      if (!Empty(addfields)) {
        for (ff = 0; ff < addfields.length; ff++) {
          links[links.length - 1][addfields[ff].prop] = links[i][addfields[ff].prop];
        }
      }
    }

    // aggiungo la diagonale
    for (i = 0; i < list_1.length; i++) {
      obj = {};
      obj.source = i;
      obj.target = i;
      links.push(obj);
    }
  }

  return { links: links, array: list_1, array_2: list_2 };

  function getDupLinks(lnks) {
    var idxs = [];
    for (var i=0; i<lnks.length; i++) {
      for (var j=i+1; j<lnks.length; j++) {
        if (lnks[i].source === lnks[j].source){
          if (lnks[i].target === lnks[j].target)
            idxs.push(j);
        }
      }
    }
    return idxs.unique();
  }
}

function getMatrixDependencies(data, hFields, valueFields, propertyName, lFields) {
  // ragiona per righe
  var list_1 = getList(propertyName.indexOf(hFields[0]), data),
  list_2 = getList(propertyName.indexOf(hFields[1]), data),
  allList = [],
  labList = [],
  i,
  j,
  el_1,
  el_2,
  value,
  mat = [];

  var matobj = {},
  countobj = {};
  for (i = 0; i < data.length; i++) {
    el_1 = data[i][propertyName.indexOf(hFields[0])];
    el_2 = data[i][propertyName.indexOf(hFields[1])];
    if (!(el_1 in matobj))
      matobj[el_1] = [];
    if (matobj[el_1].indexOf(el_2) < 0)
      matobj[el_1].push(el_2);
    if (!(el_1 in countobj))
      countobj[el_1] = 0;
    countobj[el_1] ++;
    if (!(el_2 in countobj))
      countobj[el_2] = 0;
    countobj[el_2] ++;
  }

  var aa = matobj[Object.keys(matobj)[0]];
  aa.sort(function (a, b) {
    return countobj[b] - countobj[a];
  })

  var tl = [],
  keys = Object.keys(matobj);
  for (i = 0; i < keys.length; i++) {
    var ka = matobj[keys[i]];
    ka.sort(function (a, b) {
      return countobj[b] - countobj[a];
    });
    if (tl.indexOf(keys[i]) < 0)
      tl.push(keys[i]);
    for (j = 0; j < ka.length; j++) {
      if (tl.indexOf(ka[j]) < 0)
        tl.push(ka[j]);
    }
  }

  var tkey = Object.keys(countobj);
  tkey.sort(function (a, b) {
    return countobj[b] - countobj[a];
  });

  allList = list_1.concat(list_2);
  allList = allList.unique();

  allList = tl.slice();

  if (!Empty(lFields)) {
    labList = getList(propertyName.indexOf(lFields[0]), data).concat(getList(propertyName.indexOf(lFields[1]), data));
    labList = labList.unique();
  }

  for (i = 0; i < allList.length; i++) {
    mat.push([]);
    for (j = 0; j < allList.length; j++) {
      mat[i][j] = 0;
    }
  }

  for (i = 0; i < data.length; i++) {
    el_1 = data[i][propertyName.indexOf(hFields[0])];
    el_2 = data[i][propertyName.indexOf(hFields[1])];
    if (Empty(valueFields)) {
      value = 1;  // valore simbolico
      if (Empty(mat[allList.indexOf(el_2)]))
        mat[allList.indexOf(el_2)] = [];
      mat[allList.indexOf(el_2)][allList.indexOf(el_1)] = value;
      if (Empty(mat[allList.indexOf(el_1)]))
        mat[allList.indexOf(el_1)] = [];
      mat[allList.indexOf(el_1)][allList.indexOf(el_2)] = value;
    }
    else {
      value = data[i][propertyName.indexOf(valueFields)];
      if (Empty(mat[allList.indexOf(el_2)]))
        mat[allList.indexOf(el_2)] = [];
      mat[allList.indexOf(el_2)][allList.indexOf(el_1)] = value;
    }
  }

  return { matrix: mat, array: allList, arrayLabels: labList };
}

function getAllFonts() {
  return {
    websafe : [
      "Arial", "Arial Black", "Comic Sans MS", "Courier New",
      "Georgia", "Impact", "Lucida Console", "Lucida Sans Unicode",
      "Palatino Linotype", "Tahoma", "Times New Roman", "Trebuchet MS", "Verdana"
    ],
    offline: [
      "Open Sans", "Roboto", "Raleway", "Fira Sans", "Liquid Crystal",
      "JD LCD Rounded", "DejaVu Sans", "DejaVu Sans Condensed",
      "DejaVu Sans Mono", "DejaVu Serif", "DejaVu Serif Condensed",
      "Lets Go Digital", "Digital System", "Electronic Highway Sign"
    ],
    online: ['',
      'Coustard', 'Antic Slab', 'Quattrocento',
      'Cinzel', 'Josefin Slab', 'Merriweather', 'Lora',
      'Nunito', 'Abel', 'Fjalla One', 'Dosis', 'Economica',
      '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',
      'Share Tech Mono', 'Ubuntu Mono', 'VT323'
    ]
  };
}

function getRandomColor(){
  var letters = '0123456789ABCDEF'.split('');
  var color = '#';
  for (var i = 0; i < 6; i++ ) {
    color += letters[Math.floor(Math.random() * 16)];
  }
  return color;
}

function getDuplicatesListCAT(keyidx, dupidx, dataSet, mcounter) {
	var array = [];
	var karray = [];
	var count = [];
  var setCount = false;
	if (keyidx != -1) {
		dataSet.forEach(function(record) {
      if( record != null ) {
        if (karray.indexOf(record[keyidx]) < 0) {
          if(record[keyidx]!=null) karray.push(record[keyidx].toString());
		  else karray.push(record[keyidx]);
          if ((Empty(mcounter) || (mcounter && !mcounter[record[dupidx].toString()])) && !count[record[dupidx].toString()]) {
            count[record[dupidx].toString()] = 1;
            array.push(record[dupidx].toString());
          }
          else {
            if (mcounter && mcounter[record[dupidx].toString()] && !setCount) {
              count[record[dupidx].toString()] = mcounter[record[dupidx].toString()];
              setCount = true;
            }
            if(count[record[dupidx].toString()]==1)
              array[array.indexOf(record[dupidx].toString())] = record[dupidx].toString() /*+ " ("+count[record[dupidx].toString()]+")";*/
            count[record[dupidx].toString()] ++;
            array.push(record[dupidx].toString()/* + " (" + count[record[dupidx].toString()] + ")"*/);
          }
        }
      }
		});
	}
	return {array:array, countobj:count};
}

// workaround x IE
Math.trunc = Math.trunc || function(x) {
  if (isNaN(x)) {
    return NaN;
  }
  if (x > 0) {
    return Math.floor(x);
  }
  return Math.ceil(x);
};

function getSankeyNodesDataset(data, hFields, valueFields, propertyName, addfields) {
  var list_1 = getList(propertyName.indexOf(hFields[0]), data),
  list_2 = getList(propertyName.indexOf(hFields[1]), data),
  el_1,
  el_2,
  links = [],
  tmp_n = [],
  nodes = [],
  obj,
  val;

//la lista e' una sola
  list_1 = list_1.concat(list_2);
  list_1 = list_1.unique();
  list_2 = list_1.slice();

  for (var i = 0; i < data.length; i++) {
    val = data[i][propertyName.indexOf(valueFields)];
    el_1 = data[i][propertyName.indexOf(hFields[0])];
    el_2 = data[i][propertyName.indexOf(hFields[1])];
    obj = {};
    obj.source = list_1.indexOf(el_1);
    obj.target = list_2.indexOf(el_2);
    obj.value = val;
    if (!Empty(addfields)) {
      for (var ff = 0; ff < addfields.length; ff++) {
        obj[addfields[ff].prop] = data[i][addfields[ff].index];
      }
    }
    links.push(obj);

    if (tmp_n.indexOf(el_1) < 0 && list_1.indexOf(el_1) >= 0) {
      tmp_n.push(el_1);
      nodes.push({ name: el_1/*, index: list_1.indexOf(el_1) */});
    }

    if (tmp_n.indexOf(el_2) < 0 && list_1.indexOf(el_2) >= 0) {
      tmp_n.push(el_2);
      nodes.push({ name: el_2/*, index: list_1.indexOf(el_2)*/ });
    }
  }

  var dupes = getDupLinks(links).sort(function(a, b){ return b-a; });
  for (i = 0; i < dupes.length; i++)
    links.splice(dupes[i], 1);

  nodes.sort(function(a, b) { return list_1.indexOf(a.name) - list_1.indexOf(b.name) })

  return { links: links, nodes: nodes };

  function getDupLinks(lnks) {
    var idxs = [];
    for (var i=0; i<lnks.length; i++) {
      for (var j=i+1; j<lnks.length; j++) {
        if (lnks[i].source === lnks[j].source){
          if (lnks[i].target === lnks[j].target)
            idxs.push(j);
        }
      }
    }
    return idxs.unique();
  }
}

function arrayCompare(org, newarr) {
  if(!newarr)
      return false;

  if(org.length != newarr.length)
      return false;

  for (var i = 0, l=org.length; i < l; i++) {
      if(org[i] instanceof Array && newarr[i] instanceof Array) {
          if(!arrayCompare(org[i], newarr[i]))
              return false;
      }
      else if(org[i] != newarr[i]) {
          return false;
      }
  }
  return true;
}

function decodeConditionalFormatting(fncRet) {
  if (Empty(fncRet))
    return null;
  var todec = fncRet,
  ret = {};
  if (typeof todec == "string")
    todec = JSON.parse(fncRet);
  // fill
  if (todec.background) ret.fill = todec.background;
  if (todec.backgroundColor) ret.fill = todec.backgroundColor;
  if (todec["background-color"]) ret.fill = todec["background-color"];
  if (todec.fill) ret.fill = todec.fill;
  if (todec.fillColor) ret.fill = todec.fillColor;
  if (todec["fill-color"]) ret.fill = todec["fill-color"];

  return ret;
}