// 电池组图片
var eleGroupImg = new Image();
eleGroupImg.src="image/eleCircle/elegroup.png";

//用电负载
var loadImg = new Image();
loadImg.src = "image/eleCircle/load.png";

//整流器图标
var screenImg = new Image();
screenImg.src = "image/eleCircle/screen.png";
;(function($, window, document, gl) {
	//  设置命名空间
	gl.namespace('statusImg');
	// orange
	var orangeImg = new Image();
	orangeImg.src = "image/eleCircle/orange.png";

	// red
	var redImg = new Image();
	redImg.src = 'image/eleCircle/red.png';

	// blue
	var greenImg = new Image();
	greenImg.src = 'image/eleCircle/green.png';
	
	// gray
	var gayImg = new Image();
	gayImg.src = 'image/eleCircle/gray.png';
	
	// 根据设备放电模块获取图标
	function getdisChargeImg(status) {
		var i = parseInt(status);
		var rs = gayImg;
		switch(i) {
			case 1:		// 核容测试
			case 5:		// kd
				rs = orangeImg;
				break;
			case 2:	// 预充电
				rs = greenImg;
				break;
		}
		
		return rs;
	}
	
	// 根据设备充电状态获取图标
	function getChargeImg(status) {
		var i = parseInt(status);
		var rs = gayImg;
		switch(i) {
			case 1:		// 核容测试
			case 5:		// kd
				rs = greenImg;
				break;
			case 2:
				rs = orangeImg;
				break;
		}
		
		return rs;
	}
	
	// 根据设备工作状态图标
	function getImg(status) {
		var i = parseInt(status);
		var rs = gayImg;
		switch(i) {
			case 0:
			case 4:
				rs = greenImg
				break;
			case 1:
			case 2:
			case 5:		
				rs = orangeImg;
				break;
			case 3:
				rs = redImg;
				break;
		}
		
		return rs;
	}
	
	// 将函数绑定到GLOBAL.statusImg命名空间下
	gl.statusImg.getdisChargeImg = getdisChargeImg;
	
	gl.statusImg.getChargeImg = getChargeImg;
	
	gl.statusImg.getImg = getImg;
	
})(jQuery, window, document, GLOBAL);


var nStatusImg = GLOBAL.statusImg;

var EleCircle = function(canvas, options) {
	this.canvas = document.getElementById(canvas);
	this.context = this.canvas.getContext('2d');
	this.opts = [];
	this.timer = '';
	this.start();
	this.groupVol = '0V';
	this.eleCurrent = '0A';
};
// 绘制电路图的线
EleCircle.prototype.drawLine = function(options) {
	var defaults = {
		startX: 0,
		startY: 0,
		endX:0,
		endY: 0,
		lineWidth: 4,
		strokeStyle: '#000',
		fillStyle: '#000',
		id:''
	};
	var opts = $.extend({}, defaults, options || {});
	this.context.strokeStyle = opts.strokeStyle;
	this.context.fillStyle = opts.fillStyle;
	this.context.lineWidth = opts.lineWidth;
	
	this.context.beginPath();
	this.context.moveTo(opts.startX, opts.startY);
	this.context.lineTo(opts.endX, opts.endY);
	this.context.closePath();
	
	this.context.stroke();
	
	var lineInfo = {
		options: opts,
		type:'drawLine',
	};
	
	this.opts.push(lineInfo);
};

// 绘制BAT端
EleCircle.prototype.drawBAT = function(options) {
	var defaults = {
		startX: 0,
		startY: 0,
		endX:0,
		endY: 0,
		width: 16,
		lineWidth: 4,
		strokeStyle: '#000',
		fillStyle: '#000',
		nPosition: 'up',
		name: '',
		id:''
	};
	
	var opts = $.extend({}, defaults, options || {});
	
	this.context.fillStyle = opts.fillStyle;
	this.context.strokeStyle = opts.strokeStyle;
	this.context.lineWidth = opts.lineWidth;
	
	this.context.fillRect(opts.startX, opts.startY-opts.width/2, opts.width, opts.width);
	
	this.context.strokeRect(opts.startX, opts.startY-opts.width/2, opts.width, opts.width);
	
	this.context.fillStyle = '#000';
	this.context.font="12px Arial";
	if(opts.nPosition == 'up') {
		this.context.fillText(opts.name, opts.startX+opts.width+5,opts.startY-opts.width/2);
	}else {
		this.context.fillText(opts.name, opts.startX+opts.width+5,opts.startY+opts.width);
	}
	
	
	var BATInfor = {
		options: opts,
		type:'drawBAT',
	};
	this.opts.push(BATInfor);
};

// 绘制DCDC模块
EleCircle.prototype.drawDCDC = function(options) {
	var defaults = {
		startX: 0,
		startY: 0,
		endX:0,
		endY: 0,
		width: 100,
		lineWidth: 1,
		strokeStyle: '#000',
		fillStyle: '#000',
		statusImg: -1,
		name: '',
		id:''
	};
	
	var opts = $.extend({}, defaults, options || {});
	
	this.context.strokeStyle = opts.strokeStyle;
	this.context.lineWidth = opts.lineWidth;
	this.context.strokeRect(opts.startX - opts.width/2, opts.startY, opts.width, opts.width);
	
	
	var lineHeight = 16;
	var textList = opts.name.split('&');
	this.context.font = 14
	this.context.fillStyle= opts.fillStyle;
	for(var i=0; i<textList.length; i++) {
		this.context.fillText(textList[i], opts.startX-20, opts.startY+opts.width/2-16+lineHeight);
		lineHeight += 16;
	}
	
	// 绘制图片
	if(opts.id=="DCDC1") {
		this.context.drawImage(nStatusImg.getdisChargeImg(opts.statusImg), opts.startX-38, opts.startY+opts.width/2-12);
	}else {
		this.context.drawImage(nStatusImg.getChargeImg(opts.statusImg), opts.startX-38, opts.startY+opts.width/2-12);
	}
	
	
	var DCDCInfor = {
		options: opts,
		type:'drawDCDC',
	};
	this.opts.push(DCDCInfor);
	
};

// 绘制整流器
EleCircle.prototype.drawRectifier = function (options) {
	var defaults = {
		startX: 0,
		startY: 0,
		endX:0,
		endY: 0,
		width: 25,
		height: 50,
		lineWidth: 1,
		strokeStyle: '#000',
		fillStyle: '#000',
		name: '',
		value: '0.0V',
		id:''
	};
	
	var opts = $.extend({}, defaults, options || {});
	this.context.drawImage(screenImg, opts.startX-30, opts.startY-3, 65, 105);
//	var step = 1/opts.height;
//	this.context.strokeStyle = opts.strokeStyle;
//	this.context.lineWidth = opts.lineWidth;
//	this.context.beginPath();
//  	this.context.moveTo(opts.startX+opts.width, opts.startY+opts.height); //从椭圆的左端点开始绘制
//  	
//	for (var i = 0; i < 2 * Math.PI; i += step) {
//		this.context.lineTo(opts.startX + opts.width * Math.cos(i), opts.startY+opts.height+opts.height * Math.sin(i));	
//	}
//	this.context.closePath();
//	this.context.stroke();
	
	// 设置整流器的文本和正负极
	var lineHeight = 16;
	var textList = opts.name.split('&');
	this.context.font = '14px Arial';
	this.context.fillStyle= opts.fillStyle;
	for(var i=0; i<textList.length; i++) {
		this.context.fillText(textList[i], opts.startX+35, opts.startY+20+lineHeight);
		lineHeight += 16;
	}
	this.context.font = '30px Arial';
	this.context.fillStyle="#FF0000";
	this.context.fillText('+', opts.startX-32, opts.startY);
	this.context.fillStyle="#000";
	this.context.fillText('-', opts.startX-32, opts.startY+opts.height*2.1);
	
	this.context.font = '20px Arial';
	this.context.fillStyle = "#FF0000";
	this.context.fillText(opts.value, opts.startX+10, opts.startY);
	
	var rectifierInfor = {
		options: opts,
		type:'drawRectifier',
	};
	this.opts.push(rectifierInfor); 
};

/**
 * 绘制电路图的开关 
 */
EleCircle.prototype.drawSwitchBtn = function(options) {
	var defaults = {
		startX: 0,
		startY: 0,
		direction: 'left',
		radius: 5,
		stats: 'on',
		lineWidth: 3,
		name: "",
		nPosition: 'down',
		txtLength: -1,
		fillStyle: '#000',
		strokeStyle: '#000',
		value: '0v',
		isShowValue2: false,
		value2: '触点异常',
		value2Color: '#FFD700',
		value2Length: -1,
		isBg: true,
		bgColor: '#FFFFFF',
		id: ''
	};
	var opts = $.extend({}, defaults, options || {});
	
	// 根据开关的类型和快关的状态设置value的值获取线包电压
	/*var lineVol = '线包电压:';
	if(opts.id == 'ko') {
		if(opts.stats == 'on') {
			lineVol =lineVol + '0V';
		}else {
			lineVol =lineVol + this.groupVol;
		}
	}else {
		if(opts.stats == 'on') {
			lineVol =lineVol + this.groupVol;
		}else {
			lineVol =lineVol + '0V';
		}
	}*/
	
	
	
	// 开关开始的圆圈的圆心坐标
	var startRadiusX = opts.startX;
	var startRadiusY = opts.startY;
	
	// 开关的线条
	var lineStartX = opts.startX;
	var lineStartY = opts.startY;
	var lineEndX = opts.startX;
	var lineEndY = opts.startY;
	
	// 开关结束的圆圈的圆心坐标
	var endRadiusX = opts.startX;
	var endRadiusY = opts.startY;
	var myWidth =  opts.startX;
	var myHeight = opts.startY;
	
	var txtStartX = opts.startX;
	var txtStartY = opts.startY;
	// 判断开关的方向
	switch(opts.direction) {
		case 'right':
			startRadiusX = opts.startX - opts.radius; // 设置圆心坐标
			
			lineStartX = startRadiusX - opts.radius; // 设置开关线的开始坐标
			
			
			lineEndX = opts.startX-opts.radius*10; // 设置开关线的结束坐标
			if(opts.stats == 'on') {
				lineEndY = opts.startY - opts.radius;
			}else {
				lineEndY = opts.startY - opts.radius*3;
			}
			
			endRadiusX = opts.startX-opts.radius*10;
			endRadiusY = opts.startY;
			myWidth = opts.radius*11;
			myHeight = opts.radius*2;
			
			txtStartX = opts.startX - 6*opts.radius;
			txtStartY = opts.startY + 8*opts.radius;
			break;
		case 'up':
			startRadiusY = opts.startY + opts.radius; // 设置圆心坐标
			
			lineStartY =opts.startY+opts.radius*10; // 设置开关线的开始坐标
			lineEndY = startRadiusY + opts.radius; // 设置开关线的结束坐标
			if(opts.stats == 'on') {
				lineEndX = opts.startX + opts.radius;
			}else {
				lineEndX = opts.startX + opts.radius*3;
			}
			
			endRadiusX = opts.startX;
			endRadiusY = opts.startY+opts.radius*10;
			
			myWidth = opts.radius*2;
			myHeight = opts.radius*11;
			txtStartY = opts.startY + 10*opts.radius;
			break;
		case 'down':
			startRadiusY = opts.startY + opts.radius; // 设置圆心坐标
			
			lineStartY = startRadiusY + opts.radius; // 设置开关线的开始坐标
			
			
			lineEndY = opts.startY+opts.radius*10; // 设置开关线的结束坐标
			if(opts.stats == 'on') {
				lineEndX = opts.startX + opts.radius;
			}else {
				lineEndX = opts.startX + opts.radius*3;
			}
			
			endRadiusX = opts.startX;
			endRadiusY = opts.startY+opts.radius*10;
			myWidth = opts.radius*2;
			myHeight = opts.radius*11;
			break;
		default:
			startRadiusX = opts.startX + opts.radius; // 设置圆心坐标
			
			lineStartX = startRadiusX + opts.radius; // 设置开关线的开始坐标
			
			
			lineEndX = opts.startX+opts.radius*10; // 设置开关线的结束坐标
			if(opts.stats == 'on') {
				lineEndY = opts.startY - opts.radius;
			}else {
				lineEndY = opts.startY - opts.radius*3;
			}
			
			endRadiusX = opts.startX+opts.radius*10;
			endRadiusY = opts.startY;
			myWidth = opts.radius*11;
			myHeight = opts.radius*2;
			break;
	}
	
	this.context.lineWidth = opts.lineWidth;
	this.context.fillStyle=opts.fillStyle;
	this.context.strokeStyle = opts.strokeStyle;
	this.context.beginPath();
	this.context.arc(startRadiusX, startRadiusY, opts.radius, 0, Math.PI*2, false);
	this.context.closePath();
	this.context.fill();
	
	this.context.beginPath();
	this.context.arc(startRadiusX, startRadiusY, opts.radius, 0, Math.PI*2, false);
	this.context.closePath();
	this.context.stroke();
	
	this.context.beginPath();
	this.context.moveTo(lineStartX, lineStartY);
	this.context.lineTo(lineEndX, lineEndY);
	this.context.closePath();
	this.context.stroke();
	
	
	this.context.beginPath();
	this.context.arc(endRadiusX, endRadiusY, opts.radius, 0, Math.PI*2, false);
	this.context.closePath();
	this.context.fill();
	
	this.context.beginPath();
	this.context.arc(endRadiusX, endRadiusY, opts.radius, 0, Math.PI*2, false);
	this.context.closePath();
	this.context.stroke();
	
	// 添加文本描述
	setEleCircleName(this.context, {
		startX: txtStartX,
		startY: txtStartY,
		txtLength: opts.txtLength,
		pos: opts.nPosition,
		name: opts.name
	});
	
	if(opts.isShowValue2) {
		setEleCircleName(this.context, {
			startX: txtStartX+5,
			startY: startRadiusY - 35,
			txtLength: opts.value2Length,
			fontSize: 12,
			pos: 'right',
			isBg: true,
			name: opts.value2,
			fillStyle: opts.value2Color
		});
	}
	
	
	// 设置value的值
	var valueTxtX = 0;
	var valueTxtY = 0;
	
	switch(opts.direction) {
		case 'right':
			valueTxtX = startRadiusX;
			valueTxtY = startRadiusY+ 25;
			break;
		default:
			valueTxtX = endRadiusX+5;
			valueTxtY = endRadiusY + 45;
			break;
	}
	
	// 绘制背景色
	/*this.context.beginPath();
	this.context.fillStyle = '#FFFFFF';
	var strWidth = getStringWidth(lineVol);
	this.context.rect(valueTxtX,valueTxtY-12,strWidth,14);
	this.context.fill();
	
	this.context.strokStyle = '#0000DD';
	this.context.fillStyle = '#0000DD';
	this.context.font = 'bold 12px Arial';
	this.context.fillText(lineVol, valueTxtX, valueTxtY);*/

	var switchBtnInfor = {
		options: opts,
		type:'drawSwitchBtn',
	};
	this.opts.push(switchBtnInfor);
};

// 绘制电池
EleCircle.prototype.drawEle = function(options) {
	var defaults = {
		startX: 0,
		startY: 0,
		name: '',
		direction: 'right',
		width: 10,
		scale: 6,	// 宽高比例1:10
		space: 3,	// 空白点补齐的宽度
		lineHeight: 16,
		fontSize: 14,
		value: '0V',
		fillStyle: {
			bgcolor: '#0066FF'
		},
		label: {
			show: true,
			color: '#000',
			position: 'top'
		},
	};
	this.drawEle.data = {};
	var opts = $.extend({}, defaults, options || {});
	opts.fillStyle = $.extend({}, defaults.fillStyle, options.fillStyle || {});	// 更新填充的颜色
	opts.label = $.extend({},defaults.label, options.label || {} );	// 更新label的样式
	//console.info(opts);
	var firstEle = {
		x: opts.startX,
		y: opts.startY,
		x1: opts.startX,
		y1: opts.startY
	};
	
	var spaceDot = [];
	
	var lastEle = {
		x: opts.startX,
		y: opts.startY,
		x1: opts.startX,
		y1: opts.startY
	}
	
	var width = opts.width;
	var height = opts.width*opts.scale;
	
	var width1 = opts.width;
	var height1 = opts.width*opts.scale/2;
	switch(opts.direction) {
		case 'left':
			// 第一个电池的正极起始坐标
			firstEle.x = opts.startX + (opts.space+5)*opts.width;
			firstEle.y = opts.startY - opts.width*opts.scale/2;
			
			firstEle.x1 = opts.startX + (opts.space+3.5)*opts.width;
			firstEle.y1 = opts.startY - opts.width*opts.scale/4;
			
			// 第二个电池的正极起始坐标
			lastEle.x = opts.startX + opts.width*2.5;
			lastEle.y = opts.startY - opts.width*opts.scale/2;
			
			lastEle.x1 = opts.startX + opts.width;
			lastEle.y1 = opts.startY - opts.width*opts.scale/4;
			
			for(var i=0; i<opts.space; i++) {
				var dot = {};
				dot.x = opts.startX + (2.5*opts.width + i*opts.width+0.5*opts.width);
				dot.y = opts.startY - opts.width/2;
				spaceDot.push(dot);
			}
			
			break;
		case 'right':
			// 第一个电池的正极起始坐标
			firstEle.x = opts.startX - (opts.space+5)*opts.width;
			firstEle.y = opts.startY - opts.width*opts.scale/2;
			
			firstEle.x1 = opts.startX - (opts.space+3.5)*opts.width;
			firstEle.y1 = opts.startY - opts.width*opts.scale/4;
			
			// 第二个电池的正极起始坐标
			lastEle.x = opts.startX - opts.width*2.5;
			lastEle.y = opts.startY - opts.width*opts.scale/2;
			
			lastEle.x1 = opts.startX - opts.width;
			lastEle.y1 = opts.startY - opts.width*opts.scale/4;
			
			for(var i=0; i<opts.space; i++) {
				var dot = {};
				dot.x = opts.startX - (2.5*opts.width + i*opts.width+0.5*opts.width);
				dot.y = opts.startY - opts.width/2;
				
				spaceDot.push(dot);
			}
			break;
		default:
			// 第一个电池的正极起始坐标
			firstEle.x = opts.startX - opts.width*opts.scale/2;
			firstEle.y = opts.startY;
			
			firstEle.x1 = opts.startX - opts.width*opts.scale/4;
			firstEle.y1 = opts.startY + opts.width*1.5;
			
			// 第二个电池的正极起始坐标
			lastEle.x = opts.startX - opts.width*opts.scale/2;
			lastEle.y = opts.startY + (opts.space+2.5)*opts.width;
			
			lastEle.x1 = opts.startX - opts.width*opts.scale/4;
			lastEle.y1 = opts.startY + (opts.space+4)*opts.width;
			
			for(var i=0; i<opts.space; i++) {
				var dot = {};
				dot.x = opts.startX - opts.width/2;
				dot.y = opts.startY + (2.5*opts.width + i*opts.width+0.5*opts.width);
				
				spaceDot.push(dot);
			}
			
			width = opts.width*opts.scale;
			height = opts.width;
			width1 = opts.width*opts.scale/2;
			height1 = opts.width;
			break;
	}
	this.context.fillStyle = opts.fillStyle.bgcolor;
	this.context.drawImage(eleGroupImg, firstEle.x, firstEle.y);
//	this.context.fillRect(firstEle.x, firstEle.y, width, height);
//	this.context.fillRect(firstEle.x1, firstEle.y1, width1, height1);
	
	for(var i=0; i<spaceDot.length; i++) {
		this.context.fillRect(spaceDot[i].x, spaceDot[i].y, opts.width/2, opts.width/2);
	}
	
	this.context.drawImage(eleGroupImg, lastEle.x, lastEle.y);
	//this.context.fillRect(lastEle.x, lastEle.y, width, height);
	//this.context.fillRect(lastEle.x1, lastEle.y1, width1, height1);
	
	var txtStartX = firstEle.x+opts.width*opts.scale +5;
	var txtStartY = firstEle.y+(2.5+opts.scale/2)*opts.width - 32;
	
	var txtLists = opts.name.split('&');
	for(var i=0; i<txtLists.length; i++) {
		this.context.fillText(txtLists[i], txtStartX, txtStartY+i*opts.lineHeight);
	}
	
	this.context.font = 'bold 14px Arial';
	this.context.fillText(opts.value, opts.startX+5, opts.startY-5);
	
	
	var eleInfor = {
		options: opts,
		type:'drawEle',
	};
	this.opts.push(eleInfor);
};

// 绘制用电负载
EleCircle.prototype.drawEleLoad = function(options) {
	var defaults = {
		startX: 0,
		startY: 0,
		width: 80,
		height: 80,
		lineWidth: 1,
		fillStyle: '#000',
		strokeStyle: '#000',
		name: ''
	};
	var opts = $.extend({}, defaults, options || {});
	this.context.drawImage(loadImg, opts.startX-30, opts.startY-3, 60, 105);
	
//	this.context.lineWidth = opts.lineWidth;
//	this.context.strokeStyle = opts.strokeStyle;
//	this.context.strokeRect(opts.startX-opts.width/2, opts.startY, opts.width, opts.height);
//	this.context.font = '14px Arial';
//	this.context.fillText(opts.name, opts.startX-24, opts.startY+opts.height/2);
	// 设置整流器的文本和正负极
	var lineHeight = 16;
	var textList = opts.name.split('&');
	this.context.font = '14px Arial';
	this.context.fillStyle= opts.fillStyle;
	for(var i=0; i<textList.length; i++) {
		this.context.fillText(textList[i], opts.startX+35, opts.startY+20+lineHeight);
		lineHeight += 16;
	}
	
	var eleLoadInfor = {
		options: opts,
		type:'drawEleLoad',
	}
	this.opts.push(eleLoadInfor);
};

EleCircle.prototype.drawDiode = function (options) {
	var defaults = {
		startX: 0,
		startY: 0,
		height: 20,
		lineWidth: 1,
		fillStyle: '#000',
		strokeStyle: '#000',
		name: '',
		id: '',
		isShowValue: false,
		value: '异常',
		valueColor: '#FF0000'
	};
	var opts = $.extend({}, defaults, options || {});
	
	this.context.lineWidth = opts.lineWidth;
	this.context.strokeStyle = opts.strokeStyle;
	this.context.fillStyle = opts.fillStyle;
	
	this.context.beginPath();
	this.context.moveTo(opts.startX, opts.startY);
	this.context.lineTo(opts.startX, opts.startY+opts.height);
	this.context.closePath();
	this.context.stroke();
	
	this.context.beginPath();
	this.context.moveTo(opts.startX-opts.height/2, opts.startY+opts.height);
	this.context.lineTo(opts.startX+opts.height/2, opts.startY+opts.height);
	this.context.closePath();
	this.context.stroke();
	
	this.context.beginPath();
	this.context.moveTo(opts.startX, opts.startY+opts.height);
	this.context.lineTo(opts.startX-Math.tan(Math.PI/6)*opts.height, opts.startY+opts.height*2);
	this.context.lineTo(opts.startX+Math.tan(Math.PI/6)*opts.height, opts.startY+opts.height*2);
	this.context.closePath();
	this.context.fill();
	
	this.context.beginPath();
	this.context.moveTo(opts.startX, opts.startY+opts.height*2);
	this.context.lineTo(opts.startX, opts.startY+opts.height*3);
	this.context.closePath();
	this.context.stroke();
	
	setEleCircleName(this.context, {
		startX: opts.startX+8,
		startY: opts.startY+opts.height*2.6,
		name:'D1',
		pos: 'right',
		txtLength:-1
	});
	
	if(opts.isShowValue) {
		setEleCircleName(this.context, {
			startX: opts.startX+10,
			startY: opts.startY+35,
			name:opts.value,
			fontSize: 12,
			isBg:true,
			fontWeight: 'bold',
			lineWidth: 4,
			fillStyle: opts.valueColor,
			pos: 'right',
			txtLength:-1
		});
	}
	
	
	
	var diodeInfor = {
		options: opts,
		type:'drawDiode',
	}
	this.opts.push(diodeInfor);
};

// 绘制虚线
EleCircle.prototype.drawDotLine = function (options){
	var defaults = {
		startX:100,
		startY: 100,
		endX: 0,
		endY: 0,
		dotWidth: 2,
		whiteWidth: 5,
		lineWidth: 1,
		direction: 'left',
		strokeStyle: '#000',
		name: '',
	};
	
	var opts = $.extend({}, defaults, options||{});
	
	this.context.lineWidth = opts.lineWidth;
	this.context.strokeStyle = opts.strokeStyle;
	this.context.setLineDash([opts.dotWidth, opts.whiteWidth]);
	
	this.context.beginPath();
	this.context.moveTo(opts.startX, opts.startY);
	this.context.lineTo(opts.endX, opts.endY);
	this.context.closePath();
	this.context.stroke();
	
	this.context.setLineDash([]);	// 恢复实线
	
	if(opts.name.length > 0) {
		this.context.beginPath();
		this.context.fillStyle = '#FFFFFF';
		this.context.rect(opts.startX-20,opts.startY+16*2+156, 30,32);
		this.context.fill();
	}
	
	
	var textList = opts.name.split('&');
	this.context.fillStyle = opts.strokeStyle;
	var lineHeight = 16;
	for(var i=0; i<textList.length; i++) {
		this.context.fillText(textList[i], opts.startX-20, opts.startY+lineHeight*i+200);
	}
	
	
	
	
	
	// 存储内容
	var dotLineInfor = {
		options: opts,
		type:'drawDotLine',
	};
	this.opts.push(dotLineInfor);
	
	
};

// 绘制电流
EleCircle.prototype.drawCurrent = function(options) {
	return;
	var defaults = {
		points:[],
		current: {
			start: 0,
			end: 1,
			point:[]
		},
		dotWidth: 14,
		whiteWidth: 12,
		lineWidth: 4,
		clockwise: 1,	// 1顺时针， 0逆时针
		direction: 'v',  // points坐标的第一条线的方向
		step: 8,
		isCanMove: 1,
		strokeStyle: '#533F03',
		name: '',
		isChange: 0,
		id: ''
	};
	
	var opts = $.extend({}, defaults, options||{});
	
	// 如果数据改变就修改电流的框图的样式
	if(opts.isChange) {
		opts.current = {
			start: 0,
			end: 1,
			point:[]
		};
		opts.isChange = 0;
	}
	
	this.context.lineWidth = opts.lineWidth;
	this.context.strokeStyle = opts.strokeStyle;
	this.context.setLineDash([opts.dotWidth, opts.whiteWidth]);
	this.context.beginPath();
	if(opts.points.length >= 2) {
		this.context.moveTo(opts.points[0][0], opts.points[0][1]);
		for(var i=1; i<opts.points.length; i++) {
			this.context.lineTo(opts.points[i][0], opts.points[i][1]);
		}
	}
	this.context.closePath();
	this.context.stroke();
	
	this.context.setLineDash([]);	// 恢复实线
	// 设置临时的对象
	var temp = {},
		current = opts.current;
	if(current.point.length == 0) {
		current.point = getCenterPoint(opts.points[current.start], opts.points[current.end]);
	}
	
	
	var currentDirect = 'right';
	if(opts.isCanMove == 1) {
		// 判断当前位置所在的线是横线还是竖线
		if(opts.points[current.start][0] == opts.points[current.end][0]) { // x轴相等说明是竖线
			// 判断当前线是在左还是再右
			if(opts.points[current.start][1] < opts.points[current.end][1]) {	// 该竖线在右边
				// 根据电流是顺时针还是逆时针对当前位置进行计算
				if(opts.clockwise) {
					current.point[1] = current.point[1] + opts.step;
					currentDirect = 'down';
				}else {
					current.point[1] = current.point[1] - opts.step;
					currentDirect = 'up';
				}
			}else {
				// 根据电流是顺时针还是逆时针对当前位置进行计算
				if(opts.clockwise) {
					current.point[1] = current.point[1] - opts.step;
					currentDirect = 'up';
				}else {
					current.point[1] = current.point[1] + opts.step;
					currentDirect = 'down';
				}
			}
		}else {
			// 判断当前横线是在上方还是再下方
			if(opts.points[current.start][0] < opts.points[current.end][0]) {	// 该横线在上方
				// 根据电流是顺时针还是逆时针对当前位置进行计算
				if(opts.clockwise) {
					current.point[0] = current.point[0] + opts.step;
					currentDirect = 'left';
				}else {
					current.point[0] = current.point[0] - opts.step;
					currentDirect = 'right';
				}
			}else{
				// 根据电流是顺时针还是逆时针对当前位置进行计算
				if(opts.clockwise) {
					current.point[0] = current.point[0] - opts.step;
					currentDirect = 'right';
				}else {
					current.point[0] = current.point[0] + opts.step;
					currentDirect = 'left';
				}
			}
		}
		
		var isOnLine = getPointState(opts.points[current.start], opts.points[current.end], current.point);
		// 根据当前点的位置查询是否需要进入下面一条线
		if(!isOnLine) {
			// 判断是逆时针还是顺时针处理进入拐点位置
			if(opts.clockwise) {
				current.start = current.end;
				current.end = (current.end == (opts.points.length-1))?0:current.end+1;
				current.point[0] = opts.points[current.start][0];
				current.point[1] = opts.points[current.start][1];
			}else {
				current.end = current.start;
				current.start = (current.start == 0)?opts.points.length-1: current.start-1;
				current.point[0] = opts.points[current.end][0];
				current.point[1] = opts.points[current.end][1];
			}
			
		}
	}
	
	temp.startX = current.point[0];
	temp.startY = current.point[1];
	temp.direction = currentDirect; // 设置箭头的方向
	temp.isChange = !isOnLine;
	temp.fillStyle = opts.fillStyle;
	// 根据points的坐标集合生成自己想要的特定的集合
	this.drawCurrentDirect(temp);
	
	var centerPt = getCenterPoint(opts.points[0], opts.points[1]);
	
	// 绘制电流描述信息
	setEleCircleName(this.context, {
		startX:centerPt[0],
		startY:centerPt[1],
		pos: 'up',
		name: opts.name,
		fillStyle: opts.txtFillStyle,
	});
	
	// 存储内容
	var currentLineInfor = {
		options: opts,
		type:'drawCurrent',
	}
	this.opts.push(currentLineInfor);
};


/*
 * 生成电流方向指示器
 * @param Array point 点的坐标轴
 * @param string 所在线 是横线（h）还是竖线（v）
 * @param string 电流是顺时针（）还是
 */
EleCircle.prototype.drawCurrentDirect = function (options) {
	return;
	var defaults = {
		startX: 0,
		startY: 0,
		lineWidth: 1,
		width: 60,
		isChange: false,	// 该点是否在拐点
		direction: 'left',	// 箭头的方向
		strokeStyle: '#000',
		fillStyle: '#533F03'
	};
	
	var opts = $.extend({}, defaults, options || {});
	this.context.lineWidth = opts.lineWidth;
	this.context.strokeStyle = opts.strokeStyle;
	this.context.fillStyle = opts.fillStyle;
	
	var triangle = [];
	
	
	switch(opts.direction) {
		case 'right':
			if(opts.isChange) {
				opts.startX - opts.width;	
			}
			var dot1 = [opts.startX, opts.startY];
			var dot2 = [opts.startX+opts.width/3, opts.startY+opts.width/3*Math.tan(Math.PI/6)];
			var dot3 = [opts.startX+opts.width/5, opts.startY];
			var dot4 = [opts.startX+opts.width/3, opts.startY-opts.width/3*Math.tan(Math.PI/6)];
			triangle.push(dot1);
			triangle.push(dot2);
			triangle.push(dot3);
			triangle.push(dot4);
			break;
		case 'down':
			if(opts.isChange) {
				opts.startY + opts.width;	
			}
			var dot1 = [opts.startX, opts.startY];
			var dot2 = [opts.startX-opts.width/3*Math.tan(Math.PI/6), opts.startY-opts.width/3];
			var dot3 = [opts.startX, opts.startY-opts.width/5];
			var dot4 = [opts.startX+opts.width/3*Math.tan(Math.PI/6), opts.startY-opts.width/3];
			triangle.push(dot1);
			triangle.push(dot2);
			triangle.push(dot3);
			triangle.push(dot4);
			break;
		case 'up':
			if(opts.isChange) {
				opts.startY - opts.width;	
			}
			var dot1 = [opts.startX, opts.startY];
			var dot2 = [opts.startX-opts.width/3*Math.tan(Math.PI/6), opts.startY+opts.width/3];
			var dot3 = [opts.startX, opts.startY+opts.width/5];
			var dot4 = [opts.startX+opts.width/3*Math.tan(Math.PI/6), opts.startY+opts.width/3];
			triangle.push(dot1);
			triangle.push(dot2);
			triangle.push(dot3);
			triangle.push(dot4);
			break;
		default:
			if(opts.isChange) {
				opts.startX + opts.width;	
			}
			var dot1 = [opts.startX, opts.startY];
			var dot2 = [opts.startX-opts.width/3, opts.startY+opts.width/3*Math.tan(Math.PI/6)];
			var dot3 = [opts.startX-opts.width/5, opts.startY];
			var dot4 = [opts.startX-opts.width/3, opts.startY-opts.width/3*Math.tan(Math.PI/6)];
			triangle.push(dot1);
			triangle.push(dot2);
			triangle.push(dot3);	
			triangle.push(dot4);	
			break;
	}
	
	this.context.beginPath();
	this.context.moveTo(triangle[0][0], triangle[0][1]);
	for(var i=1;i<triangle.length; i++) {
		this.context.lineTo(triangle[i][0], triangle[i][1]);
	}
	this.context.closePath();
	this.context.fill();
	
	
	this.context.beginPath();
	this.context.moveTo(triangle[0][0], triangle[0][1]);
	for(var i=1;i<triangle.length; i++) {
		this.context.lineTo(triangle[i][0], triangle[i][1]);
	}
	this.context.closePath();
	this.context.stroke();
}

// 绘制文本
EleCircle.prototype.drawText = function(options) {
	var defaluts = {
		startX: 0,
		startY: 0,
		lineWidth: 4,
		fontSize: 14,
		fontWeight: '',
		strokeStyle: '#000',
		fillStyle: '#000',
		name:'',
		id: '',
	};
	
	var opts = $.extend({}, defaluts, options || {});
	
	var textStartX = opts.startX;
	var textStartY = opts.startY;
	var txtLength = opts.name.length*opts.fontSize;
	textStartX = textStartX - txtLength/4;
	
	// 绘制背景色
	this.context.beginPath();
	this.context.fillStyle = '#FFFFFF';
	var strWidth = getStringWidth(opts.name);
	this.context.rect(textStartX,textStartY-opts.fontSize,strWidth,opts.fontSize);
	this.context.fill();
	
	this.context.lineWidth = opts.lineWidth;
	this.context.strokeStyle = opts.strokeStyle;
	this.context.fillStyle = opts.fillStyle;
	this.context.font = opts.fontSize+'px Arial';
	this.context.font += ' '+opts.fontWeight;
	
	
	
	this.context.fillText(opts.name, textStartX, textStartY);
	
	// 存储内容
	var txtInfor = {
		options: opts,
		type:'drawText',
	}
	this.opts.push(txtInfor);
}

// 绘制图片
EleCircle.prototype.drawImg = function(options) {
	var defaluts = {
		img: '',
		startX: 0,
		startY: 0,
		width: 30,
		height: 30,
		lineWidth: 4,
		fontSize: 14,
		fontWeight: '',
		strokeStyle: '#000',
		fillStyle: '#000',
		isShow: true,
		name:'',
		id: '',
	};
	
	var opts = $.extend({}, defaluts, options || {});
	
	if(opts.img != '' && opts.isShow) {
		this.context.drawImage(opts.img, opts.startX, opts.startY, opts.width, opts.height);
		
		this.context.lineWidth = opts.lineWidth;
		this.context.strokeStyle = opts.strokeStyle;
		this.context.fillStyle = opts.fillStyle;
		this.context.font = opts.fontSize+'px Arial';
		this.context.fillText(opts.name, opts.startX+30, opts.startY+25);
	}
	
	// 存储内容
	var txtInfor = {
		options: opts,
		type:'drawImg',
	};
	this.opts.push(txtInfor);
	
	
};

// 重新绘制图
EleCircle.prototype.redraw =function() {
	this.context.clearRect(0, 0, this.canvas.width, this.canvas.height);
	var opts = [];
	// 循环的方式将this.opts的值给临时变量opts避免引用传递
	for(var i=0; i<this.opts.length; i++) {
		var temp = $.extend({}, this.opts[i]);
		opts.push(temp);
	}
	
	this.opts = [];
	
	for(var i=0; i<opts.length; i++) {
		this[opts[i].type](opts[i].options);
	}
};

// 开启一直监测电池状态内容
EleCircle.prototype.start = function() {
	this.stop();
	this.redraw();
	this.timer = setInterval(function() {
		this.redraw();
	}.bind(this), 100);
}

// 关闭电池状态监控
EleCircle.prototype.stop = function() {
	clearInterval(this.timer);
}


// 隐藏电路拓扑图
EleCircle.prototype.hide = function() {
	var $canvas  = $(this.canvas);
	$canvas.parent().hide();
	this.stop();
}

// 显示电路拓扑图
EleCircle.prototype.show = function() {
	var $canvas  = $(this.canvas);
	$canvas.parent().show();
	this.start();
}

//绘制点
EleCircle.prototype.drawRect = function (options) {
    var defaults = {
        startX: 0,
        startY: 0,
        moveLine:[],
        fillColor: '#FF0000',
        index: 0,
        init: true,
        isList: false,
        step: 4
    };

    var opts = $.extend({}, defaults, options);
    var cxt = this.context;
    
    if(opts.init) {
        opts.init = false;
        opts.index = 0;
        var _startP = opts.moveLine[0].startP
        opts.startX = _startP[0];
        opts.startY = _startP[1];
    }

    // 获取起始点和结束点坐标
    var startP = opts.moveLine[opts.index].startP;
    var endP = opts.moveLine[opts.index].endP;

    // 绘制亮点
    cxt.fillStyle = opts.fillColor;
    cxt.beginPath();
    cxt.arc(opts.startX, opts.startY, 6, 0, Math.PI*2, true);
    cxt.closePath();
    cxt.fill();
    

    // 横向线条上
    if(startP[1] == endP[1]) {
        // 开始点在左侧
        if(startP[0] <endP[0]) {
            opts.startX += opts.step;
            
            // 超出就换下一组并切换开始点
            if(opts.startX > endP[0]) {
                // 不是最后一组点
                if(opts.index != (opts.moveLine.length-1)) {
                    opts.index += 1;
                }else {
                    opts.index = 0; 
                }
                opts.startX = opts.moveLine[opts.index].startP[0];
                opts.startY = opts.moveLine[opts.index].startP[1];
            }
        }else {
            opts.startX -= opts.step; 

            // 超出就换下一组并切换开始点
            if(opts.startX < endP[0]) {
                // 不是最后一组点
                if(opts.index != (opts.moveLine.length-1)) {
                    opts.index += 1;
                }else {
                    opts.index = 0; 
                }
                opts.startX = opts.moveLine[opts.index].startP[0];
                opts.startY = opts.moveLine[opts.index].startP[1];
            }
        }
    }else {
        // 开始点在上方
        if(startP[1] <endP[1]) {
            opts.startY += opts.step;

            // 超出就换下一组并切换开始点
            if(opts.startY > endP[1]) {
                // 不是最后一组点
                if(opts.index != (opts.moveLine.length-1)) {
                    opts.index += 1;
                }else {
                    opts.index = 0;
                }

                opts.startX = opts.moveLine[opts.index].startP[0];
                opts.startY = opts.moveLine[opts.index].startP[1];
            }
        }else {
            opts.startY -= opts.step;
            // 超出就换下一组并切换开始点
            if(opts.startY < endP[1]) {
                // 不是最后一组点
                if(opts.index != (opts.moveLine.length-1)) {
                    opts.index += 1;
                }else {
                    opts.index = 0;
                }

                opts.startX = opts.moveLine[opts.index].startP[0];
                opts.startY = opts.moveLine[opts.index].startP[1];
            }
        }
    }
    
    // 存储内容
    var _tmp = {
        type: 'drawRect',
        options: opts
    };
    this.opts.push(_tmp);
};

//绘制多点
EleCircle.prototype.drawRectList = function(lists) {
    // 移除旧的通过lists添加的点
    this._delRectList();
    
    // 遍历lists重新绘制亮点
    for(var i=0; i<lists.length; i++) {
        lists[i].isList = true;
        this.drawRect(lists[i]);
    }
};

// 删除通过列表添加的电流的点
EleCircle.prototype._delRectList = function() {
	for(var i=0;i<this.opts.length; i++) {
        if(this.opts[i].event = 'drawRect') {
            if(this.opts[i].options.isList) {
                this.opts.splice(i, 1);
                this._delRectList();
            }
        }
    }
}

// 设置文本的值
function setEleCircleName(context, options) {
	// startX和StartY是被描述无的中心
	var defaults = {
		startX: 0,
		startY: 0,
		name: '',
		width: 0,
		height: 0,
		pos: 'left',
		lineHeight: 16,
		lineWidth: 1,
		fontSize: 14,
		txtLength: -1,
		fillStyle: '#000',
		isBg:false,
		bgColor: '#FFFFFF',
		fontWeight: ''
	}
	
	var opts = $.extend({}, defaults, options || {});
	
	// 判断一行的字数
	var tLength = (opts.txtLength ==-1)?opts.name.length:
					(opts.txtLength>opts.name.length)?opts.name.length:opts.txtLength;
	
	// 分割name字符串
	var reg= new RegExp(".{"+tLength+"}", 'g');
	var rs=opts.name.match(reg);
	if(opts.name.substring(rs.join('').length).length>0) {
		rs.push(opts.name.substring(rs.join('').length));
	}
	
	var txtWidth = opts.fontSize*tLength;
	var txtHeight = opts.lineHeight*rs.length;
	// 文本开始描绘的位置
	var txtX = opts.startX;
	var txtY = opts.startY;
	switch(opts.pos) {
		case 'left':
			textX = opts.startX - txtWidth;
			textY = opts.startY - txtHeight/2;
			break;
		case 'up':
			textX = opts.startX - txtWidth/2;
			textY = opts.startY - txtHeight-5;
			break;
		case 'down':
			textX = opts.startX - txtWidth/2;
			textY = opts.startY - txtHeight+5;
			break;
		default:
			textX = opts.startX +5;
			textY = opts.startY - txtHeight/2;
			break;
	}
	if(opts.isBg) {
		// 绘制背景色
		context.beginPath();
		context.fillStyle = '#FFFFFF';
		var strWidth = getStringWidth(rs[0]);
		context.rect(textX,textY-12,strWidth,12);
		context.fill();
	}
	
	
	
	context.lineWidth = opts.lineWidth;
	context.font = opts.fontSize+'px Arial';
	context.font += " "+opts.fontWeight;
	context.fillStyle= opts.fillStyle;
	for(var i=0; i<rs.length;i++) {
		context.fillText(rs[i], textX, textY+opts.lineHeight*i);
	}
	
	
}

// 根据两个坐标轴获取其中心点
function getCenterPoint(point1, point2) {
	var rs = [];
	var x = (point1[0]+point2[0])/2;
	var y = (point1[1]+point2[1])/2;
	rs.push(x);
	rs.push(y);
	return rs;
}

// 获取当前点是否在某条线段上
function getPointState(start, end, point) {
	var rs = true,
		max = 0,
		min = 0;
	if(start[0] == end[0]) {
		max = (start[1] > end[1])?start[1]:end[1];
		min = (start[1] < end[1])?start[1]:end[1];
		rs = (point[1]<=max && point[1]>=min)? true: false;
	}else {
		max = (start[0] > end[0])?start[0]:end[0];
		min = (start[0] < end[0])?start[0]:end[0];
		rs = (point[0]<=max && point[0]>=min)? true: false;
	}
	return rs;
}

// 通过对象id获取对象然后修改对应的属性值的属性值对对象进行修改
function changeEleCircleOpt(eleCircle, id, options) {
	// 遍历eleCircle对象的集合根据id的值修改内容
	for(var i=0; i<eleCircle.opts.length; i++) {
		if(eleCircle.opts[i].options.id == id) {
			eleCircle.opts[i].options = $.extend({}, eleCircle.opts[i].options, options || {});
		}
	}
	//eleCircle.redraw();
}

// 更改电路图电流的状态
function changeCurrentState(values) {
	//console.info(changeCurrentState.isChange);
	var member = [
	    // 浮充			放电测试			稳流充电			直连充电 		设备未连接        kd    停电放电
		'floatCharge', 'discharge', 'constCharge', 'directCharge', 'unLink', 'kd', 'powerCutDis'
	];
	
	var state = member[values];
	
	if(changeCurrentState.isChange == 1) {
		var opts = eleCircle.opts;
		var currentObj = {
			floatCharge:{
				points:[
					[320, 40], [540, 40],[540, 520],
					[430, 520], [430, 360],[320,360]
				],
				fillStyle: '#533F03',
				isCanMove: 1,
				clockwise: 0,
				txtFillStyle: '#000',
				name: '设备浮充状态电流方向'
			},
			discharge: {
				points:[
					[80, 40], [770, 40],[770, 520],
					[430, 520], [430, 360],[80,360]
				],
				fillStyle: '#FF0000',
				isCanMove: 1,
				clockwise: 1,
				txtFillStyle: '#000',
				name: '设备放电测试时电流方向'
			},
			constCharge: {
				points:[
					[245, 40], [570, 40],[570, 520],
					[430, 520], [430, 360],[245,360]
				],
				fillStyle: '#533F03',
				isCanMove: 1,
				clockwise: 0,
				txtFillStyle: '#000',
				name: '设备稳流充电时电流方向'
			},
			directCharge: {
				points:[
					[320, 40], [540, 40],[540, 520],
					[430, 520], [430, 360],[320,360]
				],
				fillStyle: '#533F03',
				isCanMove: 1,
				clockwise: 0,
				txtFillStyle: '#000',
				name: '设备直连充电时电流方向'
			},
			unLink: {
				points:[
					[320, 40], [540, 40],[540, 520],
					[430, 520], [430, 360],[320,360]
				],
				fillStyle: '#FF0000',
				isCanMove: 0,
				clockwise: 0,
				txtFillStyle: '#FF0000',
				name: '设备未连接'
			},
			kd: {
				name: 'K1/D1测试'
			},
			powerCutDis: {
				points:[
					[320, 40], [540, 40],[540, 520],
					[430, 520], [430, 360],[320,360]
				],
				fillStyle: '#FF0000',
				isCanMove: 1,
				clockwise: 1,
				txtFillStyle: '#000',
				name: '设备停电放电'
			}
		};
		
		var currentDotLists = {
		    floatCharge: [	// 浮充电流
				{
					fillColor:'#3d90df',
					 moveLine:[{
						 startP:[480, 440],
						 endP: [480, 460]
					 },{
						 startP:[480, 460],
						 endP:[586, 460] 
					 }]
				},
				{
					fillColor:'#3d90df',
					 moveLine:[{
						 startP:[586, 460],
						 endP:[526, 290]
					 }]
				},
				{
					fillColor:'#3d90df',
					 moveLine: [{
						 startP:[586, 190],
						 endP: [586, 80]
					 }]
				},
				{
					fillColor:'#3d90df',
					 moveLine: [{
						 startP:[586, 80],
						 endP: [456, 80]
					 }]
				},
				{
					fillColor:'#3d90df',
					 moveLine: [{
						 startP:[440, 80],
						 endP: [380, 80]
					 },{
						 startP:[380, 80],
						 endP: [380, 170]
					 }]
				},
				{
					fillColor:'#3d90df',
					 moveLine: [{
						 startP:[380, 226],
						 endP: [380, 320]
					 },{
						 startP:[380, 320],
						 endP: [440, 320] 
					 }]
				},
				{
					fillColor:'#3d90df',
					 moveLine: [{
						 startP:[456, 320],
						 endP: [480, 320]
					 },{
						 startP:[480, 320],
						 endP:[480, 360]
					 }]
				},
				{
					fillColor:'#3d90df',
					moveLine:[{
						startP:[586, 80],
						endP: [740, 80]
					},{
						startP:[740, 80],
						endP: [740, 190]
					}]
				},
				{
					fillColor:'#3d90df',
					moveLine: [{
						startP:[740, 290],
						endP: [740, 460]
					}]
				},
				{
					fillColor:'#3d90df',
					moveLine: [{
						startP:[740, 460],
						endP: [586, 460]
					}]
				}
		    ],
		    discharge:[
		    	{
		    		fillColor:'#FF0000',
			    	 moveLine: [{
			    		 startP:[480, 360],
		        		 endP:[480, 320]
			    	 },{
			    		 startP:[480, 320],
		        		 endP:[456, 320]
			    	 }]
			     },
			     {
			    	 fillColor:'#FF0000',
			    	 moveLine: [{
			    		 startP: [440, 320],
			    		 endP: [305, 320]
			    	 }]
			     },
			     {
			    	 fillColor:'#FF0000',
			    	 moveLine: [{
			    		 startP: [250, 320],
			    		 endP: [120, 320]
			    	 }]
			     },
			     {
			    	 fillColor:'#FF0000',
			    	 moveLine: [{
			    		 startP: [120, 320],
			    		 endP: [120, 250]
			    	 }]
			     },
			     {
			    	 fillColor:'#FF0000',
			    	 moveLine: [{
			    		 startP: [120, 150],
			    		 endP: [120, 80]
			    	 }]
			     },
			     {
			    	 fillColor:'#FF0000',
			    	 moveLine: [{
			    		 startP: [120, 80],
			    		 endP: [220, 80]
			    	 }]
			     },
			     {
			    	 fillColor:'#FF0000',
			    	 moveLine: [{
			    		 startP: [220, 80],
			    		 endP: [440, 80]
			    	 }]
			     },
			     {
			    	 fillColor:'#FF0000',
			    	 moveLine: [{
			    		 startP: [456, 80],
			    		 endP: [740, 80]
			    	 }]
			     },
			     {
			    	 fillColor:'#FF0000',
			    	 moveLine: [{
			    		 startP: [740, 80],
			    		 endP: [740, 190]
			    	 }]
			     },
			     {
			    	 fillColor:'#FF0000',
			    	 moveLine: [{
			    		 startP: [740, 290],
			    		 endP: [740, 460]
			    	 }]
			     },
			     {
			    	 fillColor:'#FF0000',
			    	 moveLine: [{
			    		 startP: [740, 460],
			    		 endP: [586, 460]
			    	 }]
			     },
			     {
			    	 fillColor:'#FF0000',
			    	 moveLine: [{
			    		 startP:[586, 460],
			    		 endP:[480, 460]
			    	 },{
			    		 startP:[480, 460],
			    		 endP:[480, 440]
			    	 }]
			     }
		    ],
		    directCharge: [
				{
					fillColor:'#3d90df',
					 moveLine:[{
						 startP:[480, 440],
						 endP: [480, 460]
					 },{
						 startP:[480, 460],
						 endP:[586, 460] 
					 }]
				},
				{
					fillColor:'#3d90df',
					 moveLine:[{
						 startP:[586, 460],
						 endP:[526, 290]
					 }]
				},
				{
					fillColor:'#3d90df',
					 moveLine: [{
						 startP:[586, 190],
						 endP: [586, 80]
					 }]
				},
				{
					fillColor:'#3d90df',
					 moveLine: [{
						 startP:[586, 80],
						 endP: [456, 80]
					 }]
				},
				{
					fillColor:'#3d90df',
					 moveLine: [{
						 startP:[440, 80],
						 endP: [380, 80]
					 },{
						 startP:[380, 80],
						 endP: [380, 170]
					 }]
				},
				{
					fillColor:'#3d90df',
					 moveLine: [{
						 startP:[380, 226],
						 endP: [380, 320]
					 },{
						 startP:[380, 320],
						 endP: [440, 320] 
					 }]
				},
				{
					fillColor:'#3d90df',
					 moveLine: [{
						 startP:[456, 320],
						 endP: [480, 320]
					 },{
						 startP:[480, 320],
						 endP:[480, 360]
					 }]
				},
				{
					fillColor:'#3d90df',
					moveLine:[{
						startP:[586, 80],
						endP: [740, 80]
					},{
						startP:[740, 80],
						endP: [740, 190]
					}]
				},
				{
					fillColor:'#3d90df',
					moveLine: [{
						startP:[740, 290],
						endP: [740, 460]
					}]
				},
				{
					fillColor:'#3d90df',
					moveLine: [{
						startP:[740, 460],
						endP: [586, 460]
					}]
				}
		    ],
		    constCharge: [
				{
					fillColor:'#3d90df',
					 moveLine:[{
						 startP:[480, 440],
						 endP: [480, 460]
					 },{
						 startP:[480, 460],
						 endP:[586, 460] 
					 }]
				},
				{
					fillColor:'#3d90df',
				  	 moveLine:[{
				  		 startP:[586, 460],
				  		 endP:[526, 290]
				  	 }]
				},
				{
					fillColor:'#3d90df',
				  	 moveLine: [{
				  		 startP:[586, 190],
				  		 endP: [586, 80]
				  	 }]
				},
				{
					fillColor:'#3d90df',
				  	 moveLine: [{
				  		 startP:[586, 80],
				  		 endP: [456, 80]
				  	 }]
				},
				{
					fillColor:'#3d90df',
				  	 moveLine: [{
				  		 startP:[440, 80],
				  		 endP: [380, 80]
				  	 }]
				},
				{
					fillColor:'#3d90df',
					moveLine: [{
						startP: [380, 80],
						endP: [220, 80]
					}]
				},
				{
					fillColor:'#3d90df',
					moveLine: [{
						startP: [220, 80],
						endP: [220, 150]
					}]
				},
				{
					fillColor:'#3d90df',
					moveLine: [{
						startP: [220, 250],
						endP: [220, 320]
					},{
						startP: [220, 320],
						endP: [250, 320]
					}]
				},
				{
					fillColor:'#3d90df',
					moveLine: [{
						startP: [305, 320],
						endP: [440, 320]
					}]
				},
				{
					fillColor:'#3d90df',
					moveLine: [{
						startP: [456, 320],
						endP: [480, 320]
					},{
						startP: [480, 320],
						endP: [480, 360]
					}]
				},
				{
					fillColor:'#3d90df',
					moveLine:[{
						startP:[586, 80],
						endP: [740, 80]
					},{
						startP:[740, 80],
						endP: [740, 190]
					}]
				},
				{
					fillColor:'#3d90df',
					moveLine: [{
						startP:[740, 290],
						endP: [740, 460]
					}]
				},
				{
					fillColor:'#3d90df',
					moveLine: [{
						startP:[740, 460],
						endP: [586, 460]
					}]
				}
		    ],
		    unLink: [],
		    kd: [
		    	{
		    		fillColor:'#3d90df',
		    		moveLine: [{
		    			startP: [380, 80],
		    			endP: [380, 170]
		    		}]
		    	},
		    	{
		    		fillColor:'#3d90df',
		    		moveLine: [{
		    			startP: [380, 226],
		    			endP: [380, 320]
		    		}]
		    	},
		    	{
		    		fillColor:'#3d90df',
		    		moveLine: [{
		    			startP: [380, 320],
		    			endP: [305, 320]
		    		}]
		    	},
		    	{
		    		fillColor:'#3d90df',
		    		moveLine: [{
		    			startP: [250, 320],
		    			endP: [120, 320]
		    		}]
		    	},
		    	{
		    		fillColor:'#3d90df',
		    		moveLine: [{
		    			startP: [120, 320],
		    			endP: [120, 250]
		    		}]
		    	},
		    	{
		    		fillColor:'#3d90df',
		    		moveLine: [{
		    			startP: [120, 150],
		    			endP: [120, 80]
		    		}]
		    	},
		    	{
		    		fillColor:'#3d90df',
		    		moveLine: [{
		    			startP: [120, 80],
		    			endP: [380, 80]
		    		}]
		    	}
		    ],
		    powerCutDis:[
		        {
		        	fillColor:'#FF0000',
			    	 moveLine: [
	    	            {
				    		startP: [480, 360],
				    		endP: [480, 320]
	    	            },
	    	            {
	    	            	startP: [480, 320],
				    		endP: [456, 320]
	    	            }
			    	 ]
		        },
		        {
		        	fillColor:'#FF0000',
			    	 moveLine: [
	    	            {
				    		startP: [440, 320],
				    		endP: [380, 320]
	    	            }
			    	 ]
		        },
		        {
		        	fillColor:'#FF0000',
			    	 moveLine: [
	    	            {
				    		startP: [380, 320],
				    		endP: [380, 226]
	    	            }
			    	 ]
		        },
		        {
		        	fillColor:'#FF0000',
			    	 moveLine: [
	    	            {
				    		startP: [380, 170],
				    		endP: [380, 80]
	    	            }
			    	 ]
		        },
		        {
		        	fillColor:'#FF0000',
			    	 moveLine: [
	    	            {
				    		startP: [380, 80],
				    		endP: [440, 80]
	    	            }
			    	 ]
		        },
		        {
		        	fillColor:'#FF0000',
			    	 moveLine: [
	    	            {
				    		startP: [456, 80],
				    		endP: [740, 80]
	    	            }
			    	 ]
		        },
		        {
		        	fillColor:'#FF0000',
			    	 moveLine: [
	    	            {
				    		startP: [740, 80],
				    		endP: [740, 190]
	    	            }
			    	 ]
		        },
		        {
		        	fillColor:'#FF0000',
			    	 moveLine: [
	    	            {
				    		startP: [740, 290],
				    		endP: [740, 460]
	    	            }
			    	 ]
		        },
		        {
		        	fillColor:'#FF0000',
			    	 moveLine: [
	    	            {
				    		startP: [740, 460],
				    		endP: [586, 460]
	    	            }
			    	 ]
		        },
		        {
		        	fillColor:'#FF0000',
			    	 moveLine: [
			    	    {
			    	    	startP: [586, 460],
				    		endP: [480, 460]
			    	    },
	    	            {
				    		startP: [480, 460],
				    		endP: [480, 440]
	    	            }
			    	 ]
		        },
		    ]
		};
		
		var currList = currentDotLists[state];
		eleCircle.drawRectList(currList)
		
		var switchBtn = {
			floatCharge:{
				open:{stats: 'off'}, // 常开接触器
				close: {stats: 'on'} // 常闭接触器
			},
			discharge: {
				open:{stats: 'on'},
				close: {stats: 'off'}
			},
			constCharge: {
				open:{stats: 'on'},
				close: {stats: 'off'}
			},
			directCharge:{
				open:{stats: 'off'}, 
				close: {stats: 'on'} 
			},
			unLink: {
				open:{stats: 'off'}, 
				close: {stats: 'on'} 
			},
			kd: {
				open:{stats: 'on'},
				close:{stats: 'on'}
			},
			powerCutDis: {
				open: {stats: 'off'},
				close: {stats: 'on'}
			}
			
		}
		
		var eleCurrent = {
			floatCharge:{
				fillStyle: '#000'
			},
			discharge: {
				fillStyle: '#FF0000'
			},
			constCharge: {
				fillStyle: '#000'
			},
			directCharge:{
				fillStyle: '#000' 
			},
			unLink: {
				fillStyle: '#FF0000' 
			},
			kd: {
				fillStyle: '#000'
			},
			powerCutDis: {
				fillStyle: '#FF0000'
			}
		};
		
		var btnObj = switchBtn[state];
		
		
		var titleList = {
			floatCharge:{
				fillStyle: '#000',
				name: '设备浮充状态'
			},
			discharge: {
				fillStyle: '#000',
				name: '设备放电测试'
			},
			constCharge: {
				fillStyle: '#000',
				name: '设备稳流充电'
			},
			directCharge: {
				fillStyle: '#000',
				name: '设备直连充电'
			},
			unLink: {
				fillStyle: '#FF0000',
				name: '设备未连接'
			},
			kd: {
				fillStyle: '#000',
				name: 'K1/D1测试'
			},
			powerCutDis: {
				fillStyle: '#000',
				name: '设备停电放电'
			}
		};
		
		changeEleCircleOpt(eleCircle, 'title', titleList[state]);	// 拓扑图内容
		
		//console.info(btnObj.open);
		// 设置电流的状态改变了
		var temp= {
			isChange: 1,
		}
		
		var currentColor = eleCurrent[state]; 
		
		temp = $.extend({}, currentObj[state], temp);
		// 根据状态
	 	changeEleCircleOpt(eleCircle, 'current', temp);
	 	
	 	// 更新电路图中开关的状态
	 	changeEleCircleOpt(eleCircle, 'ko', btnObj.close);	// 常闭开关
	 	changeEleCircleOpt(eleCircle, 'km', btnObj.open);	// 常开开关
	 	changeEleCircleOpt(eleCircle, 'kc', btnObj.open);	// 常开开关
	 	
	 	changeEleCircleOpt(eleCircle, 'eleCurrent', currentColor);
	}
	changeCurrentState.isChange = 0;	// 恢复状态为0
}

changeCurrentState.isChange = 0;	// 设置默认的值为不改变

// 检测文本的长度
function getStringWidth(str, fontsize) {
	var _fontSize = fontsize?fontsize:12;	// 默认为12像素
	var _width = 0;
	// 遍历字符串中每个字符
	for(var i=0; i<str.length; i++) {
		var chart = str.charAt(i);
		if(isNaN(chart)) {
			_width += _fontSize;
		}else {
			_width += _fontSize/2;
		}
	}
	
	return _width;
}