var _____WB$wombat$assign$function_____ = function(name) {return (self._wb_wombat && self._wb_wombat.local_init && self._wb_wombat.local_init(name)) || self[name]; };
if (!self.__WB_pmw) { self.__WB_pmw = function(obj) { this.__WB_source = obj; return this; } }
{
  let window = _____WB$wombat$assign$function_____("window");
  let self = _____WB$wombat$assign$function_____("self");
  let document = _____WB$wombat$assign$function_____("document");
  let location = _____WB$wombat$assign$function_____("location");
  let top = _____WB$wombat$assign$function_____("top");
  let parent = _____WB$wombat$assign$function_____("parent");
  let frames = _____WB$wombat$assign$function_____("frames");
  let opener = _____WB$wombat$assign$function_____("opener");

ASPxClientWebChartControl = _aspxCreateClass(ASPxClientControl, {
 constructor: function(name) {
  this.constructor.prototype.constructor.call(this, name);
  this.ObjectHotTracked = new ASPxClientEvent();
  this.ObjectSelected = new ASPxClientEvent();
  this.printFrame = null;
  this.exportWindow = null;
  _aspxAttachEventToElement(this.GetMainDOMElement(), "mouseout", function(evt) { this.HideElements(evt); }.aspxBind(this));
 },
 HideElements: function(evt) {
  var target;
  if (_aspxIsExists(evt.toElement)) {
   target = evt.toElement;
  }
  else {
   if (_aspxIsExists(evt.relatedTarget)) {
    target = evt.relatedTarget;
   }
  }
  if (_aspxIsExists(target)) {
   var parent = _aspxGetParentById(target, this.name);
   if (_aspxIsExists(parent)) {
    return;
   }
  }
  if (_aspxIsExists(this.crosshairRenderer)) {
   this.crosshairRenderer.Hide();
  }
  if (_aspxIsExists(this.chart.toolTipController)) {
   this.chart.toolTipController.Hide();
  }
 },
 CalculateEventX: function(clickedElement, mouseEventX) {
  var left = _aspxGetAbsoluteX(clickedElement);
  return Math.abs(mouseEventX - left);
 },
 CalculateEventY: function(clickedElement, mouseEventY) {
  var top = _aspxGetAbsoluteY(clickedElement);
  return Math.abs(mouseEventY - top);
 },
 OnClick: function(evt) {
  var processOnServer = this.IsServerEventAssigned("ObjectSelected");
  var mouseEventX = _aspxGetEventX(evt);
  var mouseEventY = _aspxGetEventY(evt);
  var htmlElement = _aspxGetEventSource(evt);
  if (_aspxGetIsParent(this.GetMainDOMElement(), htmlElement))
   htmlElement = document.getElementById(this.name + '_IMG');
  var x = this.CalculateEventX(htmlElement, mouseEventX);
  var y = this.CalculateEventY(htmlElement, mouseEventY);
  var showToolTip = _aspxIsExists(this.chart.toolTipController);
  var raiseObjectSelected = _aspxIsExists(this.RaiseObjectSelected);
  if (showToolTip || raiseObjectSelected) {
   var hitObjects = this.HitTest(x, y);
   if (hitObjects != null)
    var hitInfo = new ASPxClientWebChartHitInfo(hitObjects);
  }
  if (raiseObjectSelected)
   processOnServer = this.RaiseObjectSelected(x, y, htmlElement, mouseEventX, mouseEventY, hitObjects, hitInfo);
  if (processOnServer) {
   var eventParams = "SELECT:" + x + ":" + y;
   if (this.autoPostBack)
    this.SendPostBack(eventParams);
   else if (_aspxIsExists(this.callBack))
    this.ChartCallback(eventParams);
  }
  if (showToolTip && this.chart.toolTipController.openMode == "OnClick") {
   if (hitObjects == null)
    return;
   this.chart.toolTipController.Show(mouseEventX, mouseEventY, hitInfo, _aspxGetAbsoluteX(htmlElement), _aspxGetAbsoluteY(htmlElement));
  }
 },
 OnMouseMove: function(evt) {
  var raiseObjectHotTracked = _aspxIsExists(this.RaiseObjectHotTracked);
  var showToolTip = _aspxIsExists(this.chart) ? _aspxIsExists(this.chart.toolTipController) : false;
  var showCrosshair = _aspxIsExists(this.chart) ? this.chart.showCrosshair : false;
  if (raiseObjectHotTracked || showToolTip || showCrosshair) {
   var mouseEventX = _aspxGetEventX(evt);
   var mouseEventY = _aspxGetEventY(evt);
   var htmlElement = _aspxGetEventSource(evt);
   if (_aspxGetIsParent(this.GetMainDOMElement(), htmlElement))
    htmlElement = document.getElementById(this.name + '_IMG');
   var x = this.CalculateEventX(htmlElement, mouseEventX);
   var y = this.CalculateEventY(htmlElement, mouseEventY);
   var hitObjects = this.HitTest(x, y);
   if (hitObjects == null)
    return;
   var hitInfo = new ASPxClientWebChartHitInfo(hitObjects);
   if (raiseObjectHotTracked)
    this.RaiseObjectHotTracked(x, y, htmlElement, mouseEventX, mouseEventY, hitObjects, hitInfo);
   if (showCrosshair) {
    if (!_aspxIsExists(this.crosshairRenderer))
     this.crosshairRenderer = new ASPxClientCrosshairRenderer(this, this.name + '_CH');
    this.crosshairRenderer.UpdateCrosshair(x, y);
   }
   if (showToolTip) {
    if (this.chart.toolTipController.openMode == "OnHover")
     this.chart.toolTipController.Show(mouseEventX, mouseEventY, hitInfo, _aspxGetAbsoluteX(htmlElement), _aspxGetAbsoluteY(htmlElement));
   }
  }
 },
 ensurePrintFrame: function() {
  if (this.frameElement != null && __aspxIE) {
   this.frameElement.parentNode.removeChild(this.frameElement);
   this.frameElement = null;
  }
  if (this.frameElement == null)
   this.frameElement = this.createFrameElement("DXPrinter");
  this.printFrame = window.frames[this.frameElement.id];
 },
 createFrameElement: function(name) {
  var f = document.createElement("iframe");
  f.frameBorder = "0";
  f.style.overflow = "hidden";
  f.style.width = "0px";
  f.style.height = "0px";
  f.name = name;
  f.id = name;
  document.body.appendChild(f);
  return f;
 },
 getFrame: function() {
  this.ensurePrintFrame();
  return this.printFrame;
 },
 CallbackSaveToDisk: function(result) {
  this.getFrame().location = result;
 },
 CallbackSaveToWindow: function(result) {
  if (this.exportWindow != null && !this.exportWindow.closed) {
   this.exportWindow.location = result;
  }
 },
 OnCallback: function(result) {
  var printSign = "PRINT:";
  if (result.indexOf(printSign) >= 0) {
   this.CallbackSaveToDisk(result.substring(printSign.length));
   return;
  }
  var saveToDiskSign = "SAVETODISK:";
  if (result.indexOf(saveToDiskSign) >= 0) {
   this.CallbackSaveToDisk(result.substring(saveToDiskSign.length));
   return;
  }
  var saveToWindowSign = "SAVETOWINDOW:";
  if (result.indexOf(saveToWindowSign) >= 0) {
   this.CallbackSaveToWindow(result.substring(saveToWindowSign.length));
   return;
  }
  var resultParams = result.split("|");
  if (resultParams.length >= 3) {
   var htmlImage = document.getElementById(this.name + '_IMG');
   if (_aspxIsExists(htmlImage))
    htmlImage.setAttribute("src", resultParams[0]);
   var htmlField = document.getElementById(resultParams[1]);
   if (_aspxIsExists(htmlField))
    htmlField.setAttribute("value", resultParams[2]);
   if (resultParams.length >= 5) {
    this.LoadHitInfo(eval(resultParams[3]));
    var objectModel = "";
    for (var i = 4; i < resultParams.length; i++) {
     if (objectModel != "")
      objectModel += "|";
     objectModel += resultParams[i];
    }
    this.InitObjectModel(eval("(" + objectModel + ")"));
   }
  }
 },
 LoadHitInfo: function(hitInfo) {
  this.hitTestController = new ChartHitTestController(hitInfo);
 },
 InitObjectModel: function(objectModel) {
  this.chart = new ASPxClientWebChart(this, objectModel);
 },
 SetOperaCursor: function(cursor, htmlElement) {
  var divId = this.name + "_DIV";
  var div = _aspxGetElementById(divId);
  if (!_aspxIsExists(div) || (div.tagName != "DIV") || (div != htmlElement.parentNode))
   div = null;
  oldCursor = div != null ? div.style.cursor : htmlElement.style.cursor;
  if (!_aspxIsExists(oldCursor))
   oldCursor = "default";
  if (cursor != oldCursor) {
   if (div == null) {
    div = document.createElement("div");
    div.id = divId;
    div.style.backgroundColor = "transparent";
    div.style.border = "none";
    div.style.cursor = cursor;
    htmlElement.parentNode.replaceChild(div, htmlElement);
    div.appendChild(htmlElement);
   }
   else
    div.parentNode.replaceChild(htmlElement, div);
  }
 },
 ChartCallback: function(eventParams) {
  if (_aspxIsExists(this.callBack)) {
   if (_aspxIsExists(this.crosshairRenderer)) {
    this.crosshairRenderer.Hide();
    this.crosshairRenderer = null;
   }
   if (_aspxIsExists(this.chart) && _aspxIsExists(this.chart.toolTipController)) {
    this.chart.toolTipController.Hide();
   }
   this.ShowLoadingPanel();
   this.CreateCallback(eventParams);
  }
  else
   this.SendPostBack(eventParams);
 },
 ShowLoadingPanel: function() {
  this.CreateLoadingPanelWithAbsolutePosition(this.GetMainElement().parentNode, this.GetMainElement());
 }
});
function __chartClick(evt, name) {
 var control = aspxGetControlCollection().Get(name);
 if(control != null)
  control.OnClick(evt);
}
function __chartMouseMove(evt, name) { 
 var control = aspxGetControlCollection().Get(name);
 if(control != null)
  control.OnMouseMove(evt);
}
ASPxClientScaleType = _aspxCreateClass(null, {});
ASPxClientScaleType.Qualitative = "Qualitative";
ASPxClientScaleType.Numerical = "Numerical";
ASPxClientScaleType.DateTime = "DateTime";
ASPxClientAlignment = _aspxCreateClass(null, {});
ASPxClientAlignment.Near = "Near";
ASPxClientAlignment.Center = "Center";
ASPxClientAlignment.Far = "Far";
ASPxClientTitleDockStyle = _aspxCreateClass(null, {});
ASPxClientTitleDockStyle.Left = "Left";
ASPxClientTitleDockStyle.Top = "Top";
ASPxClientTitleDockStyle.Right = "Right";
ASPxClientTitleDockStyle.Bottom = "Bottom";
ASPxClientValueLevel = _aspxCreateClass(null, {});
ASPxClientValueLevel.Value = "Value";
ASPxClientValueLevel.Value_1 = "Value_1";
ASPxClientValueLevel.Value_2 = "Value_2";
ASPxClientValueLevel.Low = "Low";
ASPxClientValueLevel.High = "High";
ASPxClientValueLevel.Open = "Open";
ASPxClientValueLevel.Close = "Close";
ASPxClientControlCoordinatesVisibility = _aspxCreateClass(null, {});
ASPxClientControlCoordinatesVisibility.Visible = "Visible";
ASPxClientControlCoordinatesVisibility.Hidden = "Hidden";
ASPxClientControlCoordinatesVisibility.Undefined = "Undefined";
ASPxClientWebChartControl.Cast = ASPxClientControl.Cast;
ASPxClientWebChartControl.prototype.GetChart = function() {
 return this.chart;
};
ASPxClientWebChartControl.prototype.SetCursor = function(cursor) {   
 var htmlElement = this.GetMainElement();
 if(_aspxIsExists(htmlElement)) {
  if(__aspxOpera)
   this.SetOperaCursor(cursor, htmlElement);
  else
   htmlElement.style.cursor = cursor;
 }
};
ASPxClientWebChartControl.prototype.RaiseObjectHotTracked = function(x, y, htmlElement, absoluteX, absoluteY, hitObjects, hitInfo) {
 for(var i = 0; i < hitObjects.length; i++) {
  var args = new ASPxClientWebChartControlHotTrackEventArgs(
   false,
   hitObjects[i].object, 
   hitObjects[i].additionalObject, 
   hitInfo,
   this.chart,
   htmlElement, 
   x, y, 
   absoluteX, absoluteY);
  this.ObjectHotTracked.FireEvent(this, args);
  if(!args.cancel)
   break;
 }
};
ASPxClientWebChartControl.prototype.RaiseObjectSelected = function(x, y, htmlElement, absoluteX, absoluteY, hitObjects, hitInfo) {
 var processOnServer = this.IsServerEventAssigned("ObjectSelected"); 
 if(hitObjects == null)
  return processOnServer;
 for(var i = 0; i < hitObjects.length; i++) {
  var args = new ASPxClientWebChartControlHotTrackEventArgs(
   processOnServer,
   hitObjects[i].object, 
   hitObjects[i].additionalObject,   
   hitInfo,
   this.chart,
   htmlElement, 
   x, y, 
   absoluteX, absoluteY);
  this.ObjectSelected.FireEvent(this, args);
  processOnServer = args.processOnServer;
  if(!args.cancel)
   break;
 }
 return processOnServer;
};
ASPxClientWebChartControl.prototype.HitTest = function(x, y) {
 if(_aspxIsExists(this.hitTestController))
  return this.hitTestController.HitTest(x, y);
 else
  return null;
};
ASPxClientWebChartControl.prototype.PerformCallback = function(args) {
 if (!_aspxIsExists(args)) args = "";
 this.ChartCallback("CUSTOMCALLBACK:" + args);
};
ASPxClientWebChartControl.prototype.Print = function() {
 if (!_aspxIsExists(this.callBack)) return;  
 this.ChartCallback("PRINT");
};
ASPxClientWebChartControl.prototype.SaveToDisk = function(format, filename) {
 if (!_aspxIsExists(this.callBack)) return;
 if (filename == undefined)
  this.ChartCallback("SAVETODISK:" + format + ":");
 else 
  this.ChartCallback("SAVETODISK:" + format + ":" + filename);
};
ASPxClientWebChartControl.prototype.SaveToWindow = function(format) {
 if (!_aspxIsExists(this.callBack)) return;  
 this.exportWindow = window.open('', '_blank', 'toolbars=no, resizable=yes, scrollbars=yes');
 this.ChartCallback("SAVETOWINDOW:" + format);
};
ASPxClientWebChartControl.prototype.GetMainDOMElement = function() {
 return this.GetMainElement();
}
ASPxClientWebChartControlHotTrackEventArgs = _aspxCreateClass(ASPxClientProcessingModeEventArgs, {
 constructor: function(processOnServer, hitObject, additionalHitObject, hitInfo, chart, htmlElement, x, y, absoluteX, absoluteY) {
  this.constructor.prototype.constructor.call(this, processOnServer);
  this.hitObject = hitObject;  
  this.additionalHitObject = additionalHitObject;
  this.hitInfo = hitInfo;
  this.chart = chart;
  this.htmlElement = htmlElement;
  this.x = x;
  this.y = y;
  if(typeof(absoluteX) != "undefined")
   this.absoluteX = absoluteX;
  else
   this.absoluteX = 0;
  if(typeof(absoluteY) != "undefined")  
   this.absoluteY = absoluteY;
  else
   this.absoluteY = 0;
  this.cancel = false;
 }
});
ASPxClientHitObject = _aspxCreateClass(null, {
 constructor: function(object, additionalObject) {
  this.object = object;
  this.additionalObject = additionalObject;
 }
});
ASPxClientWebChartHitInfo = _aspxCreateClass(null, {
 constructor: function(hitObjects) {
  this.inChart = false;
  this.inChartTitle = false;
  this.inAxis = false;
  this.inAxisLabelItem = false;
  this.inAxisTitle = false;
  this.inConstantLine = false;
  this.inDiagram = false;
  this.inNonDefaultPane = false;
  this.inLegend = false;
  this.inSeries = false;
  this.inSeriesLabel = false;
  this.inSeriesPoint = false;
  this.inSeriesTitle = false;
  this.inTrendLine = false;
  this.inFibonacciIndicator = false;
  this.inRegressionLine = false;
  this.inIndicator = false;
  this.inAnnotation = false;  
  this.chart = null;
  this.chartTitle = null;
  this.axis = null;
  this.constantLine = null;
  this.diagram = null;
  this.nonDefaultPane = null;
  this.legend = null;
  this.series = null;
  this.seriesLabel = null;
  this.seriesTitle = null;
  this.trendLine = null;
  this.fibonacciIndicator = null;
  this.regressionLine = null;
  this.indicator = null;
  this.annotation = null;
  this.seriesPoint = null;
  this.axisLabelItem = null;
  this.axisTitle = null;
  for (var i = 0; i < hitObjects.length; i++) {
   var obj = hitObjects[i].object;
   if (obj instanceof ASPxClientWebChart) {
    if (!this.inChart) {
     this.inChart = true;
     this.chart = obj;
    }
   }
   else if (obj instanceof ASPxClientChartTitle) {
    if (!this.inChartTitle) {
     this.inChartTitle = true;
     this.chartTitle = obj;
    }
   }
   else if ((obj instanceof ASPxClientAxis) || (obj instanceof ASPxClientSwiftPlotDiagramAxis) ||
      (obj instanceof ASPxClientAxis3D) || (obj instanceof ASPxClientRadarAxis)) {
    if (!this.inAxis) {
     this.inAxis = true;
     this.axis = obj;
    }
   }
   else if (obj instanceof ASPxClientConstantLine) {
    if (!this.inConstantLine) {
     this.inConstantLine = true;
     this.constantLine = obj;
    }
   }
   else if ((obj instanceof ASPxClientXYDiagram) || (obj instanceof ASPxClientSwiftPlotDiagram) ||
      (obj instanceof ASPxClientXYDiagram3D) || (obj instanceof ASPxClientRadarDiagram)) {
    if (!this.inDiagram) {
     this.inDiagram = true;
     this.diagram = obj;
    }
   }
   else if (obj instanceof ASPxClientXYDiagramPane) {
    if (!this.inNonDefaultPane) {
     this.inNonDefaultPane = true;
     this.nonDefaultPane = obj;
    }
   }
   else if (obj instanceof ASPxClientLegend) {
    if (!this.inLegend) {
     this.inLegend = true;
     this.legend = obj;
    }
   }
   else if (obj instanceof ASPxClientSeries) {
    if (!this.inSeries) {
     this.inSeries = true;
     this.series = obj;
    }
   }
   else if (obj instanceof ASPxClientSeriesLabel) {
    if (!this.inSeriesLabel) {
     this.inSeriesLabel = true;
     this.seriesLabel = obj;
    }
   }
   else if (obj instanceof ASPxClientSeriesTitle) {
    if (!this.inSeriesTitle) {
     this.inSeriesTitle = true;
     this.seriesTitle = obj;
    }
   }
   else if (obj instanceof ASPxClientIndicator) {
    this.inIndicator = true;
    this.indicator = obj;
    if (obj instanceof ASPxClientTrendLine) {
     if (!this.inTrendLine) {
      this.inTrendLine = true;
      this.trendLine = obj;
     }
    }
    else if (obj instanceof ASPxClientFibonacciIndicator) {
     if (!this.inFibonacciIndicator) {
      this.inFibonacciIndicator = true;
      this.fibonacciIndicator = obj;
     }
    }
    else if (obj instanceof ASPxClientRegressionLine) {
     if (!this.inRegressionLine) {
      this.inRegressionLine = true;
      this.regressionLine = obj;
     }
    }
   }
   else if (obj instanceof ASPxClientAnnotation) {
    if (!this.inAnnotation) {
     this.inAnnotation = true;
     this.annotation = obj;
    }
   }
   var additionalObj = hitObjects[i].additionalObject;
   if (additionalObj != null) {
    if (additionalObj instanceof ASPxClientSeriesPoint) {
     if (!this.inSeriesPoint) {
      this.inSeriesPoint = true;    
      this.seriesPoint = additionalObj;
     }
    }
    if (additionalObj instanceof ASPxClientAxisLabelItem) {
     if (!this.inAxisLabelItem) {
      this.inAxisLabelItem = true;
      this.axisLabelItem = additionalObj;
     }
    }
    if (additionalObj instanceof ASPxClientAxisTitle) {
     if (!this.inAxisTitle) {
      this.inAxisTitle = true;
      this.axisTitle = additionalObj;
     }
    }
   }     
  }
 }
});
ASPxClientDiagramCoordinates = _aspxCreateClass(null, {
 constructor: function() {
  this.argumentScaleType = '';
  this.valueScaleType = '';
  this.qualitativeArgument = '';
  this.numericalArgument = 0;
  this.dateTimeArgument = null;
  this.numericalValue = 0;
  this.dateTimeValue = null;
  this.axisX = null;  
  this.axisY = null;  
  this.pane = null;
  this.axisValueList = new Array();
 },
 SetAxisValue: function(axis, valueInternal) {
  var value = axis.GetNativeArgument(valueInternal);
  var axisValue = new ASPxClientAxisValue();
  axisValue.axis = axis;
  if (typeof(value) == 'string') {
   axisValue.qualitativeValue = value;  
   axisValue.scaleType = ASPxClientScaleType.Qualitative;
  }
  else if (value instanceof Date) {
   axisValue.dateTimeValue = value;
   axisValue.scaleType = ASPxClientScaleType.DateTime;
  }
  else {
   axisValue.numericalValue = value;
   axisValue.scaleType = ASPxClientScaleType.Numerical;
  }   
  this.axisValueList.push(axisValue);  
 },
 SetArgumentAndValue: function(axisX, axisY, argumentInternal, valueInternal) {
  var argument = axisX.GetNativeArgument(argumentInternal);
  var value = axisY.GetNativeArgument(valueInternal);
  if (typeof(argument) == 'string') {
   this.qualitativeArgument = argument;  
   this.argumentScaleType = ASPxClientScaleType.Qualitative;
  }
  else if (argument instanceof Date) {
   this.dateTimeArgument = argument;
   this.argumentScaleType = ASPxClientScaleType.DateTime;
  }
  else {
   this.numericalArgument = argument;
   this.argumentScaleType = ASPxClientScaleType.Numerical;
  }
  if (value instanceof Date) {
   this.dateTimeValue = value;
   this.valueScaleType = ASPxClientScaleType.DateTime;
  }
  else {
   this.numericalValue = value;
   this.valueScaleType = ASPxClientScaleType.Numerical;
  }  
  this.SetAxisValue(axisX, argumentInternal);
  this.SetAxisValue(axisY, valueInternal);
 },
 IsEmpty: function() {
  return this.argumentScaleType == '';
 },
 GetAxisValue: function(axis) {
  for(var i = 0; i < this.axisValueList.length; i++)
   if (axis == this.axisValueList[i].axis)
    return this.axisValueList[i];
  return null;
 }
});
ASPxClientAxisValue = _aspxCreateClass(null, {
 constructor: function() {
  this.scaleType = '';
  this.qualitativeValue = '';
  this.numericalValue = 0;
  this.dateTimeValue = null;
  this.axis = null;
 }
});
ASPxClientControlCoordinates = _aspxCreateClass(null, {
 constructor: function() {
  this.pane = null;
  this.x = 0;
  this.y = 0;
  this.visibility = ASPxClientControlCoordinatesVisibility.Undefined;
 },
 GetValueSign: function(value) {
  if(value < 0) 
   return -1;
  if(value > 0) 
   return 1;
  return 0;
 },
 StrongRound: function(value) {
  return this.GetValueSign(value) * Math.floor(Math.abs(value) + 0.5);
 },
 SetPoint: function(x, y) {
  this.x = this.StrongRound(x);
  this.y = this.StrongRound(y);
 }
});
ASPxClientWebChartElement = _aspxCreateClass(null, {
 constructor: function(chart, interimObject) {
  this.chart = chart;  
  if(_aspxIsExists(interimObject)) {
   this.InitializeProperties(interimObject);
   this.InitializeHitObjects(interimObject);
  }
  else
   this.InitializeDefault();
 },
 InitializeProperties: function(interimObject) {
  throw "ASPxClientWebChartElement abstract error";
 },
 InitializeDefault: function() {
  throw "ASPxClientWebChartElement abstract error";
 },
 InitializeHitObjects: function(interimObject) {
  var chartControl = this.chart != null ? this.chart.chartControl : this.chartControl;
  if(_aspxIsExists(chartControl)) {
   if(_aspxIsExists(chartControl.hitTestController)) {
    var hitTestController = chartControl.hitTestController;
    if(_aspxIsExists(interimObject.hi))
     hitTestController.objects[interimObject.hi] = this;
    else if(_aspxIsExists(interimObject.hia))
     hitTestController.additionalObjects[interimObject.hia] = this;
   }
  }  
 },
 CreateArray: function(interimArray, createArrayItem) {
  if(!_aspxIsExists(interimArray))
   return [];
  if(!(interimArray instanceof Array))
   throw ASPxClientWebChartElement.objectModelError;     
  var result = new Array();
  for(var i = 0; i < interimArray.length; i++)
   result.push(createArrayItem(this.chart, this, interimArray[i]));
  return result;   
 }
});
ASPxClientWebChartElement.objectModelError = "Client object model error";
ASPxClientWebChartEmptyElement = _aspxCreateClass(ASPxClientWebChartElement, {
 constructor: function(chart, interimObject) {
  this.constructor.prototype.constructor.call(this, chart, interimObject);
 },
 InitializeProperties: function(interimObject) {
 },
 InitializeDefault: function() {
 }
});
ASPxClientWebChartRequiredElement = _aspxCreateClass(ASPxClientWebChartElement, {
 constructor: function(chart, interimObject) {
  this.constructor.prototype.constructor.call(this, chart, interimObject);
 },
 InitializeDefault: function() {
  throw ASPxClientWebChartElement.objectModelError;
 } 
});
ASPxClientWebChartElementNamed = _aspxCreateClass(ASPxClientWebChartRequiredElement, {
 constructor: function(chart, interimObject) {
  this.constructor.prototype.constructor.call(this, chart, interimObject);
 },
 InitializeProperties: function(interimObject) {
  if(!_aspxIsExists(interimObject.n))
   throw ASPxClientWebChartElement.objectModelError;
  this.name = interimObject.n;
 }
});
ASPxClientWebChart = _aspxCreateClass(ASPxClientWebChartRequiredElement, {
 constructor: function(chartControl, interimChart) {
  this.chartControl = chartControl;
  this.constructor.prototype.constructor.call(this, null, interimChart);
 },
 InitializeProperties: function(interimObject) {
  this.diagram =
   _aspxIsExists(interimObject.d) ?
   this.CreateXYDiagram(interimObject.d) :
   new ASPxClientSimpleDiagram(this);
  this.series = this.CreateSeriesArray(interimObject.s);
  this.titles = this.CreateTitles(interimObject.ti);
  this.annotations = this.CreateAnnotations(interimObject.a);
  this.legend = new ASPxClientLegend(this, interimObject.l);
  this.appearanceName = interimObject.an;
  this.paletteName = interimObject.pn;
  this.showSeriesToolTip = _aspxIsExists(interimObject.sst) ? interimObject.sst : false;
  this.showPointToolTip = _aspxIsExists(interimObject.spt) ? interimObject.spt : false;
  this.showCrosshair = _aspxIsExists(interimObject.sc) ? interimObject.sc : false;
  this.toolTipPosition = this.CreateToolTipPosition(this, interimObject.ttp);
  this.toolTipController = this.CreateToolTipController(this, interimObject.ttc);
  this.crosshairOptions = this.CreateCrosshairOptions(this, interimObject.co);
  this.cssPostfix = _aspxIsExists(interimObject.css) ? interimObject.css : "";
 },
 CreateXYDiagram: function(interimXYDiagram) {
  if (interimXYDiagram.t == "XYD")
   return new ASPxClientXYDiagram(this, interimXYDiagram);
  else if (interimXYDiagram.t == "SPD")
   return new ASPxClientSwiftPlotDiagram(this, interimXYDiagram);
  else if (interimXYDiagram.t == "XYD3")
   return new ASPxClientXYDiagram3D(this, interimXYDiagram);
  else if (interimXYDiagram.t == "RD")
   return new ASPxClientRadarDiagram(this, interimXYDiagram);
  else
   throw ASPxClientWebChartElement.objectModelError;
 },
 CreateSeriesArray: function(interimSeriesArray) {
  return this.CreateArray(interimSeriesArray, function(nullChart, chart, intermSeries) {
   return new ASPxClientSeries(chart, intermSeries);
  });
 },
 CreateTitles: function(interimTitles) {
  return this.CreateArray(interimTitles, function(nullChart, chart, interimTitle) {
   return new ASPxClientChartTitle(chart, interimTitle);
  });
 },
 CreateAnnotations: function(interimAnnotations) {
  return this.CreateArray(interimAnnotations, function(nullChart, chart, interimAnnotation) {
   if (interimAnnotation.t == "TA")
    return new ASPxClientTextAnnotation(chart, interimAnnotation);
   else if (interimAnnotation.t == "IA")
    return new ASPxClientImageAnnotation(chart, interimAnnotation);
   else
    throw ASPxClientWebChartElement.objectModelError;
  });
 },
 CreateToolTipPosition: function(chart, interimPosition) {
  if (_aspxIsExists(interimPosition) && (chart.showSeriesToolTip || chart.showPointToolTip)) {
   if (interimPosition.t == "FP")
    return new ASPxClientToolTipFreePosition(interimPosition);
   else if (interimPosition.t == "RP")
    return new ASPxClientToolTipRelativePosition(interimPosition);
   else if (interimPosition.t == "MP")
    return new ASPxClientToolTipMousePosition(interimPosition);
  }
  return null;
 },
 CreateToolTipController: function(chart, interimToolTipController) {
  if (_aspxIsExists(interimToolTipController) && (chart.showSeriesToolTip || chart.showPointToolTip))
   return new ASPxClientToolTipController(chart, interimToolTipController);
  return null;
 },
 CreateCrosshairOptions: function(chart, interimCrosshairOptions) {
  if (chart.showCrosshair)
   return new ASPxClientCrosshairOptions(chart, interimCrosshairOptions);
  return null;
 }
});
ASPxClientSimpleDiagram = _aspxCreateClass(ASPxClientWebChartEmptyElement, {
 constructor: function(chart) {
  this.constructor.prototype.constructor.call(this, chart);
 }
});
ASPxClientXYDiagramBase = _aspxCreateClass(ASPxClientWebChartRequiredElement, {
 constructor: function(chart, interimXYDiagram) {
  this.constructor.prototype.constructor.call(this, chart, interimXYDiagram);
 },
 InitializeProperties: function(interimObject) {
  this.axisX = this.CreateAxis(interimObject.x);
  this.axisY = this.CreateAxis(interimObject.y);
 },
 CreateAxis: function(interimAxis) {
  throw "ASPxClientXYDiagramBase abstract error";
 }
});
ASPxClientXYDiagram2D = _aspxCreateClass(ASPxClientXYDiagramBase, {
 constructor: function(chart, interimXYDiagram) {
  this.constructor.prototype.constructor.call(this, chart, interimXYDiagram);
 },
 InitializeProperties: function(interimObject) {
  ASPxClientXYDiagramBase.prototype.InitializeProperties.call(this, interimObject);
  this.secondaryAxesX = this.CreateSecondaryAxes(interimObject.sx);
  this.secondaryAxesY = this.CreateSecondaryAxes(interimObject.sy);
  this.defaultPane = new ASPxClientXYDiagramPane(this.chart, this, interimObject.dp);
  this.panes = this.CreatePanes(interimObject.pa);
  if (_aspxIsExists(interimObject.pld))
   this.paneLayoutDirection = interimObject.pld;
 },
 CreateSecondaryAxes: function(interimSecondaryAxes) {
  throw "ASPxClientXYDiagramBase abstract error";
 },
 CreatePanes: function(interimPanes) {
  return this.CreateArray(interimPanes, function(chart, diagram, interimPane) {
   return new ASPxClientXYDiagramPane(chart, diagram, interimPane);
  });
 },
 FindPaneByXY: function(x, y) {
  if (this.defaultPane.InPane(x, y))
   return this.defaultPane;
  for (var i = 0; i < this.panes.length; i++) {
   if (this.panes[i].InPane(x, y))
    return this.panes[i];
  }
  return null;
 },
 FindPaneByID: function(paneID) {
  if (paneID == -1)
   return this.defaultPane;
  if (this.panes != null) {
   for (var pane in this.panes) {
    if (this.panes[pane].paneID == paneID)
     return this.panes[pane];
   }
  }
  return null;
 },
 FindAxisXByID: function(axisID) {
  if (this.axisX.axisID == axisID)
   return this.axisX;
  for (var i = 0; i < this.secondaryAxesX.length; i++) {
   if (this.secondaryAxesX[i].axisID == axisID)
    return this.secondaryAxesX[i];
  }
  return null;
 },
 FindAxisYByID: function(axisID) {
  if (this.axisY.axisID == axisID)
   return this.axisY;
  for (var i = 0; i < this.secondaryAxesY.length; i++) {
   if (this.secondaryAxesY[i].axisID == axisID)
    return this.secondaryAxesY[i];
  }
  return null;
 },
 CalculateAxisValues: function(pane, axis, location, length) {
  if (axis == null)
   return null;
  if (axis.reverse)
   location = length - location;
  var cacheItem = axis.intervalBoundsCaches.GetIntervalBoundsCacheItemByPaneID(pane.paneID);
  if (cacheItem == null)
   return null;
  var index = cacheItem.GetIntervalBoundsIndexByLocation(location);
  if (index < 0 || index >= axis.intervals.length)
   return null;
  var intervalBounds = cacheItem.intervalBoundsArray[index];
  var ratio = (location - intervalBounds.position) / intervalBounds.length;
  var interval = axis.intervals[index];
  var valueInternal = interval.GetInternalValue(ratio);
  return valueInternal;
 },
 AddAxisValueToAxisValueList: function(axisValues, pane, axis, location, length) {
  valueInternal = this.CalculateAxisValues(pane, axis, location, length);
  if (valueInternal != null)
   axisValues.push(new ASPxAxisValuePair(axis, valueInternal, location));
 },
 MapPointToInternal: function(pane, x, y) {
  var axisValues = [];
  var axesCoords = this.GetAxesCoordinates(pane, x, y);
  if (axesCoords == null)
   return axisValues;
  this.AddAxisValueToAxisValueList(axisValues, pane, this.FindAxisXByID(pane.primaryAxisXID), axesCoords.xLocation, axesCoords.xLength);
  this.AddAxisValueToAxisValueList(axisValues, pane, this.FindAxisYByID(pane.primaryAxisYID), axesCoords.yLocation, axesCoords.yLength);
  for (var i = 0; i < this.secondaryAxesX.length; i++)
   this.AddAxisValueToAxisValueList(axisValues, pane, this.secondaryAxesX[i], axesCoords.xLocation, axesCoords.xLength);
  for (var i = 0; i < this.secondaryAxesY.length; i++)
   this.AddAxisValueToAxisValueList(axisValues, pane, this.secondaryAxesY[i], axesCoords.yLocation, axesCoords.yLength);
  return axisValues;
 },
 AddAxisValue: function(coordinates, pane, axis, location, length) {
  var valueInternal = this.CalculateAxisValues(pane, axis, location, length);
  if (valueInternal != null)
   coordinates.SetAxisValue(axis, valueInternal);
 },
 GetAxesCoordinates: function(pane, x, y) {
  x -= pane.boundsLeft;
  y -= pane.boundsTop;
  if (x < 0 || x > pane.boundsWidth || y < 0 || y > pane.boundsHeight)
   return null;
  y = pane.boundsHeight - y;
  if (this.rotated)
   return { xLocation: y, yLocation: x, xLength: pane.boundsHeight, yLength: pane.boundsWidth };
  else
   return { xLocation: x, yLocation: y, xLength: pane.boundsWidth, yLength: pane.boundsHeight };
 },
 PointToDiagram: function(x, y) {
  var coordinates = new ASPxClientDiagramCoordinates();
  var pane = this.FindPaneByXY(x, y);
  if (pane == null)
   return coordinates;
  coordinates.pane = pane;
  var axesCoords = this.GetAxesCoordinates(pane, x, y);
  if (axesCoords == null)
   return coordinates;
  coordinates.axisX = this.FindAxisXByID(pane.primaryAxisXID);
  coordinates.axisY = this.FindAxisYByID(pane.primaryAxisYID);
  var argumentInternal = this.CalculateAxisValues(pane, coordinates.axisX, axesCoords.xLocation, axesCoords.xLength);
  var valueInternal = this.CalculateAxisValues(pane, coordinates.axisY, axesCoords.yLocation, axesCoords.yLength);
  if (argumentInternal != null && valueInternal != null)
   coordinates.SetArgumentAndValue(coordinates.axisX, coordinates.axisY, argumentInternal, valueInternal);
  for (var i = 0; i < this.secondaryAxesX.length; i++)
   this.AddAxisValue(coordinates, pane, this.secondaryAxesX[i], axesCoords.xLocation, axesCoords.xLength);
  for (var i = 0; i < this.secondaryAxesY.length; i++)
   this.AddAxisValue(coordinates, pane, this.secondaryAxesY[i], axesCoords.yLocation, axesCoords.yLength);
  return coordinates;
 },
 CalcIntervalIndexes: function(value, intervals) {
  var resultIndexes = new Array();
  var aboveIndex = -1;
  var belowIndex = -1;
  for (var i = 0; i < intervals.length; i++) {
   if (intervals[i].minLimit <= value && value <= intervals[i].maxLimit) {
    resultIndexes.push(i);
    return { indexes: resultIndexes, inRange: true };
   }
   if (value > intervals[i].maxLimit) {
    if (belowIndex == -1)
     belowIndex = i;
    else if (intervals[belowIndex].maxLimit < intervals[i].maxLimit)
     belowIndex = i;
   }
   if (value < intervals[i].minLimit) {
    if (aboveIndex == -1)
     aboveIndex = i;
    else if (intervals[aboveIndex].minLimit > intervals[i].minLimit)
     aboveIndex = i;
   }
  }
  if (belowIndex != -1)
   resultIndexes.push(belowIndex);
  if (aboveIndex != -1)
   resultIndexes.push(aboveIndex);
  return { indexes: resultIndexes, inRange: false };
 },
 CalcCoordWithinAndOutRange: function(value, intervals, cacheItem, index) {
  var min = intervals[index].minLimit;
  var max = intervals[index].maxLimit;
  var factor = max - min != 0 ? (value - min) / (max - min) : 0;
  var intervalBounds = cacheItem.intervalBoundsArray[index];
  return factor * intervalBounds.length + intervalBounds.position;
 },
 CalcCoordInScaleBreak: function(value, intervals, cacheItem, index1, index2) {
  var min = intervals[index1].maxLimit;
  var max = intervals[index2].minLimit;
  var factor = max - min != 0 ? (value - min) / (max - min) : 0;
  var intervalBoundsMin = cacheItem.intervalBoundsArray[index1];
  var intervalBoundsMax = cacheItem.intervalBoundsArray[index2];
  return factor * (intervalBoundsMax.position - intervalBoundsMin.highBound) + intervalBoundsMin.highBound;
 },
 CalcCoord: function(value, indexes, axis, cacheItem, length) {
  var coord;
  if (indexes.length == 1)
   coord = this.CalcCoordWithinAndOutRange(value, axis.intervals, cacheItem, indexes[0]);
  else
   coord = this.CalcCoordInScaleBreak(value, axis.intervals, cacheItem, indexes[0], indexes[1]);
  if (axis.reverse)
   coord = length - coord;
  return coord;
 },
 CheckIndexes: function(indexes, intervals, cacheItem) {
  if (indexes.length < 1 || indexes.length > 2)
   return false;
  for (var i = 0; i < indexes.length; i++) {
   if (indexes[i] < 0 || indexes[i] >= intervals.length || indexes[i] >= cacheItem.intervalBoundsArray.length)
    return false;
  }
  return true;
 },
 FindAxisXByName: function(name) {
  if (this.axisX.name == name)
   return this.axisX;
  for (var i = 0; i < this.secondaryAxesX.length; i++) {
   if (this.secondaryAxesX[i].name == name)
    return this.secondaryAxesX[i];
  }
  return null;
 },
 FindAxisYByName: function(name) {
  if (this.axisY.name == name)
   return this.axisY;
  for (var i = 0; i < this.secondaryAxesY.length; i++) {
   if (this.secondaryAxesY[i].name == name)
    return this.secondaryAxesY[i];
  }
  return null;
 },
 IsAxisValueVisible: function(pane, axis, value) {
  var cacheItem = axis.intervalBoundsCaches.GetIntervalBoundsCacheItemByPaneID(pane.paneID);
  if (cacheItem == null)
   return false;
  var result = this.CalcIntervalIndexes(value, axis.intervals);
  if (!result.inRange)
   return false;
  var indexes = result.indexes;
  if (!this.CheckIndexes(indexes, axis.intervals, cacheItem))
   return false;
  return true;
 },
 MapInternalToPoint: function(pane, axisName, value) {
  var isHorizontal;
  var axis = this.FindAxisXByName(axisName);
  if (axis != null)
   isHorizontal = !this.rotated;
  else {
   axis = this.FindAxisYByName(axisName);
   if (axis != null)
    isHorizontal = this.rotated;
   else
    return null;
  }
  var cacheItem = axis.intervalBoundsCaches.GetIntervalBoundsCacheItemByPaneID(pane.paneID);
  if (cacheItem == null)
   return null;
  var result = this.CalcIntervalIndexes(value, axis.intervals);
  if (!result.inRange)
   return null;
  var indexes = result.indexes;
  if (!this.CheckIndexes(indexes, axis.intervals, cacheItem))
   return null;
  var length = isHorizontal ? pane.boundsWidth : pane.boundsHeight;
  var pointValue = this.CalcCoord(value, indexes, axis, cacheItem, length);
  if (isHorizontal)
   pointValue += pane.boundsLeft;
  else
   pointValue = pane.boundsHeight - pointValue + pane.boundsTop;
  return pointValue;
 },
 DiagramToPoint: function(argument, value, axisX, axisY, pane) {
  var coordinates = new ASPxClientControlCoordinates();
  if (!_aspxIsExists(axisX.intervalBoundsCaches) || !_aspxIsExists(axisY.intervalBoundsCaches))
   return coordinates;
  coordinates.pane = pane;
  var cacheItemX = axisX.intervalBoundsCaches.GetIntervalBoundsCacheItemByPaneID(pane.paneID);
  var cacheItemY = axisY.intervalBoundsCaches.GetIntervalBoundsCacheItemByPaneID(pane.paneID);
  if (cacheItemX == null || cacheItemY == null)
   return coordinates;
  var argumentInternal = axisX.GetInternalArgument(argument);
  if (axisX.scale instanceof ASPxClientQualitativeMap
   && (argumentInternal < axisX.intervals[0].minLimit || argumentInternal > axisX.intervals[axisX.intervals.length - 1].maxLimit))
   return coordinates;
  var valueInternal = axisY.GetInternalArgument(value);
  var resultsX = this.CalcIntervalIndexes(argumentInternal, axisX.intervals);
  var resultsY = this.CalcIntervalIndexes(valueInternal, axisY.intervals);
  var indexesX = resultsX.indexes;
  var indexesY = resultsY.indexes;
  if (!this.CheckIndexes(indexesX, axisX.intervals, cacheItemX)
   || !this.CheckIndexes(indexesY, axisY.intervals, cacheItemY))
   return coordinates;
  coordinates.visibility = resultsX.inRange && resultsY.inRange ? ASPxClientControlCoordinatesVisibility.Visible
   : ASPxClientControlCoordinatesVisibility.Hidden;
  var x, y;
  if (!this.rotated) {
   x = this.CalcCoord(argumentInternal, indexesX, axisX, cacheItemX, pane.boundsWidth);
   y = this.CalcCoord(valueInternal, indexesY, axisY, cacheItemY, pane.boundsHeight);
  }
  else {
   x = this.CalcCoord(valueInternal, indexesY, axisY, cacheItemY, pane.boundsWidth);
   y = this.CalcCoord(argumentInternal, indexesX, axisX, cacheItemX, pane.boundsHeight);
  }
  coordinates.SetPoint(x + pane.boundsLeft, pane.boundsTop + pane.boundsHeight - y);
  return coordinates;
 }
});
ASPxClientXYDiagram = _aspxCreateClass(ASPxClientXYDiagram2D, {
 constructor: function(chart, interimXYDiagram) {
  this.constructor.prototype.constructor.call(this, chart, interimXYDiagram);
 },
 InitializeProperties: function(interimObject) {
  ASPxClientXYDiagram2D.prototype.InitializeProperties.call(this, interimObject);
  if (!_aspxIsExists(interimObject.dr))
   throw ASPxClientWebChartElement.objectModelError;
  this.rotated = interimObject.dr;  
 },
 CreateAxis: function(interimAxis) {
  return new ASPxClientAxis(this.chart, this, interimAxis);
 },
 CreateSecondaryAxes: function(interimSecondaryAxes) {
  return this.CreateArray(interimSecondaryAxes, function(chart, diagram, interimSecondaryAxis) {
   return new ASPxClientAxis(chart, diagram, interimSecondaryAxis);
  });
 }
});
ASPxClientSwiftPlotDiagram = _aspxCreateClass(ASPxClientXYDiagram2D, {
 constructor: function(chart, interimXYDiagram) {
  this.constructor.prototype.constructor.call(this, chart, interimXYDiagram);
 },
 InitializeProperties: function(interimObject) {
  ASPxClientXYDiagram2D.prototype.InitializeProperties.call(this, interimObject);
 },
 CreateAxis: function(interimAxis) {
  return new ASPxClientSwiftPlotDiagramAxis(this.chart, this, interimAxis);
 },
 CreateSecondaryAxes: function(interimSecondaryAxes) {
  return this.CreateArray(interimSecondaryAxes, function(chart, diagram, interimSecondaryAxis) {
   return new ASPxClientSwiftPlotDiagramAxis(chart, diagram, interimSecondaryAxis);
  });
 }
});
ASPxClientXYDiagramPane = _aspxCreateClass(ASPxClientWebChartElementNamed, {
 constructor: function(chart, diagram, interimPane) {
  this.constructor.prototype.constructor.call(this, chart, interimPane);
  this.diagram = diagram;
 },
 InitializeProperties: function(interimObject) {
  ASPxClientWebChartElementNamed.prototype.InitializeProperties.call(this, interimObject);
  this.primaryAxisXID = interimObject.paxi;
  this.primaryAxisYID = interimObject.payi;
  this.paneID = interimObject.id;
  if (_aspxIsExists(interimObject.dx))
   this.boundsLeft = interimObject.dx;
  if (_aspxIsExists(interimObject.dy))
   this.boundsTop = interimObject.dy;
  if (_aspxIsExists(interimObject.dw))
   this.boundsWidth = interimObject.dw;
  if (_aspxIsExists(interimObject.dh))
   this.boundsHeight = interimObject.dh;
  if (_aspxIsExists(interimObject.lb))
   this.axisLabelBounds = this.CreateAxisLabelBounds(interimObject.lb);
 },
 CreateAxisLabelBounds: function(interimAxisLabelBounds) {
  return this.CreateArray(interimAxisLabelBounds, function(chart, pane, interimObject) {
   return new ASPxClientAxisLabelBounds(chart, interimObject);
  });
 },
 InPane: function(x, y) {
  if (_aspxIsExists(this.boundsLeft) && _aspxIsExists(this.boundsTop) &&
   _aspxIsExists(this.boundsWidth) && _aspxIsExists(this.boundsHeight) &&
   (this.boundsWidth > 0) && (this.boundsHeight > 0)) {
   x -= this.boundsLeft;
   y -= this.boundsTop;
   return (x >= 0) && (x <= this.boundsWidth) && (y >= 0) && (y <= this.boundsHeight);
  }
  return false;
 }
});
ASPxClientXYDiagram3D = _aspxCreateClass(ASPxClientXYDiagramBase, {
 constructor: function(chart, interimXYDiagram) {
  this.constructor.prototype.constructor.call(this, chart, interimXYDiagram);
 },
 CreateAxis: function(interimAxis) {  
  return new ASPxClientAxis3D(this.chart, this, interimAxis);
 }
});
ASPxClientRadarDiagram = _aspxCreateClass(ASPxClientXYDiagramBase, {
 constructor: function(chart, interimXYDiagram) {
  this.constructor.prototype.constructor.call(this, chart, interimXYDiagram);
 },
  InitializeProperties: function(interimObject) {
  ASPxClientXYDiagramBase.prototype.InitializeProperties.call(this, interimObject);
  if (_aspxIsExists(interimObject.m))
   this.mapping = new ASPxClientRadarDiagramMapping(interimObject.m);
 },
 CreateAxis: function(interimAxis) {
  return new ASPxClientRadarAxis(this.chart, this, interimAxis);  
 },
 CorrectAngle: function(angle) {
  if (this.mapping.revertAngle && angle != 0)
    angle = 2 * Math.PI - angle;
  if (this.mapping.diagramStartAngle >= 0) {
   if (angle >= this.mapping.diagramStartAngle)
    angle -= this.mapping.diagramStartAngle;
   else
    angle = 2 * Math.PI - this.mapping.diagramStartAngle + angle;
  }
  else {
   if (angle < 2 * Math.PI + this.mapping.diagramStartAngle)
    angle -= this.mapping.diagramStartAngle;
   else
    angle = angle - 2 * Math.PI - this.mapping.diagramStartAngle;
  }
  return angle;
 },
 CalcArgumentAndValueForPolygon: function(angle, dx, dy) {
  if (this.mapping.vertices.length <= 1)
   return null;
  var k = angle / (2 * Math.PI / (this.mapping.vertices.length - 1));
  var index = Math.floor(k);
  if (index < 0 || index >= this.mapping.vertices.length - 1)
   return null;
  var min = this.mapping.vertices[index];
  var max = this.mapping.vertices[index + 1];
  var divisor1 = (min.x - max.x) * dy - (min.y - max.y) * dx;
  if (divisor1 == 0)
   return null;
  var maxFactor = (min.x * dy - min.y * dx) / divisor1;
  var dist;
  var divisor2 = (min.x - max.x) * maxFactor - min.x;
  var divisor3 = (min.y - max.y) * maxFactor - min.y;
  if (dx != 0 && divisor2 != 0)
   dist = dx / divisor2;
  else if (dy != 0 && divisor3 != 0)
   dist = dy / divisor3;
  else
   return null;
  if (dist > this.mapping.radius)
   return null;
  valueInternal = dist / this.mapping.valueScaleFactor + this.mapping.minValue;
  argumentInternal = (max.argument - min.argument) * maxFactor + min.argument;
  return {argument:argumentInternal, value:valueInternal}
 },
 PointToDiagram: function(x, y) {
  var coordinates = new ASPxClientDiagramCoordinates();
  if(!_aspxIsExists(this.mapping)) 
   return coordinates;
  if (this.axisX == null || this.axisY == null)
   return coordinates;
  coordinates.axisX = this.axisX;
  coordinates.axisY = this.axisY;
  var dy = this.mapping.centerY - y;
  var dx = this.mapping.centerX - x;
  var distance = Math.sqrt(dy * dy + dx * dx);
  if (this.mapping.radius == 0 || distance > this.mapping.radius)
   return coordinates;
  var argumentInternal , valueInternal;
  if (distance == 0) {
   argumentInternal = this.mapping.minArgument;
   valueInternal = this.mapping.minValue;
  }
  else {
   var angleCos = dy / distance;
   if (angleCos > 1 || angleCos < -1)
    return coordinates;
   var angle = Math.acos(angleCos);
   if (x < this.mapping.centerX)
    angle = Math.PI * 2 - angle; 
   angle = this.CorrectAngle(angle);
   if (this.mapping.circle) {
    valueInternal = distance / this.mapping.valueScaleFactor + this.mapping.minValue;
    argumentInternal = angle / Math.PI / 2.0 * this.mapping.argumentDiapason + this.mapping.minArgument;
   }
   else {
    var values = this.CalcArgumentAndValueForPolygon(angle, dx, dy);
    if (values == null)
     return coordinates;
    argumentInternal = values.argument;
    valueInternal = values.value;
   }
  }
  if (this.axisX.scale instanceof ASPxClientQualitativeMap)
   if (argumentInternal > this.mapping.minArgument +this.mapping.argumentDiapason- this.mapping.argumentDelta / 2)
    argumentInternal -= this.mapping.argumentDiapason;
  coordinates.SetArgumentAndValue(this.axisX, this.axisY, argumentInternal, valueInternal);
  return coordinates;
 },
 DiagramToPoint: function(argument, value) {
  var coordinates = new ASPxClientControlCoordinates();
  if(!_aspxIsExists(this.mapping)) 
   return coordinates;
  var argumentInternal = this.axisX.GetInternalArgument(argument);
  var valueInternal = this.axisY.GetInternalArgument(value);
  var point = this.mapping.GetGetScreenPoint(argumentInternal, valueInternal);
  if (point == null)
   return coordinates;
  coordinates.visibility = valueInternal > this.mapping.maxValue ? ASPxClientControlCoordinatesVisibility.Hidden : ASPxClientControlCoordinatesVisibility.Visible;
  coordinates.SetPoint(point.x, point.y);
  return coordinates;
 }
});
ASPxClientRadarDiagramMapping = _aspxCreateClass(null, {
 constructor : function(interimMapping) {
  if (_aspxIsExists(interimMapping.r))
   this.radius = interimMapping.r;
  if (_aspxIsExists(interimMapping.cx))
   this.centerX = interimMapping.cx;
  if (_aspxIsExists(interimMapping.cy))
   this.centerY = interimMapping.cy;
  if (_aspxIsExists(interimMapping.ma))
   this.minArgument = interimMapping.ma;
  if (_aspxIsExists(interimMapping.mv))
   this.minValue = interimMapping.mv;
  if (_aspxIsExists(interimMapping.ra))
   this.revertAngle = interimMapping.ra;
  if (_aspxIsExists(interimMapping.a))
   this.diagramStartAngle = interimMapping.a;
  if (_aspxIsExists(interimMapping.f))
   this.valueScaleFactor = interimMapping.f;
  if (_aspxIsExists(interimMapping.d))
   this.argumentDiapason = interimMapping.d;
  if (_aspxIsExists(interimMapping.ad))
   this.argumentDelta = interimMapping.ad;
  if (_aspxIsExists(interimMapping.ci))
   this.circle = interimMapping.ci;
  if (_aspxIsExists(interimMapping.c))
   this.clipArgument = interimMapping.c;
  if (_aspxIsExists(interimMapping.mxa))
   this.maxArgument = interimMapping.mxa;
  if (_aspxIsExists(interimMapping.mxv))
   this.maxValue = interimMapping.mxv;
  if (_aspxIsExists(interimMapping.sa))
   this.startAngle = interimMapping.sa;
  this.vertices = this.CreateArray(interimMapping.v, function(interimVertex) {
   return new ASPxClientVertex(interimVertex);
  });
 },
 CreateArray: function(interimArray, createArrayItem) {
  if(!_aspxIsExists(interimArray))
   return [];
  if(!(interimArray instanceof Array))
   throw ASPxClientWebChartElement.objectModelError;     
  var result = new Array();
  for(var i = 0; i < interimArray.length; i++)
   result.push(createArrayItem(interimArray[i]));
  return result;   
  },
 GetGetScreenPoint: function(argument, value) {
  if (this.clipArgument && (argument < this.minArgument || argument > this.maxArgument))
   return null;
  while (argument < this.minArgument)
   argument += this.argumentDiapason;
  while (argument > this.maxArgument)
   argument -= this.argumentDiapason;
  if (value < this.minValue)
   value = this.minValue;
   var x, y;
  if (this.circle) {
   var distance = (value - this.minValue) * this.valueScaleFactor;
   var angle = (argument - this.minArgument) / this.argumentDiapason * Math.PI * 2.0;
   if (this.revertAngle)
    angle = -angle;
   angle += this.startAngle;
   x = Math.cos(angle) * distance + this.centerX;
   y = Math.sin(angle) * distance + this.centerY;
  }
  else {
   var distance = (value - this.minValue) * this.valueScaleFactor;
   var coord = (argument - this.minArgument) / this.argumentDelta;
   var index = Math.floor(coord);
   if (index < 0)
    index = 0;
   else if (index >= this.vertices.length - 1)
    index = this.vertices.length - 2;
   var min = this.vertices[index];
   var max = this.vertices[index + 1];
   var maxFactor = (argument - min.argument) / (max.argument - min.argument);
   var minFactor = 1.0 - maxFactor;
   x = (min.x * minFactor + max.x * maxFactor) * distance + this.centerX;
   y = (min.y * minFactor + max.y * maxFactor) * distance + this.centerY;
  }
  return {x:x, y:y};
 }
});
ASPxClientVertex = _aspxCreateClass(null, {
 constructor : function(interimVertex) {
  if (!_aspxIsExists(interimVertex.a))
   throw ASPxClientWebChartElement.objectModelError;
  this.argument = interimVertex.a;
  if (!_aspxIsExists(interimVertex.x))
   throw ASPxClientWebChartElement.objectModelError;
  this.x = interimVertex.x;
  if (!_aspxIsExists(interimVertex.y))
   throw ASPxClientWebChartElement.objectModelError;
  this.y = interimVertex.y;
 }
});
ASPxClientQualitativeMap = _aspxCreateClass(null, {
 constructor: function(interimMap) {
  if (!_aspxIsExists(interimMap.vl))
   throw ASPxClientWebChartElement.objectModelError;
  this.values = interimMap.vl;   
 },
 GetNativeValue: function(internalValue) {
  var roundedValue = Math.round(internalValue);
  return (roundedValue < 0 || roundedValue >= this.values.length) ? null : this.values[roundedValue];
 },
 GetInternalValue : function(value) {
  for(var i = 0; i < this.values.length; i++) {
   if (this.values[i] == value)
    return i;
  }
  return -1;
 }
});
ASPxClientNumericalMap = _aspxCreateClass(null, {
 constructor: function(interimMap) {
  if(!_aspxIsExists(interimMap.l))
   throw ASPxClientWebChartElement.objectModelError;
  this.logarithmic = interimMap.l;
  if(this.logarithmic) {
   if(!_aspxIsExists(interimMap.lb) || !_aspxIsExists(interimMap.mlv))
    throw ASPxClientWebChartElement.objectModelError;
   this.logarithmicBase = interimMap.lb;
   this.minLogValue = interimMap.mlv;
  } 
 },
 GetValueSign: function(value) {
  if(value < 0) 
   return -1;
  if(value > 0) 
   return 1;
  return 0;
 },
 TransformBackward: function(value) {
  return isFinite(value) ? Math.pow(this.logarithmicBase, Math.abs(value) + this.minLogValue) * this.GetValueSign(value) : value;
 },
 TransformForward: function(value) {
  if (!isFinite(value))
   return value;
  var transformedAbsValue = Math.log(Math.abs(value)) / Math.log(this.logarithmicBase) - this.minLogValue; 
  if (transformedAbsValue < 0)
   transformedAbsValue = 0;
  return this.GetValueSign(value) * transformedAbsValue;
 },
 GetNativeValue: function(internalValue) {
  return this.logarithmic ? this.TransformBackward(internalValue) : internalValue;
 },
 GetInternalValue : function(value) {
  return this.logarithmic ? this.TransformForward(value) : value;
 }
});
ASPxClientDateTimeMap = _aspxCreateClass(null, {
 constructor: function(interimMap) {
  if (!_aspxIsExists(interimMap.su) || !_aspxIsExists(interimMap.sa) || !_aspxIsExists(interimMap.sv))
   throw ASPxClientWebChartElement.objectModelError;
  this.measureUnit = interimMap.su;
  this.gridAlignment = interimMap.sa;
  this.startDate = interimMap.sv;
  if (_aspxIsExists(interimMap.swo))
   this.workdaysOnly = interimMap.swo;
  else
   this.workdaysOnly = false;
  if (this.workdaysOnly) {
   if (!_aspxIsExists(interimMap.sw))
    throw ASPxClientWebChartElement.objectModelError;
   this.workdays = interimMap.sw;
   this.holidaysCount = this.CalcHolidaysCountInWeek();
   this.workdaysCount = 7 - this.holidaysCount;
   if (_aspxIsExists(interimMap.sh))
    this.holidays = interimMap.sh;
   else
    this.holidays = [];
   if (_aspxIsExists(interimMap.sew))
    this.exactWorkdays = interimMap.sew;
   else
    this.exactWorkdays = [];
  }
 },
 CalcHolidaysCountInWeek: function() {
  var result = 0;
  var dayFlag = 1;
  for (var i = 0; i < 7; i++) {
   if ((this.workdays & dayFlag) == 0)
    result++;
   dayFlag <<= 1;
  }
  return result;
 },
 AddDays: function(dateTime, count) {
  return new Date(dateTime.getTime() + count * 1000 * 60 * 60 * 24);
 },
 GetTotalDays: function(fromDate, toDate) {
  return (toDate.getTime() - fromDate.getTime()) / 24 / 60 / 60 / 1000;
 },
 GetDate: function(n) {
  return new Date(this.startDate.getTime() + n);
 },
 GetMonth: function(n, date) {
  var fromDate = _aspxIsExists(date) ? date : this.startDate;
  var monthsCount = Math.abs(n);
  var years = Math.floor(monthsCount / 12);
  var monthsFractional = monthsCount - years * 12;
  var months = Math.floor(monthsFractional);
  var fraction = monthsFractional - months;
  if (n < 0) {
   years = -years;
   months = -months;
   fraction = -fraction;
  }
  var year = fromDate.getUTCFullYear() + years;
  var month = fromDate.getUTCMonth() + months;
  if (month < 0) {
   year = year - 1;
   month = month + 12;
  }
  else if (month >= 12) {
   year = year + 1;
   month = month - 12;
  }
  var result = new Date(Date.UTC(year, month, 1));
  if (fraction < 0) {
   var previousMonth;
   if (month == 0) 
    previousMonth = new Date(Date.UTC(year - 1, 11, 1));
   else 
    previousMonth = new Date(Date.UTC(year, month - 1, 1));
   return new Date(result.getTime() + (result.getTime() - previousMonth.getTime()) * fraction);
  }
  else {
   var nextMonth;
   if (month == 11) 
    nextMonth = new Date(Date.UTC(year + 1, 1, 1));
   else 
    nextMonth = new Date(Date.UTC(year, month + 1, 1));
   return new Date(result.getTime() + (nextMonth.getTime() - result.getTime()) * fraction);
  }
 },
 TruncateTime: function(date) {
  return new Date(Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate()));
 },
 IsHoliday: function(dateTime, applyHolidays, applyExactWorkdays) {
  if (!this.workdaysOnly)
   return false;
  var isHoliday = (this.workdays & (1 << dateTime.getUTCDay())) == 0;
  if (applyHolidays || applyExactWorkdays) {
   var time = new Date(Date.UTC(dateTime.getUTCFullYear(), dateTime.getUTCMonth(), dateTime.getUTCDate())).getTime();
   if (applyHolidays)
    for (holiday in this.holidays)
     if (time == this.holidays[holiday].getTime()) {
      isHoliday = true;
      break;
     }
   if (applyExactWorkdays)
    for (exactWorkDay in this.exactWorkdays) 
     if (time == this.exactWorkdays[exactWorkDay].getTime()) {
      isHoliday = false;
      break;
     }
  }
  return isHoliday;
 },
 SkipHoliday: function(dateTime) {
  var result = new Date(dateTime.getTime());
  if (this.workdays == 0)
   return result;
  while (this.IsHoliday(result, true, true))
   result = this.TruncateTime(this.AddDays(result, 1));
  return result;
 },
 Floor: function(dateTime) {
  return this.FloorToDateTimeMeasureUnit(dateTime, this.measureUnit);
 },
 FloorToDateTimeMeasureUnit: function(dateTime, dateTimeMeasureUnit) {
  var result = new Date(dateTime.getTime());
  switch (dateTimeMeasureUnit) {
   case 'Year':
    result.setUTCMonth(0, 1);
    result = this.TruncateTime(result);
    break;
   case 'Month':
    result.setUTCDate(1);
    result = this.TruncateTime(result);
    break;
   case 'Day':
    result = this.TruncateTime(result);
    break;
   case 'Hour':
    result.setUTCMinutes(0, 0, 0);
    break;
   case 'Minute':
    result.setUTCSeconds(0, 0);
    break;
   case 'Second':
    result.setUTCMilliseconds(0);
    break;
   case 'Quarter':
    result = this.GetMonth(-(result.getUTCMonth() % 3), result);
    result.setUTCDate(1);
    break;
   case 'Week': {
    var offset = result.getUTCDay() - this.startDate.getUTCDay();
    result = this.TruncateTime(this.AddDays(result, -(offset >= 0 ? offset : (offset + 7))));
    break;
   }
  }
  return result;
 },
 Round: function(dateTime) {
  if (this.measureUnit != 'Millisecond') {
   if (dateTime.getUTCMilliseconds() >= 500)
    dateTime.setUTCSeconds(dateTime.getUTCSeconds() + 1);
   dateTime.setUTCMilliseconds(0);
   if (this.measureUnit != 'Second') {
    if (dateTime.getUTCSeconds() >= 30)
     dateTime.setUTCMinutes(dateTime.getUTCMinutes() + 1);
    dateTime.setUTCSeconds(0);
    if (this.measureUnit != 'Minute') {
     if (dateTime.getUTCMinutes() >= 30)
      dateTime.setUTCHours(dateTime.getUTCHours() + 1);
     dateTime.setMinutes(0);
     if (this.measureUnit != 'Hour') {
      if (dateTime.getUTCHours() >= 12)
       dateTime.setUTCDate(dateTime.getUTCDate() + 1);
      dateTime.setUTCHours(0);
      if (this.measureUnit != 'Day') {
       if (this.measureUnit == 'Week') {
        var date = dateTime.getUTCDate() - dateTime.getUTCDay() + this.startDate.getUTCDay();
        if (dateTime.getUTCDay() >= this.startDate.getUTCDay())
         dateTime.setUTCDate(date);
        else
         dateTime.setUTCDate(date - 7);
       }
       else {
        var half;
        if (dateTime.getUTCMonth() == 2)
         half = 15;
        else
         half = 16;
        if (dateTime.getUTCDate() >= half)
         dateTime.setUTCMonth(dateTime.getUTCMonth() + 1);
        dateTime.setUTCDate(1);
        if (this.measureUnit != 'Month') {
         if (this.measureUnit == 'Quarter')
          dateTime.setUTCMonth(Math.floor(dateTime.getUTCMonth() / 3) * 3);
         else if (this.measureUnit == 'Year') {
          if (dateTime.getUTCMonth() >= 6)
           dateTime.setUTCFullYear(dateTime.getUTCFullYear() + 1);
          dateTime.setMonth(0);
         }
         else
          return initialDate;
        }           
       }
      }
     }
    }
   }
  }
  return dateTime;
 },
 AddUnits: function(range, factor) {
  range *= factor;
  var integerRange = Math.floor(range);
  var remain = range - integerRange;
  var result = this.GetMonth(integerRange, this.startDate);
  var daysInMonth = this.GetTotalDays(result, this.GetMonth(1, result));
  if (this.workdaysOnly) {
   var dayCount = 0;
   var currentDate = new Date(result.getTime());
   for (var i = 0; i < daysInMonth; i++) {
    if (!this.IsHoliday(currentDate, true, true))
     dayCount++;
    currentDate = this.AddDays(currentDate, 1);
   }
   remain *= dayCount;
   while (remain >= 0.5) {
    if (!this.IsHoliday(result, true, true))
     remain -= 1;
    result = this.AddDays(result, 1);
   }
   if (remain > 0)
    while (this.IsHoliday(result, true, true))
     result = this.AddDays(result, 1);
   return this.SkipHoliday(this.AddDays(result, remain));
  }
  else
   return this.AddDays(result, daysInMonth * remain);
 },
 CorrectRangeBasedOnHolidays: function(range, multiplier) {
  if (range == 0 || this.holidaysCount == 7)
   return range;
  var fromDate = this.TruncateTime(this.startDate);
  var actualDate = new Date(fromDate.getTime());
  var dayRange = Math.floor((range + (this.startDate.getTime() - actualDate.getTime()) / (1000 * 60 * 60 * 24) * multiplier) / multiplier);
  var remain = range - (dayRange * multiplier);
  if (dayRange > 0) {
   var fullWeeks = Math.floor(dayRange / this.workdaysCount);
   var remainWeekDays = dayRange % this.workdaysCount;
   for (; remainWeekDays > 0;) {
    if (this.IsHoliday(actualDate, false, false))
     dayRange++;
    else 
     remainWeekDays--;
    actualDate = this.AddDays(actualDate, 1);
   }
   dayRange += fullWeeks * this.holidaysCount;
   actualDate = this.AddDays(fromDate, dayRange);
   while (this.IsHoliday(actualDate, false, false)) {
    dayRange++;
    actualDate = this.AddDays(actualDate, 1);
   }
   for (holiday in this.holidays) {
    var holidayDate = this.holidays[holiday];
    if (holidayDate >= fromDate && holidayDate <= actualDate && !this.IsHoliday(holidayDate, false, false))
     do {
      dayRange++;
      actualDate = this.AddDays(actualDate, 1);
     } while (this.IsHoliday(actualDate, false, false));
   }
   for (workday in this.exactWorkdays) {
    var workDate = this.exactWorkdays[workday];
    if (workDate >= fromDate && workDate <= actualDate && this.IsHoliday(workDate, true, false))
     do {
      dayRange--;
      actualDate = this.AddDays(actualDate, -1);
     } while (this.IsHoliday(actualDate, true, true));
   }
   range = dayRange * multiplier + remain;
  }
  else {
   var fullWeeks = Math.ceil(dayRange / this.workdaysCount);
   var remainWeekDays = dayRange % this.workdaysCount;
   for (; remainWeekDays < 0;) {
    if (this.IsHoliday(actualDate, false, false))
     dayRange--;
    else
     remainWeekDays++;
    actualDate = this.AddDays(actualDate, -1);
   }
   dayRange += fullWeeks * this.holidaysCount;
   actualDate = this.AddDays(fromDate, dayRange);
   while (this.IsHoliday(actualDate, false, false)) {
    dayRange--;
    actualDate = this.AddDays(actualDate, -1);
   }
   var revertedHolidays = new Array();
   for (holiday in this.holidays)
    revertedHolidays.unshift(this.holidays[holiday]);
   for (holiday in revertedHolidays) {
    var holidayDate = revertedHolidays[holiday];
    if (holidayDate >= actualDate && holidayDate <= fromDate && !this.IsHoliday(holidayDate, false, false))
     do {
      dayRange--;
      actualDate = this.AddDays(actualDate, -1);
     } while (this.IsHoliday(actualDate, false, false));
   }
   for (workday in this.exactWorkdays) {
    var workDate = this.exactWorkdays[workday];
    if (workDate >= actualDate && workDate <= fromDate && this.IsHoliday(workDate, true, false))
     do {
      dayRange++;
      actualDate = this.AddDays(actualDate, 1);
     } while (this.IsHoliday(actualDate, true, true));
   }
   range = dayRange * multiplier + remain;
  }
  return range;
 },
 GetNativeValue: function(internalValue) {
  var nativeValue;
  switch (this.gridAlignment) {
   case 'Year':
    nativeValue = this.AddUnits(internalValue, 12);
    break;
   case 'Quarter':
    nativeValue = this.AddUnits(internalValue, 3);
    break;
   case 'Month':
    nativeValue = this.AddUnits(internalValue, 1);
    break;
   case 'Week':
    if (this.workdaysOnly) {
     var fullWeeks = Math.floor(internalValue);
     var remain = internalValue - fullWeeks;
     nativeValue = this.AddDays(this.startDate, fullWeeks * 7);
     var weekDaysCount = 0;
     for (var i = 0; i < 7; i++)
      if (!this.IsHoliday(this.AddDays(nativeValue, i), true, true))
       weekDaysCount++;
     remain *= weekDaysCount;
     while (remain >= 0.5) {
      if (!this.IsHoliday(nativeValue, true, true))
       remain -= 1;
      nativeValue = this.AddDays(nativeValue, 1);
     }
     nativeValue = this.SkipHoliday(this.AddDays(nativeValue, remain));
    }
    else
     nativeValue = this.GetDate(internalValue * 1000 * 60 * 60 * 24 * 7);
    break;
   case 'Day':
    if (this.workdaysOnly)
     internalValue = this.CorrectRangeBasedOnHolidays(internalValue, 1)
    nativeValue = this.AddDays(this.startDate, internalValue);
    break;
   case 'Hour':
    if (this.workdaysOnly)
     internalValue = this.CorrectRangeBasedOnHolidays(internalValue, 24)
    nativeValue = this.GetDate(internalValue * 1000 * 60 * 60);
    break;
   case 'Minute':
    if (this.workdaysOnly)
     internalValue = this.CorrectRangeBasedOnHolidays(internalValue, 24 * 60)
    nativeValue = this.GetDate(internalValue * 1000 * 60);
    break;
   case 'Second':
    if (this.workdaysOnly)
     internalValue = this.CorrectRangeBasedOnHolidays(internalValue, 24 * 60 * 60)
    nativeValue = this.GetDate(internalValue * 1000);
    break;
   case 'Millisecond':
    if (this.workdaysOnly)
     internalValue = this.CorrectRangeBasedOnHolidays(internalValue, 24 * 60 * 60 * 1000)
    nativeValue = this.GetDate(internalValue);
    break;
   default:
    nativeValue = this.GetDate(0);
    break;
  }
  return this.Round(nativeValue);
 },
 TotalUnits: function(dateTime, majorUnit) {
  var monthRounded = this.FloorToDateTimeMeasureUnit(dateTime, 'Month');
  var dayRounded = this.FloorToDateTimeMeasureUnit(dateTime, 'Day');
  var daysInMonth = this.GetTotalDays(monthRounded, this.GetMonth(1, monthRounded));
  var monthAddition;
  if (this.workdaysOnly) {
   var dayCount = 0;
   var actualDaysInMonth = 0;
   var currentDate = new Date(monthRounded.getTime());
   for (var i = 0; i < daysInMonth; i++) {
    if (!this.IsHoliday(currentDate, true, true)) {
     actualDaysInMonth++;
     if (currentDate < dayRounded)
      dayCount++;
    }
    currentDate = this.AddDays(currentDate, 1);
   }
   monthAddition = actualDaysInMonth == 0 ? 0 : (dayCount / actualDaysInMonth);
   daysInMonth = actualDaysInMonth;
  }
  else
   monthAddition = this.GetTotalDays(monthRounded, dayRounded) / daysInMonth;
  var divider = daysInMonth * 24 * 60 * 60 * 1000;
  return (monthRounded.getUTCFullYear() * 12 + monthRounded.getUTCMonth() - 1 + monthAddition + 
    (dateTime.getTime() - dayRounded.getTime()) / divider) / majorUnit;
 },
 CorrectDifferenceBasedOnHolidays: function(value, multiplier) {
  if (this.holidaysCount == 7)
   return value;
  var actualDate = this.TruncateTime(this.startDate);
  var totalDays = Math.floor((value + this.GetTotalDays(actualDate, this.startDate) * multiplier) / multiplier);
  if (totalDays > 0) {
   var fullWeeks = Math.floor(totalDays / 7);
   value -= fullWeeks * this.holidaysCount * multiplier;
   var remainWeekDays = totalDays % 7;
   for (var i = 0; i < remainWeekDays; i++) {
    if (this.IsHoliday(actualDate, false, false))
     value -= multiplier;
    actualDate = this.AddDays(actualDate, 1);
   }
  }
  else if (totalDays < 0) {
   var fullWeeks = Math.ceil(totalDays / 7);
   value -= fullWeeks * this.holidaysCount * multiplier;
   var remainWeekDays = totalDays % 7;
   for (var i = 0; i > remainWeekDays; i--) {
    if (this.IsHoliday(actualDate, false, false))
     value += multiplier;
    actualDate = this.AddDays(actualDate, -1);
   }
  }
  actualDate = this.TruncateTime(this.startDate);
  var finishDate = this.AddDays(actualDate, totalDays);
  if (finishDate < actualDate) {
   for (holiday in this.holidays) {
    var holidayDate = this.holidays[holiday];
    if (holidayDate <= actualDate && holidayDate > finishDate && !this.IsHoliday(holidayDate, false, false))
     value += multiplier;
   }
   for (exactWorkdate in this.exactWorkdays) {
    var workDate = this.exactWorkdays[exactWorkdate];
    if (workDate <= actualDate && workDate > finishDate && this.IsHoliday(workDate, true, false))
     value -= multiplier;
   }
  }
  else {
   for (holiday in this.holidays) {
    var holidayDate = this.holidays[holiday];
    if (holidayDate >= actualDate && holidayDate < finishDate && !this.IsHoliday(holidayDate, false, false))
     value -= multiplier;
   }
   for (exactWorkdate in this.exactWorkdays) {
    var workDate = this.exactWorkdays[exactWorkdate];
    if (workDate >= actualDate && workDate < finishDate && this.IsHoliday(workDate, true, false))
     value += multiplier;
   }
  }
  return value;
 },
 GetInternalValue: function(value) {
  if (this.workdaysOnly)
   value = this.SkipHoliday(value);
  var roundedToDate = this.Floor(value);
  switch (this.gridAlignment) {
   case 'Year':
    return this.TotalUnits(roundedToDate, 12) - this.TotalUnits(this.startDate, 12);
   case 'Quarter':
    return this.TotalUnits(roundedToDate, 3) - this.TotalUnits(this.startDate, 3);
   case 'Month':
    return this.TotalUnits(roundedToDate, 1) - this.TotalUnits(this.startDate, 1);
   case 'Week': {
    if (!this.workdaysOnly)
     return (roundedToDate.getTime() - this.startDate.getTime()) / 7 / 24 / 60 / 60 / 1000;
    var roundedToWeek = this.FloorToDateTimeMeasureUnit(value, 'Week');
    var roundedToDay = this.FloorToDateTimeMeasureUnit(value, 'Day');
    var weekDaysCount = 0;
    var spentDaysCount = 0;
    var tempDate = roundedToWeek;
    for (var i = 0; i < 7; i++) {
     if (!this.IsHoliday(tempDate, true, true)) {
      weekDaysCount++;
      if (tempDate < roundedToDay)
       spentDaysCount++;
     }
     tempDate = this.AddDays(tempDate, 1);
    }
    return this.GetTotalDays(this.startDate, roundedToWeek) / 7 + 
        (spentDaysCount + this.GetTotalDays(roundedToDay, value)) / weekDaysCount;
   }
   case 'Day': {
    var totalDays = this.GetTotalDays(this.startDate, roundedToDate);
    if (this.workdaysOnly)
     totalDays = this.CorrectDifferenceBasedOnHolidays(totalDays, 1);
    return totalDays;
   }
   case 'Hour': {
    var totalHours = (roundedToDate.getTime() - this.startDate.getTime()) / 60 / 60 / 1000;
    if (this.workdaysOnly)
     totalHours = this.CorrectDifferenceBasedOnHolidays(totalHours, 24);
    return totalHours;
   }
   case 'Minute': {
    var totalMinutes = (roundedToDate.getTime() - this.startDate.getTime()) / 60 / 1000;
    if (this.workdaysOnly)
     totalMinutes = this.CorrectDifferenceBasedOnHolidays(totalMinutes, 24 * 60);
    return totalMinutes;
   }
   case 'Second': {
    var totalSeconds = (roundedToDate.getTime() - this.startDate.getTime()) / 1000;
    if (this.workdaysOnly)
     totalSeconds = this.CorrectDifferenceBasedOnHolidays(totalSeconds, 24 * 60 * 60);
    return totalSeconds;
   }
   case 'Millisecond': {
    var totalMilliseconds = roundedToDate.getTime() - this.startDate.getTime();
    if (this.workdaysOnly)
     totalMilliseconds = this.CorrectDifferenceBasedOnHolidays(totalMilliseconds, 24 * 60 * 60 * 1000);
    return totalMilliseconds;
   }
   default:
    return 0;
  }
 }
});
ASPxClientAxisBase = _aspxCreateClass(ASPxClientWebChartElementNamed, {
 constructor: function(chart, diagram, interimAxis) {
  this.constructor.prototype.constructor.call(this, chart, interimAxis);
  this.diagram = diagram;
 },
 InitializeProperties: function(interimObject) {
  ASPxClientWebChartElementNamed.prototype.InitializeProperties.call(this, interimObject);
  if (!_aspxIsExists(interimObject.r))
   throw ASPxClientWebChartElement.objectModelError;
  this.range = new ASPxClientAxisRange(this.chart, this, interimObject.r);
  if (_aspxIsExists(interimObject.m))
   this.scale = this.CreateMap(interimObject.m);
  if (_aspxIsExists(interimObject.l))
   this.labelItems = this.CreateLabelItems(interimObject.l);
 },
 CreateMap: function(interimMap) {
  if (interimMap.t == "N")
   return new ASPxClientNumericalMap(interimMap);
  if (interimMap.t == "Q")
   return new ASPxClientQualitativeMap(interimMap);
  if (interimMap.t == "D")
   return new ASPxClientDateTimeMap(interimMap);
  throw ASPxClientWebChartElement.objectModelError;
 },
 CreateLabelItems: function(interimLabelItems) {
   return this.CreateArray(interimLabelItems, createLabelItem = function(chart, axis, interimLabelItem) {
   return new ASPxClientAxisLabelItem(chart, axis, interimLabelItem);
  });
 },
 GetNativeArgument: function(value) {
  return (this.scale == null) ? value : this.scale.GetNativeValue(value);
 },
 GetInternalArgument: function(value) {
  return (this.scale == null) ? value : this.scale.GetInternalValue(value);
 }
});
ASPxClientAxis2D = _aspxCreateClass(ASPxClientAxisBase, {
 constructor: function(chart, diagram, interimAxis) {
  this.constructor.prototype.constructor.call(this, chart, diagram, interimAxis);
 },
 InitializeProperties: function(interimObject) {
  ASPxClientAxisBase.prototype.InitializeProperties.call(this, interimObject);
  if(!_aspxIsExists(interimObject.t))
   throw ASPxClientWebChartElement.objectModelError;
  this.axisTitle = new ASPxClientAxisTitle(this.chart, this, interimObject.t);
  this.strips = this.CreateStrips(interimObject.s);  
  this.constantLines = this.CreateConstantLines(interimObject.cl);  
  this.intervals = this.CreateIntervals(interimObject.i);
  if(_aspxIsExists(interimObject.ibc))
   this.intervalBoundsCaches = new ASPxClientIntervalBoundsCache(interimObject.ibc);
  this.axisID = interimObject.id;
  if (_aspxIsExists(interimObject.aclv))
   this.actualCrosshairLabelVisibility = interimObject.aclv;
  if (_aspxIsExists(interimObject.clp))
   this.crosshairLabelPattern = interimObject.clp;
 },
 CreateStrips: function(interimStrips) {
  return this.CreateArray(interimStrips, createStrip = function(chart, axis, interimStrip) {
   return new ASPxClientStrip(chart, axis, interimStrip);
  });
 },
 CreateConstantLines: function(interimConstantLines) {
  return this.CreateArray(interimConstantLines, function(chart, axis, interimConstantLine) {
   return new ASPxClientConstantLine(chart, axis, interimConstantLine);
  });
 },
 CreateIntervals: function(interimIntervals) {
  return this.CreateArray(interimIntervals, function(chart, axis, interimInterval) {
   return new ASPxClientAxisInterval(interimInterval);
  });
 }
});
ASPxClientAxis = _aspxCreateClass(ASPxClientAxis2D, {
 constructor: function(chart, diagram, interimAxis) {
  this.constructor.prototype.constructor.call(this, chart, diagram, interimAxis);
 },
 InitializeProperties: function(interimObject) {
  ASPxClientAxis2D.prototype.InitializeProperties.call(this, interimObject);  
  if (!_aspxIsExists(interimObject.ar))
   throw ASPxClientWebChartElement.objectModelError;   
  this.reverse = interimObject.ar;
 }
});
ASPxClientSwiftPlotDiagramAxis = _aspxCreateClass(ASPxClientAxis2D, {
 constructor: function(chart, diagram, interimAxis) {
  this.constructor.prototype.constructor.call(this, chart, diagram, interimAxis);
 },
 InitializeProperties: function(interimObject) {
  ASPxClientAxis2D.prototype.InitializeProperties.call(this, interimObject);
 }
});
ASPxClientAxis3D = _aspxCreateClass(ASPxClientAxisBase, {
 constructor: function(chart, diagram, interimAxis) {
  this.constructor.prototype.constructor.call(this, chart, diagram, interimAxis);
 }
});
ASPxClientRadarAxis = _aspxCreateClass(ASPxClientAxisBase, {
 constructor: function(chart, diagram, interimAxis) {
  this.constructor.prototype.constructor.call(this, chart, diagram, interimAxis);
 }
});
ASPxClientAxisTitle = _aspxCreateClass(ASPxClientWebChartRequiredElement, {
 constructor: function(chart, axis, interimAxisTitle) {
  this.constructor.prototype.constructor.call(this, chart, interimAxisTitle);
  this.axis = axis;    
 },
 InitializeProperties: function(interimObject) {  
  if (!_aspxIsExists(interimObject.tx))
   throw ASPxClientWebChartElement.objectModelError;
  this.text = interimObject.tx;
 }
});
ASPxClientAxisLabelItem = _aspxCreateClass(ASPxClientWebChartRequiredElement, {
 constructor: function(chart, axis, interimLabelItem) {
  this.constructor.prototype.constructor.call(this, chart, interimLabelItem);
  this.axis = axis;    
 },
 InitializeProperties: function(interimObject) {  
  if (!_aspxIsExists(interimObject.tx) || !_aspxIsExists(interimObject.av) || !_aspxIsExists(interimObject.iv))
   throw ASPxClientWebChartElement.objectModelError;
  this.text = interimObject.tx;
  this.axisValue = interimObject.av;
  this.axisValueInternal = interimObject.iv;
 }
});
ASPxClientAxisRange = _aspxCreateClass(ASPxClientWebChartRequiredElement, {
 constructor: function(chart, axis, interimRange) {
  this.constructor.prototype.constructor.call(this, chart, interimRange);
  this.axis = axis;    
 },
 InitializeProperties: function(interimObject) {  
  if (!_aspxIsExists(interimObject.ii) || !_aspxIsExists(interimObject.ia))
   throw ASPxClientWebChartElement.objectModelError;
  this.minValue = interimObject.mi;
  this.maxValue = interimObject.ma;
  this.minValueInternal = interimObject.ii;
  this.maxValueInternal = interimObject.ia;
 }
});
ASPxClientAxisInterval = _aspxCreateClass(null, {
 constructor: function(interimInterval) {
  this.minLimit = interimInterval.mi;
  this.maxLimit = interimInterval.ma;
 },
 GetInternalValue: function(ratio) {
  return this.minLimit + (this.maxLimit - this.minLimit) * ratio;
 }
});
ASPxClientIntervalBoundsCache = _aspxCreateClass(null, {
 constructor: function(interimCache) {
  this.items = this.CreateItems(interimCache.i);
 },
 CreateItems: function(interimItems) {
  var result = new Array();
  for(var i = 0; i < interimItems.length; i++)
   result.push(new ASPxClientIntervalBoundsCacheItem(interimItems[i]));
  return result;   
 },
 GetIntervalBoundsCacheItemByPaneID: function(paneID) {
  for(var i = 0; i < this.items.length; i++)
   if(this.items[i].paneID == paneID)
    return this.items[i];
  return null;
 }
});
ASPxClientIntervalBoundsCacheItem = _aspxCreateClass(null, {
 constructor: function(interimCacheItem) {
  this.paneID = interimCacheItem.pid;
  this.intervalBoundsArray = this.CreateIntervalBoundsArray(interimCacheItem.ibl);
 },
 CreateIntervalBoundsArray: function(interimIntervalBoundsArray) {
  var result = new Array();
  for(var i = 0; i < interimIntervalBoundsArray.length; i++)
   result.push(new ASPxClientIntervalBounds(interimIntervalBoundsArray[i]));
  return result;   
 },
 GetIntervalBoundsIndexByLocation: function(location) {
  for(var i = 0; i < this.intervalBoundsArray.length; i++)
   if(location >= this.intervalBoundsArray[i].position && location <= this.intervalBoundsArray[i].highBound)
    return i;
  return -1;
 }
});
ASPxClientIntervalBounds = _aspxCreateClass(null, {
 constructor: function(interimBounds) {
  this.position = interimBounds.p;
  this.length = interimBounds.l;
  this.highBound = this.position + this.length;
 }
});
ASPxClientStrip = _aspxCreateClass(ASPxClientWebChartElementNamed, {
 constructor: function(chart, axis, interimStrip) {
  this.constructor.prototype.constructor.call(this, chart, interimStrip);
  this.axis = axis;
 },
 InitializeProperties: function(interimObject) {
  ASPxClientWebChartElementNamed.prototype.InitializeProperties.call(this, interimObject);
  if(_aspxIsExists(interimObject.mi))
   this.minValue = interimObject.mi;
  if(_aspxIsExists(interimObject.ma))   
   this.maxValue = interimObject.ma;   
 }
});
ASPxClientConstantLine = _aspxCreateClass(ASPxClientWebChartElementNamed, {
 constructor: function(chart, axis, interimConstantLine) {
  this.constructor.prototype.constructor.call(this, chart, interimConstantLine);
  this.axis = axis;
 },
 InitializeProperties: function(interimObject) {
  ASPxClientWebChartElementNamed.prototype.InitializeProperties.call(this, interimObject);
  if(!_aspxIsExists(interimObject.v))
   throw ASPxClientWebChartElement.objectModelError;
  this.value = interimObject.v;
  this.title = _aspxIsExists(interimObject.ti) ? interimObject.ti : "";
 }
});
ASPxClientSeries = _aspxCreateClass(ASPxClientWebChartElementNamed, {
 constructor: function(chart, interimSeries) {
  this.constructor.prototype.constructor.call(this, chart, interimSeries);
 },
 InitializeProperties: function(interimObject) {
  ASPxClientWebChartElementNamed.prototype.InitializeProperties.call(this, interimObject);
  this.viewType = _aspxIsExists(interimObject.v) ? interimObject.v : "Bar";
  this.argumentScaleType = _aspxIsExists(interimObject.as) ? interimObject.as : "Qualitative";
  this.valueScaleType = _aspxIsExists(interimObject.vs) ? interimObject.vs : "Numerical";
  if (_aspxIsExists(interimObject.ax))
   this.axisX = interimObject.ax;
  if (_aspxIsExists(interimObject.ay))
   this.axisY = interimObject.ay;
  if (_aspxIsExists(interimObject.pa))
   this.pane = interimObject.pa;
  this.visible = !_aspxIsExists(interimObject.nvi);
  this.toolTipEnabled = _aspxIsExists(interimObject.tte);
  this.toolTipText = interimObject.st;
  this.toolTipImage = interimObject.tti;
  this.label = new ASPxClientSeriesLabel(this.chart, this, interimObject.l);
  this.points = this.CreatePoints(interimObject.p);
  if (_aspxIsExists(interimObject.ti))
   this.titles = this.CreateTitles(interimObject.ti);
  if (_aspxIsExists(interimObject.id))
   this.indicators = this.CreateIndicators(interimObject.id);
  this.regressionLines = this.indicators;
  this.trendLines = this.indicators;
  this.fibonacciIndicators = this.indicators;
  if (_aspxIsExists(interimObject.scc)) {
   this.color = interimObject.scc;
  }
  if (_aspxIsExists(interimObject.sg))
   this.stackedGroup = interimObject.sg;
  if (_aspxIsExists(interimObject.clp)) {
   this.crosshairLabelPattern = interimObject.clp;
  }
  this.crosshairValueItems = this.CreateCrosshairValueItemsArray(interimObject.cvi);
  if (_aspxIsExists(interimObject.ace)) {
   this.actualCrosshairEnabled = interimObject.ace;
  }
  if (_aspxIsExists(interimObject.aclv)) {
   this.actualCrosshairLabelVisibility = interimObject.aclv;
  }
 },
 CreatePoints: function(interimPoints) {
  return this.CreateArray(interimPoints, createPoint = function(chart, series, interimPoint) {
   return new ASPxClientSeriesPoint(chart, series, interimPoint);
  });
 },
 CreateCrosshairValueItemsArray: function(interimValueItems) {
  return this.CreateArray(interimValueItems, createValueItem = function(chart, series, interimValueItem) {
   return new ASPxClientCrosshairValueItem(interimValueItem);
  });
 },
 CreateTitles: function(interimTitles) {
  return this.CreateArray(interimTitles, createTitle = function(chart, series, interimTitle) {
   return new ASPxClientSeriesTitle(chart, series, interimTitle);
  });
 },
 CreateIndicators: function(interimIndicators) {
  return this.CreateArray(interimIndicators, createIndicator = function(chart, series, interimIndicator) {
   if (interimIndicator.t == "RL")
    return new ASPxClientRegressionLine(chart, series, interimIndicator);
   if (interimIndicator.t == "TL")
    return new ASPxClientTrendLine(chart, series, interimIndicator);
   if (interimIndicator.t == "FI")
    return new ASPxClientFibonacciIndicator(chart, series, interimIndicator);
   if (interimIndicator.t == "SMA")
    return new ASPxClientSimpleMovingAverage(chart, series, interimIndicator);
   if (interimIndicator.t == "EMA")
    return new ASPxClientExponentialMovingAverage(chart, series, interimIndicator);
   if (interimIndicator.t == "WMA")
    return new ASPxClientWeightedMovingAverage(chart, series, interimIndicator);
   if (interimIndicator.t == "TMA")
    return new ASPxClientTriangularMovingAverage(chart, series, interimIndicator);
   throw ASPxClientWebChartElement.objectModelError;
  });
 }
});
ASPxClientSeriesLabel = _aspxCreateClass(ASPxClientWebChartElement, {
 constructor: function(chart, series, interimSeriesLabel) {
  this.constructor.prototype.constructor.call(this, chart, interimSeriesLabel);  
  this.series = series;
 },
 InitializeProperties: function(interimObject) {
 },
 InitializeDefault: function() {
  this.text = "";
 }
});
ASPxClientSeriesPoint = _aspxCreateClass(ASPxClientWebChartRequiredElement, {
 constructor: function(chart, series, interimSeriesPoint) {
  this.constructor.prototype.constructor.call(this, chart, interimSeriesPoint);
  this.series = series;
 },
 InitializeProperties: function(interimObject) {
  if (!_aspxIsExists(interimObject.x) || !_aspxIsExists(interimObject.y) || !(interimObject.y instanceof Array))
   throw ASPxClientWebChartElement.objectModelError;
  this.argument = interimObject.x;
  this.values = interimObject.y;
  this.toolTipText = interimObject.pt;
  if (_aspxIsExists(interimObject.pcc)) {
   this.color = interimObject.pcc;
  }
  if (_aspxIsExists(interimObject.pv)) {
   this.percentValue = interimObject.pv;
  }
  if (_aspxIsExists(interimObject.h)) {
   this.toolTipHint = interimObject.h;
  }
  if (_aspxIsExists(interimObject.chv)) {
   this.crosshairValues = interimObject.chv;
  }
  if (_aspxIsExists(interimObject.o)) {
   this.offset = interimObject.o;
  }
  if (_aspxIsExists(interimObject.fo)) {
   this.fixedOffset = interimObject.fo;
  }
 }
});
ASPxClientLegend = _aspxCreateClass(ASPxClientWebChartEmptyElement, {
 constructor: function(chart, interimLegend) {
  this.constructor.prototype.constructor.call(this, chart, interimLegend);  
 }
});
ASPxClientTitleBase = _aspxCreateClass(ASPxClientWebChartRequiredElement, {
 constructor: function(chart, interimTitle) {
  this.constructor.prototype.constructor.call(this, chart, interimTitle);
 },
 InitializeProperties: function(interimObject) {
  if(!_aspxIsExists(interimObject.l) || !(interimObject.l instanceof Array))
   throw ASPxClientWebChartElement.objectModelError;
  this.lines = interimObject.l;
  this.alignment = interimObject.a;
  this.dock = interimObject.d;
 }
});
ASPxClientChartTitle = _aspxCreateClass(ASPxClientTitleBase, {
 constructor: function(chart, interimChartTitle) {
  this.constructor.prototype.constructor.call(this, chart, interimChartTitle);
 }
});
ASPxClientSeriesTitle = _aspxCreateClass(ASPxClientTitleBase, {
 constructor: function(chart, series, interimSeriesTitle) {
  this.constructor.prototype.constructor.call(this, chart, interimSeriesTitle);
  this.series = series;
 }
});
ASPxClientIndicator = _aspxCreateClass(ASPxClientWebChartElementNamed, {
 constructor: function(chart, series, interimIndicator) {
  this.constructor.prototype.constructor.call(this, chart, interimIndicator);
  this.series = series;
 },
 InitializeProperties: function(interimObject) {  
  ASPxClientWebChartElementNamed.prototype.InitializeProperties.call(this, interimObject);
 }
});
ASPxClientFinancialIndicator = _aspxCreateClass(ASPxClientIndicator, {
 constructor: function(chart, series, interimFinancialIndicator) {
  this.constructor.prototype.constructor.call(this, chart, series, interimFinancialIndicator);
 },
 InitializeProperties: function(interimObject) {
  ASPxClientIndicator.prototype.InitializeProperties.call(this, interimObject);
  if (!_aspxIsExists(interimObject.p1) || !_aspxIsExists(interimObject.p2))
   throw ASPxClientWebChartElement.objectModelError;  
  this.point1 = new ASPxClientFinancialIndicatorPoint(this.chart, this, interimObject.p1);
  this.point2 = new ASPxClientFinancialIndicatorPoint(this.chart, this, interimObject.p2);
 }
});
ASPxClientTrendLine = _aspxCreateClass(ASPxClientFinancialIndicator, {
 constructor: function(chart, series, interimTrendLine) {
  this.constructor.prototype.constructor.call(this, chart, series, interimTrendLine);
 }
});
ASPxClientFibonacciIndicator = _aspxCreateClass(ASPxClientFinancialIndicator, {
 constructor: function(chart, series, interimFibonacciIndicator) {
  this.constructor.prototype.constructor.call(this, chart, series, interimFibonacciIndicator);
 }
});
ASPxClientFinancialIndicatorPoint = _aspxCreateClass(ASPxClientWebChartRequiredElement, {
 constructor: function(chart, financialIndicator, interimFinancialIndicatorPoint) {
  this.constructor.prototype.constructor.call(this, chart, interimFinancialIndicatorPoint);
  this.financialIndicator = financialIndicator;
 },
 InitializeProperties: function(interimObject) {
  if(!_aspxIsExists(interimObject.a) || !_aspxIsExists(interimObject.vl))
   throw ASPxClientWebChartElement.objectModelError;
  this.argument = interimObject.a;
  this.valueLevel = interimObject.vl;
 }
});
ASPxClientSingleLevelIndicator = _aspxCreateClass(ASPxClientIndicator, {
 constructor: function(chart, series, interimIndicator) {
  this.constructor.prototype.constructor.call(this, chart, series, interimIndicator);
 },
 InitializeProperties: function(interimObject) {  
  ASPxClientIndicator.prototype.InitializeProperties.call(this, interimObject);
  if (!_aspxIsExists(interimObject.vl))
   throw ASPxClientWebChartElement.objectModelError;  
  this.valueLevel = interimObject.vl;
 }
});
ASPxClientRegressionLine = _aspxCreateClass(ASPxClientSingleLevelIndicator, {
 constructor: function(chart, series, interimRegressionLine) {
  this.constructor.prototype.constructor.call(this, chart, series, interimRegressionLine);
 }
});
ASPxClientMovingAverage = _aspxCreateClass(ASPxClientSingleLevelIndicator, {
 constructor: function(chart, series, interimMovingAverage) {
  this.constructor.prototype.constructor.call(this, chart, series, interimMovingAverage);
 },
 InitializeProperties: function(interimObject) {
  ASPxClientSingleLevelIndicator.prototype.InitializeProperties.call(this, interimObject);
  if (!_aspxIsExists(interimObject.pc) || !_aspxIsExists(interimObject.ki))
   throw ASPxClientWebChartElement.objectModelError;  
  this.pointsCount = interimObject.pc;
  this.kind = interimObject.ki;
  if (this.kind == "Envelope" || this.kind == "MovingAverageAndEnvelope") {
   if (!_aspxIsExists(interimObject.ep))
    throw ASPxClientWebChartElement.objectModelError;  
   this.envelopePercent = interimObject.ep;
  }
 }
});
ASPxClientSimpleMovingAverage = _aspxCreateClass(ASPxClientMovingAverage, {
 constructor: function(chart, series, interimMovingAverage) {
  this.constructor.prototype.constructor.call(this, chart, series, interimMovingAverage);
 }
});
ASPxClientExponentialMovingAverage = _aspxCreateClass(ASPxClientMovingAverage, {
 constructor: function(chart, series, interimMovingAverage) {
  this.constructor.prototype.constructor.call(this, chart, series, interimMovingAverage);
 }
});
ASPxClientWeightedMovingAverage = _aspxCreateClass(ASPxClientMovingAverage, {
 constructor: function(chart, series, interimMovingAverage) {
  this.constructor.prototype.constructor.call(this, chart, series, interimMovingAverage);
 }
});
ASPxClientTriangularMovingAverage = _aspxCreateClass(ASPxClientMovingAverage, {
 constructor: function(chart, series, interimMovingAverage) {
  this.constructor.prototype.constructor.call(this, chart, series, interimMovingAverage);
 }
});
ASPxClientAnnotation = _aspxCreateClass(ASPxClientWebChartElementNamed, {
 constructor: function(chart, interimAnnotation) {
  this.constructor.prototype.constructor.call(this, chart, interimAnnotation);
 },
 InitializeProperties: function(interimObject) {
  ASPxClientWebChartElementNamed.prototype.InitializeProperties.call(this, interimObject);
 }
});
ASPxClientTextAnnotation = _aspxCreateClass(ASPxClientAnnotation, {
 constructor: function(chart, interimTextAnnotation) {
  this.constructor.prototype.constructor.call(this, chart, interimTextAnnotation); 
 },
 InitializeProperties: function(interimObject) {
  ASPxClientAnnotation.prototype.InitializeProperties.call(this, interimObject);
  if(!_aspxIsExists(interimObject.l) || !(interimObject.l instanceof Array))
   throw ASPxClientWebChartElement.objectModelError;
  this.lines = interimObject.l;
 }
});
ASPxClientImageAnnotation = _aspxCreateClass(ASPxClientAnnotation, {
 constructor: function(chart, interimImageAnnotation) {
  this.constructor.prototype.constructor.call(this, chart, interimImageAnnotation); 
 },
 InitializeProperties: function(interimObject) {
  ASPxClientAnnotation.prototype.InitializeProperties.call(this, interimObject);
 }
});
ASPxClientCrosshairValueItem = _aspxCreateClass(null, {
 constructor: function(interimObject) {
  this.value = interimObject.v;
  this.pointIndex = interimObject.pi;
 }
});
ASPxClientToolTipController = _aspxCreateClass(ASPxClientWebChartEmptyElement, {
 constructor: function(chart, interimToolTipController) {
  this.constructor.prototype.constructor.call(this, chart, interimToolTipController);
  this.showImage = interimToolTipController.si;
  this.showText = interimToolTipController.st;
  this.imagePosition = interimToolTipController.ip;
  this.openMode = interimToolTipController.om;
  this.toolTipObject = null;
  this.toolTip = null;
 },
 Show: function(x, y, hitInfo, htmlElementX, htmlElementY) {
  var newObject = null;
  if (hitInfo.seriesPoint != null && this.chart.showPointToolTip) {
   newObject = hitInfo.seriesPoint;
  }
  else {
   if (hitInfo.series != null && this.chart.showSeriesToolTip) {
    newObject = hitInfo.series;
   }
  }
  if (this.toolTipObject != newObject) {
   this.toolTipObject = newObject;
   if (this.toolTipObject == null) {
    this.Hide();
    return;
   }
   var series = _aspxIsExists(hitInfo.series) ? hitInfo.series : hitInfo.seriesPoint.series;
   if (!series.toolTipEnabled) {
    this.Hide();
    return;
   }
   var showForPoint = hitInfo.inSeriesPoint && this.chart.showPointToolTip;
   var showForSeries = !hitInfo.inSeriesPoint && hitInfo.inSeries && this.chart.showSeriesToolTip;
   if (showForPoint || showForSeries) {
    if (this.toolTip == null) {
     this.toolTip = __aspxCreateChartToolTip(this.chart.chartControl, __aspxChartToolTipID, 0);
    }
    if (showForPoint) {
     var image = series != null ? series.toolTipImage : null;
     this.setToolTipContent(image, this.toolTipObject.toolTipText);
     this.showToolTip(x, y, hitInfo, htmlElementX, htmlElementY);
     return;
    }
    if (showForSeries) {
     this.setToolTipContent(this.toolTipObject.toolTipImage, this.toolTipObject.toolTipText);
     this.showToolTip(x, y, hitInfo, htmlElementX, htmlElementY);
     return;
    }
   }
   this.toolTipObject = null;
  }
 },
 Hide: function() {
  if (this.toolTip != null) {
   __aspxRemoveChartDiv(this.chart.chartControl, __aspxChartToolTipID, 0);
   this.toolTip = null;
  }
 },
 getImageHTML: function(image) {
  return "<img src='" + image + "' />";
 },
 getVerticalTable: function(cell1, cell2) {
  return "<table><tr><td>" + cell1 + "</td></tr><tr><td>" + cell2 + "</td></tr></table>";
 },
 setToolTipContent: function(image, text) {
  var toolTipContent = "";
  if (this.showText && this.showImage && image != null) {
   var imageHTML = this.getImageHTML(image);
   switch (this.imagePosition) {
    case "Right":
     toolTipContent = __aspxChartGetHorizontalTable(text, imageHTML);
     break;
    case "Top":
     toolTipContent = this.getVerticalTable(imageHTML, text);
     break;
    case "Bottom":
     toolTipContent = this.getVerticalTable(text, imageHTML);
     break;
    default:
     toolTipContent = __aspxChartGetHorizontalTable(imageHTML, text);
     break;
   }
  }
  else if (this.showImage && image != null) {
   toolTipContent = this.getImageHTML(image);
  }
  else if (this.showText) {
   toolTipContent = text;
  }
  this.toolTip.innerHTML = toolTipContent;
 },
 showToolTip: function(x, y, hitInfo, htmlElementX, htmlElementY) {
  if (this.chart.toolTipPosition instanceof ASPxClientToolTipMousePosition) {
   __aspxChartSetDivPosition(this.toolTip, x, y);
   return;
  }
  if (this.chart.toolTipPosition instanceof ASPxClientToolTipFreePosition) {
   __aspxShowInFreePosition(this.toolTip, this.chart, this.chart.toolTipPosition, htmlElementX, htmlElementY);
   return;
  }
  if (this.chart.toolTipPosition instanceof ASPxClientToolTipRelativePosition) {
   this.showToolTipInRelativePosition(x, y, hitInfo, htmlElementX, htmlElementY);
  }
 },
 showToolTipInRelativePosition: function(x, y, hitInfo, htmlElementX, htmlElementY) {
  var left;
  var top;
  if (hitInfo.seriesPoint != null && !hitInfo.inLegend) {
   left = htmlElementX + hitInfo.seriesPoint.toolTipPoint[0] - this.toolTip.clientWidth / 2 + this.chart.toolTipPosition.offsetX;
   top = htmlElementY + hitInfo.seriesPoint.toolTipPoint[1] - this.toolTip.clientHeight + this.chart.toolTipPosition.offsetY;
  }
  else {
   left = x + this.chart.toolTipPosition.offsetX;
   top = y + this.chart.toolTipPosition.offsetY;
  }
  __aspxChartSetDivPosition(this.toolTip, left, top);
 }
});
ASPxClientToolTipPosition = _aspxCreateClass(null, {
 constructor: function(interimObject) {
 }
});
ASPxClientToolTipMousePosition = _aspxCreateClass(ASPxClientToolTipPosition, {
 constructor: function(interimObject) {
  this.constructor.prototype.constructor.call(this, interimObject);
 }
});
ASPxClientToolTipRelativePosition = _aspxCreateClass(ASPxClientToolTipPosition, {
 constructor: function(interimObject) {
  this.constructor.prototype.constructor.call(this, interimObject);
  this.offsetX = interimObject.ox;
  this.offsetY = interimObject.oy;
 }
});
ASPxClientToolTipFreePosition = _aspxCreateClass(ASPxClientToolTipPosition, {
 constructor: function(interimObject) {
  this.constructor.prototype.constructor.call(this, interimObject);
  this.offsetX = interimObject.ox;
  this.offsetY = interimObject.oy;
  this.paneID = interimObject.dt;
  this.dockPosition = interimObject.dp;
 }
});
ASPxClientCrosshairPosition = _aspxCreateClass(null, {
 constructor: function(interimObject) {
  this.offsetX = interimObject.ox;
  this.offsetY = interimObject.oy;
 }
});
ASPxClientCrosshairMousePosition = _aspxCreateClass(ASPxClientCrosshairPosition, {
 constructor: function(interimObject) {
  this.constructor.prototype.constructor.call(this, interimObject);
 }
});
ASPxClientCrosshairFreePosition = _aspxCreateClass(ASPxClientCrosshairPosition, {
 constructor: function(interimObject) {
  this.constructor.prototype.constructor.call(this, interimObject);
  this.paneID = interimObject.dt;
  this.dockPosition = interimObject.dp;
 }
});
ASPxClientCrosshairOptions = _aspxCreateClass(ASPxClientWebChartEmptyElement, {
 constructor: function(chart, interimObject) {
  this.constructor.prototype.constructor.call(this, chart, interimObject);
  this.showArgumentLabels = interimObject.sx;
  this.showValueLabels = interimObject.sy;
  this.showCrosshairLabels = interimObject.sl;
  this.showArgumentLine = interimObject.sxl;
  this.showValueLine = interimObject.syl;
  this.showOnlyInFocusedPane = interimObject.sfp;
  this.snapMode = interimObject.sm;
  this.crosshairLabelMode = interimObject.lm;
  if (_aspxIsExists(interimObject.clp)) {
   this.crosshairLabelPosition = this.CreateCrosshairPosition(interimObject.clp);
  }
 },
 CreateCrosshairPosition: function(interimPosition) {
  if (interimPosition.t == "CFP")
   return new ASPxClientCrosshairFreePosition(interimPosition);
  else if (interimPosition.t == "CMP")
   return new ASPxClientCrosshairMousePosition(interimPosition);
  return null;
 }
});
ASPxClientAxisLabelBounds = _aspxCreateClass(ASPxClientWebChartEmptyElement, {
 constructor: function(chart, interimObject) {
  this.constructor.prototype.constructor.call(this, chart, interimObject);
  this.axisName = interimObject.an;
  this.left = interimObject.ll;
  this.top = interimObject.lt;
  this.height = interimObject.lh;
  this.width = interimObject.lw;
 }
});


}

/*
playback timings (ms):
  captures_list: 491.326
  exclusion.robots: 0.12
  exclusion.robots.policy: 0.11
  RedisCDXSource: 26.032
  esindex: 0.009
  LoadShardBlock: 439.996 (3)
  PetaboxLoader3.datanode: 425.525 (4)
  CDXLines.iter: 22.418 (3)
  load_resource: 82.976
  PetaboxLoader3.resolve: 43.952
*/