ASPxClientWebChartControl = _aspxCreateClass(ASPxClientControl, {
	constructor: function(name){
		this.constructor.prototype.constructor.call(this, name);			    
		this.ObjectHotTracked = new ASPxClientEvent();
		this.ObjectSelected = new ASPxClientEvent();
    },
    GetHtmlElement : function(evt) {
        return __aspxIE ? evt.srcElement : evt.target;
    },        
    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);
    },    
    OnMouseDown : function(evt) {
        if(!_aspxGetIsLeftButtonPressed(evt))
            return;
        var processOnServer = this.IsServerEventAssigned("ObjectSelected");
        var mouseEventX = _aspxGetEventX(evt);
        var mouseEventY = _aspxGetEventY(evt);        
        var htmlElement = this.GetHtmlElement(evt);        
        var x = this.CalculateEventX(htmlElement, mouseEventX);
        var y = this.CalculateEventY(htmlElement, mouseEventY);        
        if(_aspxIsExists(this.RaiseObjectSelected))
            processOnServer = this.RaiseObjectSelected(x, y, htmlElement, mouseEventX, mouseEventY);
        if(processOnServer) {
            var eventParams = "SELECT:" + x + ":" + y;
            if(this.autoPostBack)
                this.SendPostBack(eventParams);
            else if(_aspxIsExists(this.callBack))
                this.ChartCallback(eventParams);
        }
    },
    OnMouseMove : function(evt) {
        if(_aspxIsExists(this.RaiseObjectHotTracked)) {
            var mouseEventX = _aspxGetEventX(evt);
            var mouseEventY = _aspxGetEventY(evt);        
            var htmlElement = this.GetHtmlElement(evt);        
            var x = this.CalculateEventX(htmlElement, mouseEventX);
            var y = this.CalculateEventY(htmlElement, mouseEventY);        
            this.RaiseObjectHotTracked(x, y, htmlElement, mouseEventX, mouseEventY);
        }
    },
    OnCallback: function(result) {
        this.HideLoadingPanel();
        var resultParams = result.split("|");
        if(resultParams.length >= 3) {
            var htmlImage = this.GetMainElement();
            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]));
                this.InitObjectModel(eval("(" + resultParams[4] + ")"));
            }
        }
    },
    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) {
        this.ShowLoadingPanel();
        this.CreateCallback(eventParams);
    },
    ShowLoadingPanel: function() {
        var panelElement = this.GetLoadingPanelElement();
        var chartElement = this.GetMainElement();
        
        panelElement.style.position = "absolute";        
		var left = Math.max(_aspxGetAbsoluteX(chartElement), _aspxGetDocumentScrollLeft());
		var width = Math.min(_aspxGetAbsoluteX(chartElement) + chartElement.offsetWidth, _aspxGetDocumentScrollLeft() + _aspxGetDocumentClientWidth()) - left;
		var top = Math.max(_aspxGetAbsoluteY(chartElement), _aspxGetDocumentScrollTop());
		var height = Math.min(_aspxGetAbsoluteY(chartElement) + chartElement.offsetHeight, _aspxGetDocumentScrollTop() + _aspxGetDocumentClientHeight()) - top;
		_aspxSetElementDisplay(panelElement, true);        
        panelElement.style.left = left + (width - panelElement.offsetWidth) / 2  + "px";
        panelElement.style.top = top + (height - panelElement.offsetHeight) / 2 + "px";		
    },
    HideLoadingPanel: function() {
        var panelElement = this.GetLoadingPanelElement();
        _aspxSetElementDisplay(panelElement, false);
    }
});

function __chartMouseDown(evt, name) {
    var control = aspxGetControlCollection().Get(name);
    if(control != null)
        control.OnMouseDown(evt);
        
}
function __chartMouseMove(evt, name) { 
    var control = aspxGetControlCollection().Get(name);
    if(control != null)
        control.OnMouseMove(evt);
}

// API
ASPxClientScaleType = _aspxCreateClass(null, {});
ASPxClientScaleType.Qualitative = "Qualitative";
ASPxClientScaleType.Numerical = "Numerical";
ASPxClientScaleType.DateTime = "DateTime";
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) {
    var hitObjects = this.HitTest(x, y);
    var hitInfo = new ASPxClientWebChartHitInfo(hitObjects);
    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) {
    var processOnServer = this.IsServerEventAssigned("ObjectSelected");    
    var hitObjects = this.HitTest(x, y);
    var hitInfo = new ASPxClientWebChartHitInfo(hitObjects);
    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) {
    return this.hitTestController.HitTest(x, y);
};
ASPxClientWebChartControl.prototype.PerformCallback = function(args) {
    if (!_aspxIsExists(this.callBack)) return;        
    if (!_aspxIsExists(args)) args = "";
    this.ChartCallback("CUSTOMCALLBACK:" + args);
};
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.inConstantLine = false;                
        this.inDiagram = false;                
        this.inLegend = false;                
        this.inSeries = false;                        
        this.inSeriesLabel = false;                        
        this.inSeriesPoint = false;                        
        this.inSeriesTitle = false;
        
        for(var i = 0; i < hitObjects.length; i++) {
            if(hitObjects[i].object instanceof ASPxClientWebChart)
                this.inChart = true;
            else if(hitObjects[i].object instanceof ASPxClientChartTitle)
                this.inChartTitle = true;
            else if(
                (hitObjects[i].object instanceof ASPxClientAxis) || 
                (hitObjects[i].object instanceof ASPxClientAxis3D) || 
                (hitObjects[i].object instanceof ASPxClientRadarAxis))
                this.inAxis = true;
            else if(hitObjects[i].object instanceof ASPxClientConstantLine)
                this.inConstantLine = true;
            else if(
                (hitObjects[i].object instanceof ASPxClientSimpleDiagram) || 
                (hitObjects[i].object instanceof ASPxClientXYDiagram) || 
                (hitObjects[i].object instanceof ASPxClientXYDiagram3D) || 
                (hitObjects[i].object instanceof ASPxClientRadarDiagram))
                this.inDiagram = true;
            else if(hitObjects[i].object instanceof ASPxClientLegend)
                this.inLegend = true;
            else if(hitObjects[i].object instanceof ASPxClientSeries)
                this.inSeries = true;
            else if(hitObjects[i].object instanceof ASPxClientSeriesLabel)
                this.inSeriesLabel = true;
            else if(hitObjects[i].object instanceof ASPxClientSeriesTitle)
                this.inSeriesTitle = true;
                
            if(hitObjects[i].additionalObject != null)
                if(hitObjects[i].additionalObject instanceof ASPxClientSeriesPoint)
                    this.inSeriesPoint = true;                
        }
    }
});
ASPxClientDiagramCoordinates = _aspxCreateClass(null, {
    constructor: function() {
        this.argumentScaleType = '';
        this.valueScaleType = '';
        this.qualitativeArgument = '';
        this.numericalArgument = 0;
        this.dateTimeArgument = null;
        this.numericalValue = 0;
        this.dateTimeValue = null;
    },
    IsEmpty: function() {
        return this.argumentScaleType == '';
    }
});
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.legend = new ASPxClientLegend(this, interimObject.l);        
    },
    CreateXYDiagram: function(interimXYDiagram) {
        if(interimXYDiagram.t == "XYD")
            return new ASPxClientXYDiagram(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);
        });
    }
});
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";
    }
});
ASPxClientXYDiagram = _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.dr))
            throw ASPxClientWebChartElement.objectModelError;
        this.secondaryAxesX = this.CreateSecondaryAxes(interimObject.sx);
        this.secondaryAxesY = this.CreateSecondaryAxes(interimObject.sy);
        this.rotated = interimObject.dr;
        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;
    },
    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);
        });
    },
    PointToDiagram: function(x, y) {
        var coordinates = new ASPxClientDiagramCoordinates();
        if (!_aspxIsExists(this.boundsLeft) || !_aspxIsExists(this.boundsTop) || 
            !_aspxIsExists(this.boundsWidth) || !_aspxIsExists(this.boundsHeight) ||
            (this.boundsWidth == 0) || (this.boundsHeight == 0) || (this.axisX == null) || (this.axisY == null))
            return coordinates;
        x -= this.boundsLeft;
        y -= this.boundsTop;
        if ((x < 0) || (x > this.boundsWidth) || (y < 0) || (y > this.boundsHeight))
            return coordinates;
        var xRatio = x / this.boundsWidth;
        var yRatio = 1.0 - y / this.boundsHeight;
        if (this.rotated) {
            var temp = xRatio;
            xRatio = yRatio;
            yRatio = temp;
        }
        if (this.axisX.reverse)
            xRatio = 1.0 - xRatio;
        if (this.axisY.reverse)
            yRatio = 1.0 - yRatio;
            
        var argumentInternal = this.axisX.range.GetInternalValue(xRatio);
        var valueInternal = this.axisY.range.GetInternalValue(yRatio);
        var argument = this.axisX.GetNativeArgument(argumentInternal);
        var value = this.axisY.GetNativeArgument(valueInternal);
        if (typeof(argument) == 'string') {
            coordinates.qualitativeArgument = argument;        
            coordinates.argumentScaleType = ASPxClientScaleType.Qualitative;
        }
        else if (argument instanceof Date) {
            coordinates.dateTimeArgument = argument;
            coordinates.argumentScaleType = ASPxClientScaleType.DateTime;
        }
        else {
            coordinates.dateTimeArgument = 'not found';
            coordinates.argumentScaleType = ASPxClientScaleType.Numerical;
        }
        coordinates.numericalArgument = argumentInternal;
        
        if (value instanceof Date) {
            coordinates.dateTimeValue = value;
            coordinates.valueScaleType = ASPxClientScaleType.DateTime;
        }
        else
            coordinates.valueScaleType = ASPxClientScaleType.Numerical;
        coordinates.numericalValue = valueInternal;
        return coordinates;
    }
});
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);
    },
    CreateAxis: function(interimAxis) {
        return new ASPxClientRadarAxis(this.chart, this, interimAxis);        
    }
});

ASPxClientQualitativeMap = _aspxCreateClass(null, {
    constructor: function(interimMap) {
        if (!_aspxIsExists(interimMap.vl))
            throw ASPxClientWebChartElement.objectModelError;
        this.values = interimMap.vl;            
    },
    GetNativeValue: function(internalValue) {
        return (internalValue < 0 || internalValue >= this.values.length) ? null : this.values[internalValue];
    }
});

ASPxClientDateTimeMap = _aspxCreateClass(null, {
    constructor: function(interimMap) {
        if (!_aspxIsExists(interimMap.su) || !_aspxIsExists(interimMap.sv))
            throw ASPxClientWebChartElement.objectModelError;
        this.measureUnit = interimMap.su;
        this.startDate = interimMap.sv;
    },
    GetDate: function(n) {
		return new Date(this.startDate.getTime() + n);
	},
    GetNativeValue: function(internalValue) {
        if (this.measureUnit == 'Year')
            return new Date(this.startDate.getYear() + internalValue, this.startDate.getMonth(), this.startDate.getDate(), 
                            this.startDate.getHours(), this.startDate.getMinutes(), this.startDate.getSeconds());
        if (this.measureUnit == 'Month') {
            var monthsCount = Math.abs(internalValue);
            var years = Math.floor(monthsCount / 12);
            var months = monthsCount - years * 12;
            if (internalValue < 0) {
                years = -years;
                months = -months;
            }
            var year = this.startDate.getYear() + years;
            var month = this.startDate.getMonth() + months;
            if (month < 0) {
                year = year - 1;
                month = month + 12;
            }
            else if (month >= 12) {
                year = year + 1;
                month = month - 12;
            }
            return new Date(year, month, this.startDate.getDate(), this.startDate.getHours(), this.startDate.getMinutes(), this.startDate.getSeconds());
        }
        if (this.measureUnit == 'Day')
            return this.GetDate(internalValue * 1000 * 60 * 60 * 24);
        if (this.measureUnit == 'Hour')
            return this.GetDate(internalValue * 1000 * 60 * 60);
        if (this.measureUnit == 'Minute')
            return this.GetDate(internalValue * 1000 * 60);
        if (this.measureUnit == 'Second')
            return this.GetDate(internalValue * 1000);
        return this.GetDate(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);
        this.range = new ASPxClientAxisRange(this.chart, this, interimObject.r);
        
        if (_aspxIsExists(interimObject.m))
            this.scale = this.CreateMap(interimObject.m);
    },
    CreateMap: function(interimMap) {
        if (interimMap.t == "Q")
            return new ASPxClientQualitativeMap(interimMap);
        if (interimMap.t == "D")
            return new ASPxClientDateTimeMap(interimMap);
        throw ASPxClientWebChartElement.objectModelError;
    },
	GetNativeArgument: function(value) {
	    return (this.scale == null) ? value : this.scale.GetNativeValue(Math.round(value));
	}
});
ASPxClientAxis = _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);
        this.title = _aspxIsExists(interimObject.ti) ? interimObject.ti : "";
        this.strips = this.CreateStrips(interimObject.s);
        this.constantLines = this.CreateConstantLines(interimObject.cl);        
        
        if (!_aspxIsExists(interimObject.ar))
            throw ASPxClientWebChartElement.objectModelError;
        this.reverse = interimObject.ar;
    },
    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);
        });
    }
});
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);
    }
});
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.mi) || !_aspxIsExists(interimObject.ma) ||
            !_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;
    },
    GetInternalValue: function(ratio) {
        return this.minValueInternal + (this.maxValueInternal - this.minValueInternal) * ratio;
    }
});
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;            
        this.visible = !_aspxIsExists(interimObject.nvi);
        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);
    },
    CreatePoints: function(interimPoints) {
        return this.CreateArray(interimPoints, createPoint = function(chart, series, interimPoint) {
            return new ASPxClientSeriesPoint(chart, series, interimPoint);
        });
    },
    CreateTitles: function(interimTitles) {
        return this.CreateArray(interimTitles, createTitle = function(chart, series, interimTitle) {
            return new ASPxClientSeriesTitle(chart, series, interimTitle);
        });
    }
});
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;
    }
});
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;
    }
});
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;
    }
});