(function (window) {

    Element.prototype.setAttr = function () {
        try{
            if (arguments == undefined) {
                return;
            }
            if (arguments.length == 1) {
                for (var name in arguments[0]) {
                    this.setAttribute(name, arguments[0][name]);
                }
                ;
            } else if (arguments.length == 2) {
                this.setAttribute(arguments[0], arguments[1]);
            }
            return this;
        }
        catch (err) {
            alert(err);
        }
    };

    Element.prototype.setStyle = function () {
        if (arguments.length == 1) {
            for (var name in arguments[0]) {
                this.style[name] = arguments[0][name];
            }
            ;
        } else if (arguments.length == 2) {
            this.style[arguments[0]] = arguments[1];
        }
        ;
        return this;
    };

    Element.prototype.html = function (html) {
        if (html != null) {
            this.innerHTML = html;
            return this;
        } else {
            return this.innerHTML;
        }
    };

    Element.prototype.createKey = function (key) {
        if (!key)
            return this;
        this.setAttr("id", key);
        return this;
    };

    Element.prototype.on = function (type, callback) {
        if (this.addEventListener) {
            this.addEventListener(type, callback, false);
        }
        else if (this.attachEvent) {
            this.attachEvent('on' + type, function () {
                return callback.call(this, window.event);
            });
        }
        ;
    };

 

    var extend = function (c, o) {
        if (o == null) {
            return c;
        }
        ;
        if (c == null) {
            c = {};
        }
        ;
        for (var key in o) {
            c[key] = o[key];
        }
        ;
        return c;
    };

    var svgObject = function ( ) {
        var  elementType = {
                    "svg": "svg",
                    "path": 'path',
                    "rect": "rect",
                    "g": "g",
                    "circle": "circle",
                    "text": "text"
                },
                area = null,
                node = null,
                paths = null,
                importAddress = "http://www.w3.org/2000/svg";

        this.createArea = function (attr, style) {
  
            var areaAttr = extend({}, attr);

            var areaStyle = extend({}, style);

            node.appendChild(area = document.createElementNS(importAddress,
                elementType.rect).setAttr(areaAttr).setStyle(areaStyle));

            return area;
        };

        this.createRect = function (attr, style, name) {
            var
                   areaAttr = extend({}, attr),

                   areaStyle = extend({}, style),

                   rect = document.createElementNS(importAddress, elementType.rect).setAttr(areaAttr).setStyle(areaStyle);
            rect.createKey(name);
            //paths[name] = rect.setAttr();
            node.appendChild(rect);
        }

        this.createText = function (attr, style, txt, zIndex, name) {
            var
                    g = document.createElementNS(importAddress, elementType.g),
                    textNode = document.createTextNode(txt);
            text = document.createElementNS(importAddress, elementType.text);
            text.createKey(name);
            //paths[name] = text;
            text.setAttr(attr).setAttr("style", style || "").appendChild(textNode);
            g.setAttr("zIndex", (zIndex || 7)).appendChild(text);
            node.appendChild(g);

        };

        this.removeByName = function (name) {
            var elm = this.getPathByName(name);
            if (typeof elm === "Element") {
                node.remove(this.getPathByName(name));
            }
            //if (paths[name] != null)
            //    node.removeChild(paths[name])
        };

        this.createCircle = function (name, attr, style) {
            var
                    circle = document.createElementNS(importAddress, elementType.circle);
            circle.createKey(name);
            // paths[name] = circle;
            if (style != null) {
                circle.setAttr(attr);
            }
            else {
                circle.setAttr(attr).setAttr("style", style);
            }
            // circle.setAttr("id", name);
            node.appendChild(circle);
            return circle;
        };

        this.createPath = function (name, value, attr, style) {
            var  path = document.createElementNS(importAddress, elementType.path);
            //paths[name] = path;
            path.createKey(name);
            node.appendChild(path);
            this.setPathValue(path, value, attr, style)
            return path;
        };

        this.getPathByName = function (name) {
            return document.getElementById(name);
        };

        this.setPathValue = function (path, value, attr, style) {
            if (value == null) {
                return;
            }
            path = typeof path === "string" ? this.getPathByName(path) : path;
            path.setAttr("d", value).setAttr(attr || {}).setStyle(style || {});
        };

        this.getNode = function () {
            return node;
        };

        this.init = function (divName,svgClick, svgMove) {

            var container = document.getElementById(divName);

            paths = new Object();
 
            var        size = {
                        "width": document.getElementById(divName).clientWidth,
                        "height": document.getElementById(divName).clientHeight
                    };
            if (node == null) {
                node = document.createElementNS(importAddress, elementType.svg);
                node.setAttribute("xmlns", "http://www.w3.org/2000/svg")
                node.setAttribute("shape-rendering", "crispEdges");
                node.setAttribute("version", "1.0");
                node.on("mousemove", function (e) {
                    if (typeof svgMove == "function") {//没有起到作用                     
                        var e = e || window.event;
                        svgMove(e, node);
                    }
                });
                node.on("click", function (e) {
                    if (typeof svgClick == "function") {//没有起到作用      
                        var e = e || window.event;
                        svgClick(e, node);
                    }
                });
            }
            container.appendChild(node.setAttr(size));
            return this;
        };
    };

    var thumbnailChart = function () {
        var m_svg;
        var m_chartType = 1;//Speed 0     Cut 1     BaoLuo 2    ZhouLiu 4
     
 
        var m_displayStyle;//显示样式
        var m_chartSize;
        var m_localizationType = 0;//中文zhCN = 0, zhTW = 1,   enUS = 2
        var m_divChartName;//容器DIV名称
        var m_divChartHeight = 50;
        var m_divChartWidth = 100;
 
        var m_chartObject;//图表上的物体
        var m_systemPlantType = 0;  //0: 电脑 1:手机  
 
 
 
        var m_designPoint;

 

        //转成Bezier曲线模型
        var transBezierCurveModel = function (pixelPoints) {
            if (pixelPoints == null || pixelPoints.length < 4)
                return null;

            var iPointCout = pixelPoints.length;
            var a = 0.09;
            var b = 0.09;
            var controlPoint = new Array();

            for (var i = 0; i < iPointCout - 1; i++) {
                var bezier = {};
                bezier.Point0 = pixelPoints[i];
                if (i == 0) {
                    var x1 = pixelPoints[i].X + a * (pixelPoints[i + 1].X - pixelPoints[i].X);
                    var y1 = pixelPoints[i].Y + a * (pixelPoints[i + 1].Y - pixelPoints[i].Y);
                    bezier.Point1 = {
                        "X": x1,
                        "Y": y1
                    };
                }
                else {
                    var x1 = pixelPoints[i].X + a * (pixelPoints[i + 1].X - pixelPoints[i - 1].X);
                    var y1 = pixelPoints[i].Y + a * (pixelPoints[i + 1].Y - pixelPoints[i - 1].Y);
                    bezier.Point1 = {
                        "X": x1,
                        "Y": y1
                    }
                }

                if (i == iPointCout - 2) {
                    var x2 = pixelPoints[i + 1].X - b * (pixelPoints[i + 1].X - pixelPoints[i].X);
                    var y2 = pixelPoints[i + 1].Y - b * (pixelPoints[i + 1].Y - pixelPoints[i].Y);
                    bezier.Point2 = {
                        "X": x2,
                        "Y": y2
                    }
                }
                else {
                    var x2 = pixelPoints[i + 1].X - b * (pixelPoints[i + 2].X - pixelPoints[i].X);
                    var y2 = pixelPoints[i + 1].Y - b * (pixelPoints[i + 2].Y - pixelPoints[i].Y);
                    bezier.Point2 = {
                        "X": x2,
                        "Y": y2
                    }
                }

                bezier.Point3 = pixelPoints[i + 1];
                controlPoint.push(bezier);
            }
            return controlPoint;
        };

        //转成曲线路径
        var transBezierCurveToPath = function (pixelPoints) {
            var bezierCurveValue = transBezierCurveModel(pixelPoints);
            if (bezierCurveValue == null) {
                return;
            }
            var pathValue = new Array();
            for (var h = 0; h < bezierCurveValue.length; h++) {
                if (h == 0) {
                    pathValue.push("M ", bezierCurveValue[h].Point0.X, " ", bezierCurveValue[h].Point0.Y);
                    pathValue.push(" C ", bezierCurveValue[h].Point1.X, " ", bezierCurveValue[h].Point1.Y, " ", bezierCurveValue[h].Point2.X, " ", bezierCurveValue[h].Point2.Y, " ", bezierCurveValue[h].Point3.X, " ", bezierCurveValue[h].Point3.Y);
                }
                else {
                    pathValue.push(" L ", bezierCurveValue[h].Point0.X, " ", bezierCurveValue[h].Point0.Y);
                    pathValue.push(" C ", bezierCurveValue[h].Point1.X, " ", bezierCurveValue[h].Point1.Y, " ", bezierCurveValue[h].Point2.X, " ", bezierCurveValue[h].Point2.Y, " ", bezierCurveValue[h].Point3.X, " ", bezierCurveValue[h].Point3.Y);
                }
                if (h == bezierCurveValue.length - 1) {
                    pathValue.push(" L ", bezierCurveValue[h].Point3.X, " ", bezierCurveValue[h].Point3.Y);
                }
            }
            return pathValue;
        };


        var getActualValue = function (actualMinValue, actualMaxValue, pixelMinValue, pixelMaxValue, pixelValue) {
            var actual = null;
            actual = (pixelValue - pixelMinValue) / (pixelMaxValue - pixelMinValue) * (actualMaxValue - actualMinValue) + actualMinValue;
            // actual = (pixelValue - pixelMinValue) / (pixelMaxValue - pixelMinValue) * (actualMaxValue - actualMinValue) + pixelMinValue;
            return actual;
        };

        var getPixelValue = function (actualValue, actualMinValue, actualMaxValue, pixelMinValue, pixelMaxValue) {
            return (actualValue - actualMinValue) / (actualMaxValue - actualMinValue) * (pixelMaxValue - pixelMinValue) + pixelMinValue;
        };

        var  getSectPoint4Pixel = function (curve, x) {

            var iPtCount = curve.length;

            if (x < curve[0].Point0.X) {
                return null;
            }
            if (x > curve[iPtCount - 1].Point3.X) {
                return null;
            }

            for (var i = 0; i < iPtCount; i++) {

                if (x > curve[i].Point0.X && x < curve[i].Point3.X) {
                    var ptBizer = curve[i];
                    //
                    try {
                        //alert(i);
                        var minDis = Math.abs(ptBizer.Point3.X - ptBizer.Point0.X);
                        //alert(x + "   " + curve[i].Point0.X + "    " + curve[i].Point3.X);
                        var sectY = 0;
                        var sectX = 0;
                        for (var uu = 0; uu <= 1; uu = uu + 0.05) {
                            var x0 = ptBizer.Point0.X * uu * uu * uu;
                            var x1 = 3 * ptBizer.Point1.X * uu * uu * (1 - uu);
                            var x2 = 3 * ptBizer.Point2.X * uu * (1 - uu) * (1 - uu);
                            var x3 = ptBizer.Point3.X * (1 - uu) * (1 - uu) * (1 - uu);

                            var curveX = x0 + x1 + x2 + x3;
                            if (Math.abs(curveX - x) < minDis) {
                                var y0 = ptBizer.Point0.Y * uu * uu * uu;
                                var y1 = 3 * ptBizer.Point1.Y * uu * uu * (1 - uu);
                                var y2 = 3 * ptBizer.Point2.Y * uu * (1 - uu) * (1 - uu);
                                var y3 = ptBizer.Point3.Y * (1 - uu) * (1 - uu) * (1 - uu);
                                minDis = Math.abs(curveX - x);
                                sectY = y0 + y1 + y2 + y3;
                                sectX = curveX;
                            }
                        }
                        return {
                            x: sectX, y: sectY
                        };
                    }
                    catch (ex) {
                        alert(ex.message);
                    }
                }

            }
        };

 
 
        //
        var getSvgObjByName = function (objName) {
            return m_svg.getPathByName(objName);
        };

 
 

        var svgClick = function (e, svg) {
           


        };

        var svgMove = function (e, svg) {
            //alert("svgMove");
        };

        //初始化面板
        var initialMainPanel = function (divName) {
            if (divName == null) {
                return;
            }
            var width = m_divChartWidth;
            var height = m_divChartHeight;

            var space_left = 3;
            var space_right = 3;
            var space_top = 3;
            var space_bottom = 3;

            m_chartSize = {};
            m_chartSize.TotalWidth = width;
            m_chartSize.TotalHeight = height;
            m_chartSize.DiagramWidth = width - space_left - space_right;
            m_chartSize.DiagramHeight = height - space_top - space_bottom;
   
            m_chartSize.SpaceLeft = space_left;
            m_chartSize.SpaceTop = space_top;
            m_chartSize.SpaceRight = space_right;
            m_chartSize.SpaceBottom = space_bottom;

            m_chartSize.DiagramRightX = width - space_right;
            m_chartSize.DiagramBottomY = height - space_bottom;
 
 

            //把间隙弄小点
            var areaAttr = {
                x: space_left,
                y: space_top,
                width: m_chartSize.DiagramWidth,
                height: m_chartSize.DiagramHeight
            };

            var areaStyle = {
                "stroke-width": "0px",
                "stroke": "#cccccc",
                "fill": "white",
                "opacity":"0",
                "fill-opacity": "0.5",
                "zIndex:": 5
            };

            //
            m_svg = new svgObject().init(divName, svgClick, svgMove);
            //
            m_svg.createArea(areaAttr, areaStyle);
        };

 

        //产生型谱
        var craeteSpectrumShape = function (spectrumShape) {
            if (spectrumShape == null)
                return;

            var pathValue = new Array();

            var coordinates_Left = new Array();
            var points = spectrumShape["LeftParabolaPoints"];
            for (var v = 0; v < points.length; v++) {
                var pt = points[v];
                //var x = m_chartSize.SpaceLeft + (pt.X - m_coordinatePara.CoordMinQ) * m_chartSize.DiagramWidth / (m_coordinatePara.CoordSpaceQ * m_coordinatePara.GridNumberX);
                //var y = m_chartSize.DiagramBottomY - (pt.Y - m_coordinatePara.CoordMinH) * m_chartSize.DiagramHeight / (m_coordinatePara.CoordSpaceH * m_coordinatePara.GridNumberY);

                var x  = getPixelValue(pt.X, m_chartObject.MinQ, m_chartObject.MaxQ, m_chartSize.SpaceLeft, m_chartSize.DiagramRightX);
                var y = getPixelValue(pt.Y, m_chartObject.MinH, m_chartObject.MaxH, m_chartSize.DiagramBottomY, m_chartSize.SpaceTop);


                coordinates_Left.push({ "X": x, "Y": y });
            }
            var bezierCurveValue = transBezierCurveModel(coordinates_Left);           
            for (var h = 0; h < bezierCurveValue.length; h++) {
                if (h == 0) {
                    pathValue.push("M ", bezierCurveValue[h].Point0.X, " ", bezierCurveValue[h].Point0.Y);
                    pathValue.push(" C ", bezierCurveValue[h].Point1.X, " ", bezierCurveValue[h].Point1.Y, " ", bezierCurveValue[h].Point2.X, " ", bezierCurveValue[h].Point2.Y, " ", bezierCurveValue[h].Point3.X, " ", bezierCurveValue[h].Point3.Y);

                }
                else {
                    pathValue.push(" L ", bezierCurveValue[h].Point0.X, " ", bezierCurveValue[h].Point0.Y);
                    pathValue.push(" C ", bezierCurveValue[h].Point1.X, " ", bezierCurveValue[h].Point1.Y, " ", bezierCurveValue[h].Point2.X, " ", bezierCurveValue[h].Point2.Y, " ", bezierCurveValue[h].Point3.X, " ", bezierCurveValue[h].Point3.Y);
                }
            }

            var coordinates_Top = new Array();
            points = spectrumShape["BasePoints"];
            for (var v = 0; v < points.length; v++) {
                var pt = points[v];
                var x = getPixelValue(pt.X, m_chartObject.MinQ, m_chartObject.MaxQ, m_chartSize.SpaceLeft, m_chartSize.DiagramRightX);
                var y = getPixelValue(pt.Y, m_chartObject.MinH, m_chartObject.MaxH, m_chartSize.DiagramBottomY, m_chartSize.SpaceTop);
                coordinates_Top.push({ "X": x, "Y": y });
            }
            bezierCurveValue = transBezierCurveModel(coordinates_Top);
            for (var h = 0; h < bezierCurveValue.length; h++) {
 
                pathValue.push(" L ", bezierCurveValue[h].Point0.X, " ", bezierCurveValue[h].Point0.Y);
                pathValue.push(" C ", bezierCurveValue[h].Point1.X, " ", bezierCurveValue[h].Point1.Y, " ", bezierCurveValue[h].Point2.X, " ", bezierCurveValue[h].Point2.Y, " ", bezierCurveValue[h].Point3.X, " ", bezierCurveValue[h].Point3.Y);              
            }


            var coordinates_bottom = new Array();
            points = spectrumShape["SimularPoints"];
            for (var v = 0; v < points.length; v++) {
                var pt = points[v];
                var x = getPixelValue(pt.X, m_chartObject.MinQ, m_chartObject.MaxQ, m_chartSize.SpaceLeft, m_chartSize.DiagramRightX);
                var y = getPixelValue(pt.Y, m_chartObject.MinH, m_chartObject.MaxH, m_chartSize.DiagramBottomY, m_chartSize.SpaceTop);
                coordinates_bottom.push({ "X": x, "Y": y });
            }
            bezierCurveValue = transBezierCurveModel(coordinates_bottom);
            for (var h = 0; h < bezierCurveValue.length; h++) {
                pathValue.push(" L ", bezierCurveValue[h].Point0.X, " ", bezierCurveValue[h].Point0.Y);
                pathValue.push(" C ", bezierCurveValue[h].Point1.X, " ", bezierCurveValue[h].Point1.Y, " ", bezierCurveValue[h].Point2.X, " ", bezierCurveValue[h].Point2.Y, " ", bezierCurveValue[h].Point3.X, " ", bezierCurveValue[h].Point3.Y);
            }


            var coordinates_right = new Array();
            points = spectrumShape["RightParabolaPoints"];
            for (var v = 0; v < points.length; v++) {
                var pt = points[v];
                var x = getPixelValue(pt.X, m_chartObject.MinQ, m_chartObject.MaxQ, m_chartSize.SpaceLeft, m_chartSize.DiagramRightX);
                var y = getPixelValue(pt.Y, m_chartObject.MinH, m_chartObject.MaxH, m_chartSize.DiagramBottomY, m_chartSize.SpaceTop);
                coordinates_right.push({ "X": x, "Y": y });
            }
            var bezierCurveValue = transBezierCurveModel(coordinates_right);
            for (var h = 0; h < bezierCurveValue.length; h++) {

                pathValue.push(" L ", bezierCurveValue[h].Point0.X, " ", bezierCurveValue[h].Point0.Y);
                pathValue.push(" C ", bezierCurveValue[h].Point1.X, " ", bezierCurveValue[h].Point1.Y, " ", bezierCurveValue[h].Point2.X, " ", bezierCurveValue[h].Point2.Y, " ", bezierCurveValue[h].Point3.X, " ", bezierCurveValue[h].Point3.Y);
                if (h == bezierCurveValue.length - 1) {
                    pathValue.push(" L ", bezierCurveValue[h].Point3.X, " ", bezierCurveValue[h].Point3.Y);
                }
            }


            var style = {
                "stroke-width": "1",
                "stroke": "none",
                "fill": "yellow",
                "stroke-opacity": '0.1',
                "fill-opacity": "0.3",
                "shape-rendering": "optimizeSpeed",
                "zIndex:": -1
            };
            m_svg.createPath("SpectrumShape", pathValue.join(''), {
                "id": "SpectrumShape"
            }, style);
        };
 
        //绘制曲线
        var createCurveQH = function (objName, curvePoints, curveWidth, curveColor) {

            if (curvePoints == null) {
                return;
            };

            var pixelPoints = new Array();
            for (var v = 0; v < curvePoints.length; v++) {
                var x = getPixelValue(curvePoints[v].X, m_chartObject.MinQ, m_chartObject.MaxQ, m_chartSize.SpaceLeft, m_chartSize.DiagramRightX);
                var y = getPixelValue(curvePoints[v].Y, m_chartObject.MinH, m_chartObject.MaxH, m_chartSize.DiagramBottomY, m_chartSize.SpaceTop);
                pixelPoints.push({ "X": x, "Y": y });
            }

            var pathValue = transBezierCurveToPath(pixelPoints);


            var style = {
                "stroke-width": "2px",
                "stroke": "black",
                "fill": "none",
                "fill-opacity": "0.5",
                //"stroke-dasharray":"5 3",
                "shape-rendering": "optimizeSpeed",
                "zIndex:": 7
            };
            if (curveWidth != null) {
                style["stroke-width"] = curveWidth;
            }
            if (curveColor != null) {
                style["stroke"] = curveColor;
            }
            m_svg.createPath(objName, pathValue.join(''), {
                "id": objName
            }, style);

            return pixelPoints;
 
        };
        //绘制直线
        var createLineQH = function (objName, point1, point2, curveWidth, curveColor, objTag) {
            if (point1 == null || point2 == null) {
                return;
            }
            if (objName == null) {
                return;
            }

            var x1 = getPixelValue(point1.X, m_chartObject.MinQ, m_chartObject.MaxQ, m_chartSize.SpaceLeft, m_chartSize.DiagramRightX);
            var y1 = getPixelValue(point1.Y, m_chartObject.MinH, m_chartObject.MaxH, m_chartSize.DiagramBottomY, m_chartSize.SpaceTop);


            var x2 = getPixelValue(point2.X, m_chartObject.MinQ, m_chartObject.MaxQ, m_chartSize.SpaceLeft, m_chartSize.DiagramRightX);
            var y2 = getPixelValue(point2.Y, m_chartObject.MinH, m_chartObject.MaxH, m_chartSize.DiagramBottomY, m_chartSize.SpaceTop);

            var style = {
                "stroke-width": "2px",
                "stroke": "black",
                "fill": "none",
                "fill-opacity": "0.5",
                //"stroke-dasharray":"5 3",
                "shape-rendering": "optimizeSpeed",
                "zIndex:": 7
            };
            if (curveWidth != null) {
                style["stroke-width"] = curveWidth;
            }
            if (curveColor != null) {
                style["stroke"] = curveColor;
            }
            var temp = "M x1 y1 L x2 y2";
            var pathValue = temp.replace("x1", x1).replace("y1", y1).replace("x2", x2).replace("y2", y2);
            if (objTag == null)
                m_svg.createPath(objName, pathValue, null, style);
            else
                m_svg.createPath(objName, pathValue, { "tag": objTag }, style);
        };
        //绘制点
        var createPointQH = function (objName, point, circleSize, circleColor) {
            if (point == null) {
                return;
            }
            if (objName == null) {
                return;
            }
            var xPixel = getPixelValue(point.X, m_chartObject.MinQ, m_chartObject.MaxQ, m_chartSize.SpaceLeft, m_chartSize.DiagramRightX);
            var yPixel = getPixelValue(point.Y, m_chartObject.MinH, m_chartObject.MaxH, m_chartSize.DiagramBottomY, m_chartSize.SpaceTop);
 

            var attr = {
                "cx":xPixel,
                "cy": yPixel,
                "r":2
            }
            var style = {
                "stroke-width": "1px",
                "stroke": "black",
                "fill": "none",
                "fill-opacity": "0.5",
                //"stroke-dasharray":"5 3",
                "shape-rendering": "optimizeSpeed",
                "zIndex:": 7
            };
            if (circleSize != null) {
                attr.r = circleSize;
            }
            if (circleColor != null) {
                style["stroke"] = circleColor;
            }

            m_svg.createCircle(objName, attr, style);
        };
 
 

  
        //绘制设计点
        var drawDesignPoint = function () {
            if(m_designPoint == null)
                return;

            var style = {
                "stroke-width": 2,
                "stroke": "red",
                "fill": "none",
                "stroke-opacity": '0.8',
                "shape-rendering": "optimizeSpeed",
                "zIndex:": 101
            };
     
            var x0 = getPixelValue(m_designPoint.Q, m_chartObject.MinQ, m_chartObject.MaxQ, m_chartSize.SpaceLeft, m_chartSize.DiagramRightX);
            var y0 = getPixelValue(m_designPoint.H, m_chartObject.MinH, m_chartObject.MaxH, m_chartSize.DiagramBottomY, m_chartSize.SpaceTop);

 
    
            var temp1 = "M x1 y1 L x2 y2";
            var pathValue1 = temp1.replace("x1", x0 - m_chartSize.DiagramWidth * 0.08).replace("y1", y0).replace("x2", x0 + m_chartSize.DiagramWidth * 0.08).replace("y2", y0);
            m_svg.createPath("DesignPointQ", pathValue1, null, style);


            var temp2 = "M x1 y1 L x2 y2";
            var pathValue2 = temp2.replace("x1", x0).replace("y1", y0 - m_chartSize.DiagramHeight * 0.1).replace("x2", x0).replace("y2", y0 + m_chartSize.DiagramHeight * 0.1);
            m_svg.createPath("DesignPointH", pathValue2, null, style);

 
           
        };

 
    
 
        //设置容器
        this.setContainerDivInfo = function (divChartName,divWidth,divHeight) {

            m_divChartName = divChartName;
            m_divChartHeight = divHeight;
            m_divChartWidth = divWidth;
        };

        this.setDesignPoint = function (dpQ, dpH) {
            m_designPoint = {};
            m_designPoint.Q = dpQ;
            m_designPoint.H = dpH;
        };

        //初始化图表(入口)
        this.createChartLxp = function (ChartFullInfo) {
           
            if (!m_divChartName)
                return;
            m_chartObject = ChartFullInfo;

            initialMainPanel(m_divChartName);

            createCurveQH("MaxWaterCurveQH", m_chartObject.MaxCurveQH);

            //设置设计点
            drawDesignPoint();         
            
            //绘制型谱
            craeteSpectrumShape(m_chartObject.SpectrumShape);
     
            return this;
        };

        //初始化图表(入口)
        this.createChartZlp = function (ChartFullInfo) {

            if (!m_divChartName)
                return;
            m_chartObject = ChartFullInfo;

            initialMainPanel(m_divChartName);
 

            //设置设计点
            drawDesignPoint();

    

            return this;
        };

    };

    window.ThumbnailChart = thumbnailChart;
 


})(window);
export default window