front_end/libs/Controls/Select.js

function Select(layer){
	this.layer = layer;
	this.currentState=this.layer.currentState;
	this.calculateElement=this.layer.calculateElement;
	this.calculateLine=this.layer.calculateLine;
	this.contextIndex=this.layer.parameter.selectcontext;
	
	this.f_selectSymbol=false;
	this.f_selectSymbolEndPoint=false;
	this.f_selectWallCorner=false;
	this.f_selectWallLine=false;
	this.f_selectStairCorner=false;
	this.f_selectStairLine=false;
	this.f_selectSpiralCorner=false;
	this.f_selectSpiralLine=false;

	this.selectSymbolIds={};	
	this.selectWall={wallid:null,index:null};
	this.r=this.layer.parameter.selectCircle_R;
};

//当鼠标单击symbol的端点时
Select.prototype.selectSymbolPoint=function(symbol2d,point)
{
	if(this.layer.move.draggingSymbol2dPoint==null)
	{
		this.layer.move.draggingSymbol2dPoint={};
	}
	
	this.layer.move.draggingSymbol2dPoint.wallid=this.currentState.currentWallId;
	this.layer.move.draggingSymbol2dPoint.wallStartindex=symbol2d.attributes.wallstartindex;
	this.layer.move.draggingSymbol2dPoint.wallEndindex=symbol2d.attributes.wallendindex;
	
	var point1={x:this.layer.vectors[this.currentState.currentSymbolCircleId1].geometry.x,y:this.layer.vectors[this.currentState.currentSymbolCircleId1].geometry.y};
	var point2={x:this.layer.vectors[this.currentState.currentSymbolCircleId2].geometry.x,y:this.layer.vectors[this.currentState.currentSymbolCircleId2].geometry.y};
	if(BABYLON.Vector2.Distance(point1,point)<this.r)
	{
		this.layer.move.draggingSymbol2dPoint.selectPoint=point1;
		this.layer.move.draggingSymbol2dPoint.noselectPoint=point2;
		
		this.layer.move.draggingSymbol2dPoint.selectVectorId=this.currentState.currentSymbolCircleId1;
		this.layer.move.draggingSymbol2dPoint.noselectVectorId=this.currentState.currentSymbolCircleId2;
	}
	else if(BABYLON.Vector2.Distance(point2,point)<this.r)
	{
		this.layer.move.draggingSymbol2dPoint.selectPoint=point2;
		this.layer.move.draggingSymbol2dPoint.noselectPoint=point1;
		
		this.layer.move.draggingSymbol2dPoint.selectVectorId=this.currentState.currentSymbolCircleId2;
		this.layer.move.draggingSymbol2dPoint.noselectVectorId=this.currentState.currentSymbolCircleId1;
	}
	
	this.f_selectSymbolEndPoint=true;
	this.layer.pan.f_draggingSymbol=false;
};

//编辑扇形
Select.prototype.editSector=function(index)
{
	var points=this.layer.vectors[this.currentState.currentWallId].geometry.points;
	var len=points.length;

	if(len<3)
	{
		return null;
	}
	
	if(this.layer.vectors[this.currentState.currentWallId].geometry.state==1)
	{
		if(index==0)
		{
			++index;
		}
		else if(index==len-1)
		{
			--index;
		}
	}
	var sideIndex=this.calculateElement.getSideIndex(len,index);
	
	var temp={x:points[index].x+1,y:points[index].y};
	
	var tempangle1=this.calculateLine.Angle(points[index],points[sideIndex.pre],temp);
	
	var start,end;
	if(points[sideIndex.pre].y<temp.y)
	{
		start=tempangle1/180*Math.PI;
	}
	else if(points[sideIndex.pre].y>temp.y)
	{
		start=(360-tempangle1)/180*Math.PI;	
	}
	else if(points[sideIndex.pre].x<temp.x)
	{
		start=Math.PI;	
	}
	else
	{
		start=0;		
	}
	
	var tempangle2=this.calculateLine.Angle(points[index],points[sideIndex.next],temp);
	if(points[sideIndex.next].y<temp.y)
	{
		end=tempangle2/180*Math.PI;
	}
	else if(points[sideIndex.next].y>temp.y)
	{
		end=(360-tempangle2)/180*Math.PI;	
	}
	else if(points[sideIndex.next].x<temp.x)
	{
		end=Math.PI;	
	}
	else
	{
		end=0;		
	}
	if(start>end)
	{
		var t=start;
		start=end;
		end=t;	
	}
	var angle=this.calculateLine.Angle(points[index],points[sideIndex.pre],points[sideIndex.next]);
	if(Math.round(angle)==180)
	{
		this.layer.vectors[this.currentState.currentWallId].geometry.disappearPointIndex=index;
	}
	else
	{
		this.layer.vectors[this.currentState.currentWallId].geometry.disappearPointIndex=-1;
	}
	return {x:points[index].x,y:points[index].y,start:start,end:end};
};

//选择拐角
Select.prototype.selectStairCorner=function(id,index)
{
	var point=this.layer.vectors[id].geometry.points[index];
	var r=(wallThickness/2)/this.layer.res;
	var circle = new Circle(point.x,point.y,r);
	var vector1 = new Vector(circle, circleStyle);
    this.currentState.currentCircleId=vector1.id;
    vector1.geometry.contextIndex=this.contextIndex;
	this.layer.drawSingleVector(vector1);
	this.f_selectStairCorner=true;
};

Select.prototype.selectSpiralCorner=function(id,index)
{
	var point=null;
	if(index==1)
	{
		point=this.layer.vectors[id].geometry.point1;
	}
	else
	{
		point=this.layer.vectors[id].geometry.point2;
	}
	
    var vector1 = new Vector(new Point(point.x,point.y,point_r), pointStyle);
    this.currentState.currentPointId=vector1.id;
    vector1.geometry.contextIndex=this.contextIndex;
    
	var vector2 = new Vector(new Circle(point.x,point.y,this.layer.parameter.selectCircle_R/this.layer.res), circleStyle);
    this.currentState.currentCircleId=vector2.id;
    vector2.geometry.contextIndex=this.contextIndex;
	
	this.layer.drawSingleVector(vector1);
	this.layer.drawSingleVector(vector2);
	
	spiralStyle.strokeStyle2="#89b808";
	this.f_selectSpiralCorner=true;
	
	this.layer.control.refreshCanvas=true;
};

Select.prototype.selectSpiralPlane=function(id)
{
	this.f_selectSpiralLine=true;
	spiralStyle.strokeStyle2="#89b808";
	this.layer.control.refreshCanvas=true;
};

Select.prototype.endselectSpiralCorner=function()
{
	spiralStyle.strokeStyle2="#000000";
	this.f_selectSpiralCorner=false;
	this.layer.deleteVector(this.currentState.currentPointId);
	this.layer.deleteVector(this.currentState.currentCircleId);
	this.layer.control.refreshCanvas=true;
};

Select.prototype.endselectSpiralPlane=function()
{
	spiralStyle.strokeStyle2="#000000";
	this.f_selectSpiralLine=false;
	this.layer.control.refreshCanvas=true;
};

//选择墙角
Select.prototype.selectWallCorner=function(wallid,index)
{
	console.log('----0')
	this.currentState.currentWallId = wallid;
	var point=this.layer.vectors[wallid].geometry.points[index];
	var r=this.layer.parameter.wallThickness;
	if(r!=null)
	{
		r=(r/2)/this.layer.res;
	}
	var vectors=[];
	
    var circle = new Circle(point.x,point.y,r);
    var vector1 = new Vector(circle, circleStyle);
    this.currentState.currentCircleId=vector1.id;
    vector1.geometry.contextIndex=this.contextIndex;
    
    var point = new Point(point.x,point.y,point_r);
    var vector2 = new Vector(point, pointStyle);
    this.currentState.currentPointId=vector2.id;
    vector2.geometry.contextIndex=this.contextIndex;
    
	this.layer.drawSingleVector(vector1);
	this.layer.drawSingleVector(vector2);
	
    var sectorinfo=this.editSector(index);
	if(sectorinfo!=null)
	{
		var sector = new Sector(sectorinfo.x,sectorinfo.y,Sector_r,sectorinfo.start,sectorinfo.end);
		var vector3 = new Vector(sector,sectorStyle);
		this.currentState.currentSecotrId=vector3.id;
		vector3.geometry.contextIndex=this.contextIndex;
		this.currentState.selectWallSet={id:wallid,index:index,type:0};
		this.currentState.currentstartlinePointIndex=index;
		this.layer.drawSingleVector(vector3);
	}
	this.f_selectWallCorner=true;
};

Select.prototype.selectStairWallLine=function(id,startindex,endindex)
{
	var pt1=this.layer.vectors[id].geometry.points[startindex];
	var pt2=this.layer.vectors[id].geometry.points[endindex];
	
	//不能用引用，可能选中的线的index和墙面的index不一致
	var points=[];
	
	points.push({x:pt1.x,y:pt1.y});
	points.push({x:pt2.x,y:pt2.y});
	
	var line = new Vector(new Line(points),selectLineStyle);
	this.currentState.currentLineId=line.id;
	line.geometry.contextIndex=this.contextIndex;
	this.layer.drawSingleVector(line);
	
    var point1 = new Point(pt1.x,pt1.y,point_r);
	var point2 = new Point(pt2.x,pt2.y,point_r);

    var vector1 = new Vector(point1, pointStyle);
    vector1.geometry.contextIndex=this.contextIndex;
    this.currentState.currentLinePoint1Id=vector1.id;
    this.layer.drawSingleVector(vector1);
    
	var vector2 = new Vector(point2, pointStyle);
	vector2.geometry.contextIndex=this.contextIndex;
	this.currentState.currentLinePoint2Id=vector2.id;
	this.layer.drawSingleVector(vector2);
	
	if(this.layer.vectors[id].geometry.geoType=="Wall")
	{
		this.f_selectWallLine=true;
		this.currentState.selectWallSet={id:id,index:startindex,type:1,endindex:endindex};
	}
	else if(this.layer.vectors[id].geometry.geoType=="WinderStair")
	{
		this.f_selectStairLine=true;
		this.currentState.selectStairSet={id:id,index:startindex,type:1,endindex:endindex};
	}
};

/*
//选择楼梯面
Select.prototype.selectStairLine=function(stairid,startindex,endindex)
{
	
};


//选择墙面
Select.prototype.selectWallLine=function(wallid,startindex,endindex)
{
	var pt1=this.layer.vectors[wallid].geometry.points[startindex];
	var pt2=this.layer.vectors[wallid].geometry.points[endindex];
	
	//不能用引用，可能选中的线的index和墙面的index不一致
	var points=[];
	
	points.push({x:pt1.x,y:pt1.y});
	points.push({x:pt2.x,y:pt2.y});
	
	var line = new Vector(new Line(points),selectLineStyle);
	this.currentState.currentLineId=line.id;
	line.geometry.contextIndex=this.contextIndex;
	this.layer.drawSingleVector(line);
	
    var point1 = new Point(pt1.x,pt1.y,point_r);
	var point2 = new Point(pt2.x,pt2.y,point_r);

    var vector1 = new Vector(point1, pointStyle);
    vector1.geometry.contextIndex=this.contextIndex;
    this.currentState.currentLinePoint1Id=vector1.id;
    this.layer.drawSingleVector(vector1);
    
	var vector2 = new Vector(point2, pointStyle);
	vector2.geometry.contextIndex=this.contextIndex;
	this.currentState.currentLinePoint2Id=vector2.id;
	this.currentState.selectWallSet={id:wallid,index:startindex,type:1,endindex:endindex};
	this.layer.drawSingleVector(vector2);
	
	this.f_selectWallLine=true;
};
*/

//选择Symbol
Select.prototype.selectSymbol=function(symbol2d)
{
	var points=[];
	points.push(symbol2d.geometry.point1);
	points.push(symbol2d.geometry.point2);
	var selectSymbolIds=[];
	
	var vectorline=new Vector(new Line(points),selectLineStyle);
	vectorline.geometry.contextIndex=this.contextIndex;
	this.layer.drawSingleVector(vectorline);
	this.layer.vectors[vectorline.id] = vectorline;
	selectSymbolIds.push(vectorline.id);

	var vectorp1=new Vector(new Circle(points[0].x,points[0].y,this.r),selectCircleStyle);
	vectorp1.geometry.contextIndex=this.contextIndex;
	this.layer.drawSingleVector(vectorp1);
	this.layer.vectors[vectorp1.id] = vectorp1;
	selectSymbolIds.push(vectorp1.id);
	
	var vectorp2=new Vector(new Circle(points[1].x,points[1].y,this.r),selectCircleStyle);
	vectorp2.geometry.contextIndex=this.contextIndex;
	this.layer.drawSingleVector(vectorp2);
	this.layer.vectors[vectorp2.id] = vectorp2;
	selectSymbolIds.push(vectorp2.id);

	this.currentState.currentSymbolCircleId1=vectorp1.id;
	this.currentState.currentSymbolCircleId2=vectorp2.id;
	this.currentState.currentSymbolId=symbol2d.id;

	this.f_selectSymbol=true;
	this.selectSymbolIds.vectorid=symbol2d.id;
	this.selectSymbolIds.vectorMeasureid=symbol2d.attributes.vectorMeasureid;
	this.selectSymbolIds.selects=selectSymbolIds;
	
	symbol2d.attributes.selectSymbolIds=selectSymbolIds;								
	return selectSymbolIds;
};

Select.prototype.reset=function()
{
	this.f_selectSymbol=false;
	this.f_selectSymbolEndPoint=false;
	this.f_selectWallCorner=false;
	this.f_selectWallLine=false;
};

Select.prototype.endSelectSymbol=function(vectorid,selects,vectorMeasureid)
{
	
	this.layer.vectors[vectorid].attributes.vectorMeasureid=null;
	this.layer.vectors[vectorid].attributes.selectSymbolIds=[];
	
	if(this.layer.vectors[vectorid]&&this.layer.vectors[vectorid].symbol2Ds)
	{
		for(var i=0;i<selects.length;++i)
		{
			this.layer.deleteVector(selects[i]);
		}
	}
	
	this.layer.deleteVector(vectorMeasureid);
	
	this.selectSymbolIds={};
	this.currentState.clearSelectSymbol();
	this.f_selectSymbolEndPoint=false;
	this.f_selectSymbol=false;
	this.layer.control.refreshSelectCanvas=true;
};

Select.prototype.endSelectWallLine=function()
{
	if(this.currentState.currentLineId!=null)
	{
		this.layer.deleteVector(this.currentState.currentLineId);
		this.currentState.currentLineId=null;
		this.layer.control.refreshSelectCanvas=true;
	}
	if(this.currentState.currentLinePoint1Id!=null)
	{
		this.layer.deleteVector(this.currentState.currentLinePoint1Id);
		this.currentState.currentLinePoint1Id=null;
		this.layer.control.refreshSelectCanvas=true;
	}
	if(this.currentState.currentLinePoint2Id!=null)
	{
		this.layer.deleteVector(this.currentState.currentLinePoint2Id);
		this.currentState.currentLinePoint2Id=null;
		this.layer.control.refreshSelectCanvas=true;
	}
};

Select.prototype.endSelectWallCorner=function()
{
	if(this.currentState.currentWallId==null)
	{
		return;
	}
	
	if(this.layer.vectors[this.currentState.currentWallId].geometry.disappearPointIndex!=-1)
	{
		var index=this.layer.vectors[this.currentState.currentWallId].geometry.disappearPointIndex;
		this.layer.vectors[this.currentState.currentWallId].geometry.disappearPointIndex=-1;
		var wallId = this.currentState.currentWallId;
		var point=this.layer.vectors[this.currentState.currentWallId].geometry.points[index];
		this.calculateElement.updateSymbolsForDeleteOnePoint(wallId,index);

		this.layer.vectors[this.currentState.currentWallId].geometry.points.splice(index,1);
		this.layer.vectors[this.currentState.currentWallId].geometry.wallInfo.splice(index,1);
		var startinidex=this.calculateElement.getPreIndex(this.layer.vectors[this.currentState.currentWallId].geometry.points,index);
		var endindex=this.calculateElement.getNextIndex(this.layer.vectors[this.currentState.currentWallId].geometry.points,startinidex);
		this.clearSelect();
		this.layer.control.refreshSelectCanvas=true;
		this.layer.control.refreshCanvas=true;
		this.layer.renderer.autoRedraw();
		this.currentState.selectWallSet=this.layer.calculateElement.wallsContain(point);
		this.selectStairWallLine(wallId,startinidex,endindex)
	}
	else
	{
		
		var index=this.currentState.currentstartlinePointIndex;
		var point=this.layer.vectors[this.currentState.currentWallId].geometry.points[index];
		var id=this.currentState.currentWallId;
		this.currentState.selectWallSet=this.calculateElement.wallsContain(point,this.currentState.currentWallId);
		if(this.currentState.selectWallSet==null)
		{
			this.layer.vectors[id].geometry.firstLines=[];
			this.layer.vectors[id].geometry.endLines=[];
		}
		else
		{
			if(index==0)
			{
				this.layer.vectors[id].geometry.firstLines=this.layer.build.getRelaEndLines();
				point=this.layer.build.adjustPoint(point);
				this.layer.vectors[id].geometry.points[index]=point;
			}
			else if(index==this.layer.vectors[id].geometry.points.length-1)
			{
				this.layer.vectors[id].geometry.endLines=this.layer.build.getRelaEndLines();
				point=this.layer.build.adjustPoint(point);
				this.layer.vectors[id].geometry.points[index]=point;
			}

		}
		
	}
	this.layer.control.refreshCanvas=true;
	this.layer.control.refreshSelectCanvas=true;
};

Select.prototype.clearSelect=function()
{
	this.reset();
	
	if(this.currentState.currentSymbolCircleId1!=null)
	{
		this.layer.deleteVector(this.currentState.currentSymbolCircleId1);
		this.currentState.currentSymbolCircleId1=null;
		this.layer.control.refreshSelectCanvas=true;
	}
	if(this.currentState.currentSymbolCircleId2!=null)
	{
		this.layer.deleteVector(this.currentState.currentSymbolCircleId2);
		this.currentState.currentSymbolCircleId2=null;
		this.layer.control.refreshSelectCanvas=true;
	}
	
	if(this.currentState.currentCircleId!=null)
	{
		this.layer.deleteVector(this.currentState.currentCircleId);
		this.currentState.currentCircleId=null;
		this.layer.control.refreshSelectCanvas=true;
	}
	if(this.currentState.currentPointId!=null)
	{
		this.layer.deleteVector(this.currentState.currentPointId);
		this.currentState.currentPointId=null;
		this.layer.control.refreshSelectCanvas=true;
	}
	if(this.currentState.currentSecotrId!=null)
	{
		this.layer.deleteVector(this.currentState.currentSecotrId);
		this.currentState.currentSecotrId=null;
		this.layer.control.refreshSelectCanvas=true;
	}
	
	if(this.currentState.currentLineId!=null)
	{
		this.layer.deleteVector(this.currentState.currentLineId);
		this.currentState.currentLineId=null;
		this.layer.control.refreshSelectCanvas=true;
	}
	if(this.currentState.currentLinePoint1Id!=null)
	{
		this.layer.deleteVector(this.currentState.currentLinePoint1Id);
		this.currentState.currentLinePoint1Id=null;
		this.layer.control.refreshSelectCanvas=true;
	}
	if(this.currentState.currentLinePoint2Id!=null)
	{
		this.layer.deleteVector(this.currentState.currentLinePoint2Id);
		this.currentState.currentLinePoint2Id=null;
		this.layer.control.refreshSelectCanvas=true;
	}
	
	if(this.currentState.currentSymbolId!=null)
	{
		var symbol = this.layer.vectors[this.currentState.currentSymbolId];
		symbol.attributes.selectSymbolIds=[];
		symbol.vectorMeasureid=null;
	}
	
	if(typeof(this.selectSymbolIds.selects)!="undefined"&&this.selectSymbolIds.selects.length>0)
	{
		var selectSymbolIds=this.selectSymbolIds.selects;
		if(selectSymbolIds.length>0)
		{
			this.layer.deleteVector(selectSymbolIds[0]);
			this.layer.control.refreshSelectCanvas=true;
		}
	}
	
	if(typeof(this.selectSymbolIds.vectorMeasureid)!="undefined")
	{
		this.layer.deleteVector(this.selectSymbolIds.vectorMeasureid);
		this.layer.control.refreshSelectCanvas=true;
	}

	if(this.f_selectSpiralCorner)
	{
		this.endselectSpiralCorner();
	}
	
	if(this.f_selectSpiralLine)
	{
		this.endselectSpiralPlane();
	}
	
	this.selectSymbolIds={};
	
	this.currentState.clearSelects();
};

//symbol由虚转实
Select.prototype.convertTrue=function(symbol)
{
	var contextIndex=this.layer.parameter.contextIndex;
	this.drawMeasure(symbol);

	symbol.geometry.contextIndex=contextIndex;
	this.layer.vectors[symbol.attributes.wallId].symbol2Ds[symbol.id]=symbol;
	++this.layer.vectors[symbol.attributes.wallId].symbol2dsCount;
	
	this.f_selectWallLine=false;
	this.f_selectSymbol=true;
	
	this.selectSymbolIds.vectorid=symbol.id;
	this.selectSymbolIds.vectorMeasureid=symbol.attributes.vectorMeasureid;
	
	this.layer.control.refreshCanvas=true;
	this.layer.control.refreshSelectCanvas=true;
	
	this.layer.data2d.symbol2DIds.push(symbol.id);
};

//当选择symbol时候，会显示测量
Select.prototype.drawMeasure=function(symbol)
{
	var wallType=this.layer.vectors[symbol.attributes.wallId].geometry.wallType;
	
	var vectorMeasure = new Vector(new LineMeasure([symbol.geometry.point1,symbol.geometry.point2]),selectLineStyle);
	vectorMeasure.geometry.contextIndex=this.contextIndex;
	vectorMeasure.geometry.wallType=wallType;
	this.layer.drawSingleVector(vectorMeasure);
	this.layer.vectors[vectorMeasure.id] = vectorMeasure;
	symbol.attributes.vectorMeasureid=vectorMeasure.id;
};