drawstate.java

用Java开发的、实现类似Visio功能的应用程序源码

/**
 *    $Id:DrawState.java $
 *
 *    Copyright 2004 ~ 2005  JingFei International Cooperation LTD. All rights reserved. *
 */
package com.jfimagine.jfdraw.draw;

import com.jfimagine.jfdraw.action.ActionConst;
import com.jfimagine.jfdraw.draw.DrawConst;

import com.jfimagine.jfgraph.shape.base.AbstractObject;
import com.jfimagine.jfgraph.shape.base.ObjectFactory;
import com.jfimagine.jfgraph.shape.base.ShapeConst;
import com.jfimagine.jfgraph.shape.base.AbstractShape;
import com.jfimagine.jfgraph.shape.base.Node;
import com.jfimagine.jfgraph.shape.base.ObjectList;

import com.jfimagine.jfgraph.geom.JFPoint;



 /**
 *  A draw state encapsulate current drawing or dragging state.
 *
 * @author     CookieMaker    
 *
 * @version $Revision: 1.00 $
 */  
 public class DrawState {

    /** current draw state.*/
    private int	m_drawState = DrawConst.DRAWSTATE_DRAW;

    /** type of current shape which is being drew or dragged.*/
    private int	m_shapeType = ShapeConst.SHAPETYPE_LINE;  
    
    /** current drawing shape,this shape should always be Drawable.*/
    private AbstractObject	m_shape;

    /** an object factory to make new objects.*/
    private ObjectFactory	m_objectFactory=ObjectFactory.getInstance();

    /** Current draw event.*/
    private AbstractDrawEvent	m_drawEvent;

    /** A start point for drawing,dragging or transforming.*/
    private JFPoint	m_startPoint	=new JFPoint();

    /** A flag to indicate if a start point is assigned already*/
    private boolean	m_startPointAssigned =false;

    /** A last point for the next point of drawing,dragging or transforming.*/
    private JFPoint	m_lastPoint	=new JFPoint();

    /** A last temporary point for drawing,dragging or transforming.
     * this point is a mouse position while the mouse is moving.
     */
    private JFPoint	m_lastTempPoint	=new JFPoint();



    /** Constructor **/
    public DrawState(){
    }	

    /** Constructor **/
    public DrawState(DrawState drawState){
    	this.m_drawState	=drawState.m_drawState;
    	this.m_shapeType	=drawState.m_shapeType;  
    	this.m_zoomScale	=drawState.m_zoomScale;
    	
    	try{
    		if (drawState.m_shape!=null)
    			this.m_shape		=(AbstractObject)drawState.m_shape.clone();
    		else
    			this.m_shape		=null;
    	}catch(Exception e){
    		this.m_shape		=null;
    	}
    }	


    /** get current drawing state
     * @return current drawing state.
     */	
    public int getDrawState(){
    	return m_drawState;
    }

    /** get current drawing shape type
     * @return current drawing shape type.
     */	
    public int getShapeType(){
    	return m_shapeType;
    }


    /** get if currently in rotation situation.
     * @return True if user want to rotate something, false otherwise.
     */	
   public boolean isRotating(){  
	return m_drawState==DrawConst.DRAWSTATE_ROTATE;
    }

    
    /** get current draw event.
     *  @return  Current drawing event.
     */
    public AbstractDrawEvent	getCurrentDrawEvent(){
    	return	m_drawEvent;
    }
    
    /** set current draw event.
     * @param drawEvent Current drawing event.
     */
    public void	setCurrentDrawEvent(AbstractDrawEvent drawEvent){
    	m_drawEvent	=drawEvent;
    }


    /** get the flag that if a start point is assigned
     * @return If a start point is assigned.
     */	
    public boolean getStartPointAssigned(){
    	return m_startPointAssigned;
    }

    /** set the flag that if a start point is assigned
     * @param startPointAssigned If a start point is assigned.
     */	
    public void setStartPointAssigned(boolean startPointAssigned){
    	m_startPointAssigned	=startPointAssigned;
    }

    /** get start point of drawing,dragging or transformming
     *  @return Get a start point of drawing, drawgging, etc.
     */	
    public JFPoint getStartPoint(){
    	return m_startPoint;
    }

    /** add a new node for current shape
     * @param x, y Coordinates of position of a new node.
     */	
    public boolean addNode(double x, double y){
    	if (m_shape!=null){
    		//if current shape is an AbstractShape, add a new node according to current point(parameter pnt).
    		if (m_shape instanceof AbstractShape){
    			((AbstractShape)m_shape).addNode(x,y);
    			return true;
    		}
    	}
    	return false;
    }
    
    /** set a start point of drawing,dragging or transformming
     *  @param pnt start point of drawing or dragging, etc.
     */	
    public void setStartPoint(JFPoint pnt){
    	setStartPoint(pnt.getX(),pnt.getY());
    }

    /** set a start point of drawing,dragging or transformming
     *  @param x, y  Coordinates of start point of drawing or dragging, etc.
     */	
    public void setStartPoint(double x, double y){
    	m_startPointAssigned	=true;
    	m_startPoint.setValue(x,y);
    	m_lastPoint.setValue(x,y);
    	m_lastTempPoint.setValue(x,y);
    	if (m_drawState==DrawConst.DRAWSTATE_DRAW)
		addNode(x,y);
    }


    /** get a next point of drawing,dragging or transformming*/	
    public JFPoint getLastPoint(){
    	return m_lastPoint;
    }

    /** set a next point of drawing,dragging or transformming
     *  @param pnt Last point.
     */
    public void setLastPoint(JFPoint pnt){
    	setLastPoint(pnt.getX(),pnt.getY());
    }

    /** set a next point of drawing,dragging or transformming
     *  @param x, y  Coordinates of last point.
     */
    public void setLastPoint(double x, double y){
    	if (m_lastPoint.getX()!=x || m_lastPoint.getY()!=y){
    		m_lastPoint.setValue(x,y);
    		if (m_drawState==DrawConst.DRAWSTATE_DRAW){
    			addNode(x,y);
    		}
    	}
    }

    /** get last temp point of drawing,dragging or transformming*/	
    public JFPoint getLastTempPoint(){
    	return m_lastTempPoint;
    }

    /** set last temp point of drawing,dragging or transformming	
     *  @param pnt Last temp point.
     */
    public void setLastTempPoint(JFPoint pnt){
    	setLastTempPoint(pnt.getX(),pnt.getY());
    }

    /** set last temp point of drawing,dragging or transformming	
     *  @param x, y  Coordinates of last temp point.
     */
    public void setLastTempPoint(double x, double y){
    	m_lastTempPoint.setValue(x,y);
    }


    /** cancel a last point
     *  @param pnt A new temporary point to instead last temp point.
     */	
    public void cancelLastPoint(JFPoint pnt){
    	//remove last point.
    	if (m_shape!=null){
    		//if current shape is an AbstractShape, remove the last node of this shape.
    		if (m_shape instanceof AbstractShape){
    			try{
    				Node lastNode	=((AbstractShape)m_shape).removeLastNode();
    				
    				if (lastNode==null){
    					m_startPointAssigned	=false;
    					m_startPoint.setValue(0,0);
    					m_lastPoint.setValue(m_startPoint);
    					m_lastTempPoint.setValue(m_startPoint);
    				}else{
    					m_lastPoint.setValue(lastNode.getXOffset(),lastNode.getYOffset());
    					m_lastTempPoint.setValue(pnt);
    				}
    			}catch(Exception e){
    			}
    		}
    	}
    }

    /** get current drawing shape*/	
    public AbstractObject getCurrentShape(){
    	return m_shape;
    }
    
    /** clear draw state.
     */	
    public void clearDrawState(){
    	m_drawState 	= DrawConst.DRAWSTATE_NONE;
	m_shapeType 	= ShapeConst.SHAPETYPE_NONE;  
	m_drawEvent	= null;
	m_shape		= null;
	
	m_startPointAssigned	=false;
	m_startPoint.setX(0);
	m_startPoint.setY(0);
	m_lastPoint.setValue(m_startPoint);
	m_lastTempPoint.setValue(m_startPoint);
	
    }
       
    /** set current canvas state
     *  @param state A new canvas state for current canvas.
     *  @param type  A new current canvas shape(in drawing or dragging) type.  
     */	
    public void setDrawState(int state,int type){
  	
	if (m_drawState==DrawConst.DRAWSTATE_DRAW && m_drawEvent!=null){
		m_drawEvent.terminateDrawing();
	}
	
	clearDrawState();
	
	if (state==DrawConst.DRAWSTATE_DRAW){
    		AbstractObject  obj	=m_objectFactory.createObj(type);
    		obj.setZoomScale(m_zoomScale);
    		setDrawState(state,type,obj);

    	}else if (state==DrawConst.DRAWSTATE_ROTATE){
    		m_drawState	=state;
    	}
    	
    }

    /** set current canvas state
     *  @param state A new canvas state for current canvas.
     *  @param type  A new current canvas shape(in drawing or dragging) type.  
     *  @param obj   A new current drawing shape.
     */	
    public void setDrawState(int state,int type,AbstractObject obj){
	clearDrawState();
    	m_drawState		=state;
    	m_shapeType		=type;
    	m_shape			=obj;
    }


   /** zoom scale.
    *  A zoom scale is internally used by almost all shapes.
    *  So we defiend zoom scale here for simplify class definitions.
    */
   private double m_zoomScale		=1.0;


    /** get zoom scale
     *  @return the zoom scale
     */	
    public double getZoomScale(){
    	return m_zoomScale;
    }

    /** set zoom scale
     *  @param zoomScale A new zoom scale.
     */	
    public void setZoomScale(double zoomScale){
    	m_zoomScale	=zoomScale;
    	if (m_shape!=null){
    		m_shape.setZoomScale(zoomScale);
    	}
    }


	 	
 }