jfregularline.java

来自「用Java开发的、实现类似Visio功能的应用程序源码」· Java 代码 · 共 1,295 行 · 第 1/3 页

    		return;
    		
	
	int 	newNodeCount=m_regularLine.getNodeCount();
	JFPoint newMoveNode;
	JFPoint newPriorNode1;
	JFPoint newPriorNode2;
	JFPoint newNextNode1;
	JFPoint newNextNode2;
	double slope=0; //for regular line, slope of each line segment will always be 0 or GeomConst.LARGE_VALUE


	//if node type of the moving node is an END point.
	if (m_moveNodeType==JFPointNode.NODETYPE_END){
		
		//if only two nodes on the original regular line.
		if (m_endNodeCount==2){
			if (m_priorNode1.isValid()){
				//last node moved
				newMoveNode	=m_regularLine.getNode(newNodeCount-1);
				newPriorNode1	=m_regularLine.getNextNode((JFPointNode)newMoveNode,true);
				m_portList.movePort(m_moveNode,m_priorNode1,newMoveNode,newPriorNode1);
			}else{
				//first node moved
				newMoveNode	=m_regularLine.getNode(0);
				newNextNode1	=m_regularLine.getNextNode((JFPointNode)newMoveNode,false);
				m_portList.movePort(m_moveNode,m_nextNode1,newMoveNode,newNextNode1);
			}
		//multiple end nodes more than 2.
		}else{
			newMoveNode	=new JFPoint(x,y);	
			//process the ports between priorNode1,priorNode2 and moveNode
			if (m_priorNode1.isValid()){
				slope	=m_priorNode1.getSlope(m_moveNode);
				if (slope==GeomConst.LARGE_VALUE)
					newPriorNode1	=new JFPoint(m_priorNode1.getX()+(x-m_moveNode.getX()),m_priorNode1.getY());
				else
					newPriorNode1	=new JFPoint(m_priorNode1.getX(),m_priorNode1.getY()+(y-m_moveNode.getY()));
				m_portList.movePort(m_moveNode,m_priorNode1,newMoveNode,newPriorNode1);

				if (m_priorNode2.isValid() && slope!=m_priorNode1.getSlope(m_priorNode2)){
					//line from moveNode to priorNode1 and line from moveNode to priorNode2
					//are not on same line(upright line)
					m_portList.movePort(m_priorNode1,m_priorNode2,newPriorNode1,m_priorNode2);
				}
    			}

			//process the ports between nextNode1,nextNode2 and moveNode
			if (m_nextNode1.isValid()){
				slope	=m_nextNode1.getSlope(m_moveNode);
				if (slope==GeomConst.LARGE_VALUE)
					newNextNode1	=new JFPoint(m_nextNode1.getX()+(x-m_moveNode.getX()),m_nextNode1.getY());
				else
					newNextNode1	=new JFPoint(m_nextNode1.getX(),m_nextNode1.getY()+(y-m_moveNode.getY()));
				m_portList.movePort(m_moveNode,m_nextNode1,newMoveNode,newNextNode1);

				if (m_nextNode2.isValid() && slope!=m_nextNode1.getSlope(m_nextNode2)){
					m_portList.movePort(m_nextNode1,m_nextNode2,newNextNode1,m_nextNode2);
				}
    			}
    		}	
	

	//if node type of the moving node is an MIDDLE point.
	}else if (m_moveNodeType==JFPointNode.NODETYPE_MIDDLE){
		
		if (m_priorNode1.getX()==m_nextNode1.getX()){
			newPriorNode1	=new JFPoint(x,m_priorNode1.getY());
			newNextNode1	=new JFPoint(x,m_nextNode1.getY());
		}else{
			newPriorNode1	=new JFPoint(m_priorNode1.getX(),y);
			newNextNode1	=new JFPoint(m_nextNode1.getX(),y);
		}
		m_portList.movePort(m_priorNode1,m_nextNode1,newPriorNode1,newNextNode1);
		
		if (m_priorNode2!=null){
			slope	=m_priorNode1.getSlope(m_nextNode1);
			if (slope!=m_priorNode1.getSlope(m_priorNode2)){
				m_portList.movePort(m_priorNode1,m_priorNode2,newPriorNode1,m_priorNode2);
			}
		}

		if (m_nextNode2!=null){
			slope	=m_nextNode1.getSlope(m_priorNode1);
			if (slope!=m_nextNode1.getSlope(m_nextNode2)){
				m_portList.movePort(m_nextNode1,m_nextNode2,newNextNode1,m_nextNode2);
			}
		}

	//if node type of the moving node is a SUB-MIDDLE point.
	}else if (m_moveNodeType==JFPointNode.NODETYPE_SUBMIDDLE){
		JFPoint middle		=m_priorNode1.midPoint(m_nextNode1);
		JFPoint newMiddle;
		
		//divide ports firstly by the middle point
		m_portList.dividePort(m_priorNode1,m_nextNode1,middle);
		
		
		if (m_moveNode.middleOf(m_priorNode1,middle)){

			if (m_priorNode1.getX()==middle.getX()){
				newPriorNode1	=new JFPoint(x,m_priorNode1.getY());
				newMiddle	=new JFPoint(x,middle.getY());
			}else{
				newPriorNode1	=new JFPoint(m_priorNode1.getX(),y);
				newMiddle	=new JFPoint(middle.getX(),y);
			}
			m_portList.movePort(m_priorNode1,middle,newPriorNode1,newMiddle);

			
			if (m_priorNode2!=null){
				slope	=m_priorNode1.getSlope(middle);
				if (slope!=m_priorNode1.getSlope(m_priorNode2)){
					m_portList.movePort(m_priorNode1,m_priorNode2,newPriorNode1,m_priorNode2);
				}
			}
		}else{

			if (m_nextNode1.getX()==middle.getX()){
				newNextNode1	=new JFPoint(x,m_nextNode1.getY());
				newMiddle	=new JFPoint(x,middle.getY());
			}else{
				newNextNode1	=new JFPoint(m_nextNode1.getX(),y);
				newMiddle	=new JFPoint(middle.getX(),y);
			}
			m_portList.movePort(m_nextNode1,middle,newNextNode1,newMiddle);
			
			if (m_nextNode2!=null){
				slope	=m_nextNode1.getSlope(middle);
				if (slope!=m_nextNode1.getSlope(m_nextNode2)){
					m_portList.movePort(m_nextNode1,m_nextNode2,newNextNode1,m_nextNode2);
				}
			}

		}
		
	}


	//List portList	=m_portList.getList();
	//Iterator it;
	Port port;

	//four node of regularLine.
	JFPointNode  firstNode		=m_regularLine.getNode(0);
	JFPointNode  secondNode		=m_regularLine.getNextNode(0,false);
	int nodeCount	=m_regularLine.getNodeCount();
	JFPointNode  lastFirstNode	=m_regularLine.getNode(nodeCount-1);
	JFPointNode  lastSecondNode	=m_regularLine.getNextNode(nodeCount-1,true);

			
	//now, all of the new ports position have been decided,
	//but consider all of the node currently moved may no longer exist,
	//so we started to check and correct the new value of each port.
	for (int i=m_portList.size()-1; i>=0; i--){
	  	try{
			port		=(Port)m_portList.getByIndex(i);
	  	}catch(Exception e){
	  		m_logger.error("finishMoveRegularLineNode: "+e);
			break;
	  	}
			
		JFPoint firstPoint	=port.getFirstPoint();
		JFPoint secondPoint	=port.getSecondPoint();			
		JFPoint portPoint	=port.getPortPoint();
		

		if (port.getPortType()==Port.PORTTYPE_DEFAULT){
			//only two default port for a regularLine.
			JFPointNode  node1,node2;
			//port index=0: default start port, port index=1: default end port.
			if (i==0){
				//the start port.
				node1	=firstNode;
				node2	=secondNode;
			}else{
				//the end port.
				node1	=lastFirstNode;
				node2	=lastSecondNode;
			}
				
			port.setFirstPoint(node1);
			port.setSecondPoint(node2);
			port.setPortPoint(node1);
		
	
		}else{

			LineSeg line	=m_regularLine.pickLine(portPoint.getX(),portPoint.getY(),GeomConst.PICK_OFFSET,firstPoint,secondPoint);
			if (line==null){
				//if this port is no longer on the regular line, we remove it silently here.
				m_portList.removePort(port);			
			}else {
		
				JFPoint newPortPoint	=line.uprightFoot(portPoint.getX(),portPoint.getY());

				
				JFPoint pnt1=line.getPoint1();
				JFPoint pnt2=line.getPoint2();					
				if (!newPortPoint.middleOf(pnt1,pnt2)){
					if(newPortPoint.distance(pnt1)<newPortPoint.distance(pnt2))
						newPortPoint.setValue(pnt1);
					else
						newPortPoint.setValue(pnt2);
				}
			
				port.setFirstPoint(line.getPoint1());
				port.setSecondPoint(line.getPoint2());
				port.setPortPoint(newPortPoint);
			}
		}		
  	}
	   	
   }


   /**
    *   finish move/adjust a node of current object.
    * 
    *   @param  node Currently moving node.
    *
    *   @param  x,&nbsp;y Moving offsets.
    *
    *   @param g current drawing canvas.
    *
    */ 	
   public void  finishMoveNode(Node node, double x, double y,Graphics g){
	finishMoveLabel();

	if (node!=null && node instanceof RegularNode){
	
		int index	=m_nodeList.getIndexByObjectId(node.getObjectId());
		if (index<0) return;
		
		m_regularLine.finishMoveNode(index,x,y);
		initNodes();

		finishMoveRegularLineNode(x,y);
                
                m_portList.setZoomScale(getZoomScale());
		
		
		if (g!=null)
			draw(g,false);
	}
   }




   /**
    *   Convert this object to String <br>
    * 
    *   @return  An string represents the content of the object
    *
    */ 	
   public String toString(){
   	StringBuffer buf=new StringBuffer();
	
	buf.append(super.toString());
	buf.append("\n<arrowType>");
	buf.append(m_arrow.toString());
   	buf.append("\n<lineFormat>");
   	buf.append(m_lineFormat.toString());
	buf.append("\n");
	buf.append(m_regularLine.toString());

   	return buf.toString();
   }


   /**
    *   Creates a new AbstractObject of the same class and with the same contents as this object.
    *   This method implements the method defined in AbstractObject.
    * 
    *   @return  A clone of this class.
    *
    */ 	
  protected AbstractObject cloneMe() throws CloneNotSupportedException{
  	return new JFRegularLine();
  }
  
  
   /**
    *   Creates a new object of the same class and with the same contents as this object.
    * 
    *   @return  A clone of this instance.
    *
    */ 	
  public Object clone() throws CloneNotSupportedException{
  	try{
  		Object obj =super.clone();
  		if (obj==null){
  			return null;
  		}
  		
  		JFRegularLine line =(JFRegularLine) obj;
  		line.m_regularLine	=new RegularLine(m_regularLine);
  		line.initNodes();
  		line.m_arrow.setValue(m_arrow);
  		line.m_lineFormat.setValue(m_lineFormat);
  		
  		return line;
  		
	}catch(Exception e){
		throw new CloneNotSupportedException(e.getMessage());
	}
  }


   /**
    *   Returns the hashcode for this Object.
    * 
    *   @return hash code for this Point2D.
    *
    */ 	
  public int hashCode(){
  	return  super.hashCode() ^ 
  		m_regularLine.hashCode() ^ 
  		m_lineFormat.hashCode() ^
  		m_arrow.hashCode();
  }


   /**
    *   Determines whether or not two objects are equal. 
    * 
    * 	@param obj  an object to be compared with this object 
    * 
    *   @return true if the object to be compared is an instance of Port and has the same values; false otherwise.
    *
    */ 	
  public boolean equals(Object obj){
      if (!super.equals(obj))
             return false;
             		
      if (obj == this)
             return true;
      if (!(obj instanceof JFRegularLine))
            return false;

      JFRegularLine  line= (JFRegularLine)obj;
      
      return  	(line.m_regularLine.equals(m_regularLine))&&
      		(line.m_arrow.equals(m_arrow)) &&
        	(line.m_lineFormat.equals(m_lineFormat));
  }


   /**
    *   Append necessary xml child for current element,
    *   this method will be called internally by toDOM.
    * 
    *   @param  element A XML element to append child xml nodes
    *   @param version A file version notification so this object can obey the rules to save data.
    *
    */ 	
  protected void appendChildToDOM(Element element,JFVersion version){
  		if (element==null)
  			return;
  			
  		super.appendChildToDOM(element,version);
  		m_arrow.toDOM(element,version);
    		m_lineFormat.toDOM(element,version);
  }


   /**
    *   Extract needed xml child from current element,
    *   this method will be called internally by fromDOM.
    * 
    *   @param  element An element used to extract needed xml child
    *   @param version A file version notification so this object can obey the rules to fetch data.
    *
    */ 	
  protected void extractChildFromDOM(Element element,JFVersion version){

      if (element==null)
  	  return;
  
      super.extractChildFromDOM(element,version);

      m_arrow.fromDOM(element.getChild(m_arrow.getXMLTag()),version);
      m_lineFormat.fromDOM(element.getChild(m_lineFormat.getXMLTag()),version);
      //recover point nodes to m_regularLine.
      recallNodes();
  }

 
   /**
    *   Save this object to a binary stream 
    * 
    *   @param stream An binary output stream
    *
    *   @param version A file version notification so this object can obey the rules to save data.
    *   @exception  java.io.IOException
    *
    */ 	
  public void saveToStream(com.jfimagine.utils.io.JFWriter stream,JFVersion version) throws IOException{
	super.saveToStream(stream,version);
	
	m_arrow.saveToStream(stream,version);
	m_lineFormat.saveToStream(stream,version);
  }

   /**
    *   Load object data from a binary stream <br>
    * 
    *   @param stream An binary input stream
    *
    *   @param skipHead Skip head 'TYPE' check, an shape object should always 
    *   has its own shape-type stored, if this shape-type has already been readed,
    *   this loadFromStream should/could not read the type anymore.
    *
    *   @param version A file version notification so this object can obey the rules to fetch data.
    *   @exception  java.io.IOException
    *
    */ 	
  public void loadFromStream(com.jfimagine.utils.io.JFReader stream,boolean skipHead,JFVersion version) throws IOException{
	super.loadFromStream(stream,skipHead,version);
	
	m_arrow.loadFromStream(stream,false,version);
	m_lineFormat.loadFromStream(stream,false,version);//don't skip head here
      	    
      	//recover point nodes to m_regularLine.
	recallNodes();
  }



 }