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

import java.util.Iterator;

import java.awt.Color;
import java.awt.Dimension;
import java.awt.Rectangle;
import java.awt.BorderLayout;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.RenderingHints;

import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.event.MouseMotionListener;
import java.awt.event.KeyListener;
import java.awt.event.KeyEvent;
import java.awt.event.ActionEvent;



import javax.swing.JPanel;
import javax.swing.Scrollable;
import javax.swing.SwingConstants;   
import javax.swing.JScrollPane;

import com.jfimagine.jfgraph.shape.union.JFPage;
import com.jfimagine.jfgraph.shape.base.ShapeConst;
import com.jfimagine.jfgraph.shape.base.AbstractShape;
import com.jfimagine.jfgraph.shape.base.ObjectList;
import com.jfimagine.jfgraph.shape.action.JFOperationManager;

import com.jfimagine.jfgraph.shape.line.JFQuadrant;
import com.jfimagine.jfgraph.shape.union.JFLayer;

import com.jfimagine.jfgraph.shape.decorate.GridFormat;
import com.jfimagine.jfgraph.shape.decorate.FontFormat;
import com.jfimagine.jfgraph.shape.decorate.LineFormat;  
import com.jfimagine.jfgraph.shape.decorate.CanvasFormat;

import java.awt.print.PageFormat;
import com.jfimagine.jfgraph.shape.decorate.JFPageFormat;

import com.jfimagine.jfgraph.geom.GeomConst;
import com.jfimagine.jfgraph.geom.Rect;
import com.jfimagine.jfgraph.geom.JFPoint;
import com.jfimagine.jfgraph.geom.JFPoint;

import com.jfimagine.jfdraw.draw.DrawState;
import com.jfimagine.jfdraw.draw.AbstractDrawEvent;
import com.jfimagine.jfdraw.draw.EventDispatcher;
import com.jfimagine.jfdraw.draw.DrawConst;
import com.jfimagine.jfdraw.draw.Selection;

import com.jfimagine.jfdraw.gui.GlobalSettings;




 /**
 * Drawing canvas class. A main drawing canvas used to draw or show graphs.
 *
 * @author     CookieMaker    
 *
 * @version $Revision: 1.3.0 $
 */ 
public class DrawCanvas extends JPanel  
			implements Scrollable,MouseListener,MouseMotionListener,KeyListener {

    /** for scrolling increment. */
    private double m_maxUnitIncrement = 1;

    private boolean m_isMetric  =true;
    
    /** for event processing.*/
    private EventDispatcher m_eventDispatcher;
    
    /** current draw state.*/
    private DrawState	m_drawState;

    /** A CAD page for each canvas.*/
    private JFPage m_page=new JFPage(); 
    
    /** An operation manager for undo and redo */
    private JFOperationManager m_operationManager = new JFOperationManager(m_page);

    /** A CAD selection for current shape objects.*/
    private Selection m_selection=new Selection(this);
    
    /** Last mouse position on this canvas.*/
    private JFPoint m_lastMousePos	=new JFPoint();
    
    /** grid of this canvas.*/
    private GridFormat m_gridFormat	=new GridFormat();
    
    /** zoom scale.*/
    private double m_zoomScale		=1.0;

    /** original canvas dimension.*/
    private Dimension m_originalSize	=new Dimension();
    
    /** parent draw pane */
    private DrawPane m_parentDrawPane;
    
    /** if hide grids */
    private boolean m_hideGrids	=false;

    /** if hide popup menus */
    private boolean m_hidePopupMenus	=false;

    /** if use page bounds to restrict drawing*/
    private boolean m_usePageBounds	=true;   
    
    /** graph file name **/
    private String m_fileName		=""; 
    
    /** background color for drawing canvas */
    private Color m_backgroundColor	=Color.white;   
    
    /** if current drawing canvas is under a reversed color */
    private boolean m_isReverse	=false;
   
    /** 
     *  Constructor
     *  @param maxIncrement A max increment unit for scrolling.
     */ 
    public DrawCanvas(DrawAdapter drawAdapter,double maxUnitIncrement) {
	
	setLayout(new java.awt.BorderLayout());
	
	if (drawAdapter!=null && drawAdapter instanceof DrawPane){
		m_parentDrawPane	=(DrawPane)drawAdapter;
	}
                
        m_drawState	=new DrawState();
	m_drawState.setDrawState(DrawConst.DRAWSTATE_NONE,ShapeConst.SHAPETYPE_NONE); 

        m_eventDispatcher	=new EventDispatcher(drawAdapter,this);

	
        setOpaque(true);
        setBackground(m_backgroundColor);
        m_maxUnitIncrement = maxUnitIncrement;

        //Let the user scroll by dragging to outside the window.
        setAutoscrolls(true); //enable synthetic drag events
        addMouseListener(this); //handle mouse events(e.g. click, press,release)
        addMouseMotionListener(this); //handle mouse events(e.g. move, drag)
        addKeyListener(this);//handle key events
        
        GlobalSettings settings	=GlobalSettings.getInstance();
        m_gridFormat.setIsMetric(settings.isMetric()); 
        m_page.setIsMetric(settings.isMetric());  
        
	//copy global settings to page settings
        m_page.setHidePorts(settings.isHidePorts());
        m_page.setDisablePortSnapping(settings.isDisablePortSnapping());
        m_page.setScaleValue(settings.getScaleValue());
        m_page.setScaleUnit(settings.getScaleUnit());
        m_page.setScreenUnit(settings.getScreenUnit()); 

    } 

    public boolean isMetric() {
        return m_isMetric;
    }

    public void setIsMetric(boolean isMetric) {
        this.m_isMetric = isMetric;
	
	//set gridformat to metric/english        
        getGridFormat().setIsMetric(isMetric);
	//set draw page to metric/english.        
        getDrawPage().setIsMetric(isMetric);
    }

    /** if hide grids now */	
    public boolean isHideGrids(){
	return m_hideGrids;
    }
    /** set if hide grids */
    public void setHideGrids(boolean hideGrids){
    	m_hideGrids	=hideGrids;
    }

    /** if hide popupmenus  now */	
    public boolean isHidePopupMenus(){
	return m_hidePopupMenus;
    }
    /** set if hide popupmenus */
    public void setHidePopupMenus(boolean hidePopupMenus){
    	m_hidePopupMenus	=hidePopupMenus;
    }

    /** if use page bounds(or the bounds of a canvas format) to restrict drawing */	
    public boolean isUsePageBounds(){
	return m_usePageBounds;
    }
    /** set if use page bounds(or the bounds of a canvas format) to restrict drawing */
    public void setUsePageBounds(boolean usePageBounds){
    	m_usePageBounds	=usePageBounds;
    }


    /** get the background color for drawing canvas 
     *  @return the background color
     */
    public Color getBackgroundColor(){
    	return m_backgroundColor;
    }
    
    /** set the background color for drawing canvas 
     *  @param A new background color for drawing canvas
     */
    public void setBackgroundColor(Color color){
    	if (color!=null)
    		m_backgroundColor	=new Color(color.getRGB());
    }

    /** get if current current drawing canvas is under a reverse color.
     *  @return True if is reversed, false otherwise.
     */
    public boolean isReverse(){
    	return m_isReverse;
    }
    
    /** set if current current drawing canvas is under a reverse color.
     *  @param reverse True if is reversed, false otherwise.
     */
    public void setReverse(boolean reverse){
    	  m_isReverse	=reverse;
    	  
    	  if (reverse){
    	  	setBackgroundColor(Color.black);
    	  	FontFormat.getDefaultFontFormat().setFontColor(Color.white);
    	  	LineFormat.getDefaultLineFormat().setLineColor(Color.white);
    	  }else{
    	  	setBackgroundColor(Color.white);
    	  	FontFormat.getDefaultFontFormat().setFontColor(Color.black);
    	  	LineFormat.getDefaultLineFormat().setLineColor(Color.black);
    	  }
    	
    }


    /** get graph file name */
    public String getFileName(){
    	return m_fileName;
    }	

    /** set graph file name */
    public void setFileName(String fileName){
    	m_fileName	=fileName;
    }	


    /** get current grid format
     *  @return the grid format.
     */	
    public GridFormat getGridFormat(){
    	return m_gridFormat;
    }

    /** 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){

    	clearCanvas(null);
    	
    	if (zoomScale<0.25) zoomScale	=0.25;
    	
    	m_zoomScale	=zoomScale;
    	if (m_page.getZoomScale()!=zoomScale){
    		m_page.setZoomScale(zoomScale);
    	}
    	m_drawState.setZoomScale(zoomScale);
    	GeomConst.setZoom(zoomScale);
    	
    	Dimension d	=new Dimension((int)(m_originalSize.getWidth() * m_zoomScale),(int)(m_originalSize.getHeight() * m_zoomScale));
    	setPreferredSize(d);
    	setSize(d);
    	
    	if (m_parentDrawPane!=null)
    		m_parentDrawPane.setZoomScale(zoomScale);
    }
	
    /** 
     *  get view center of this canvas
     *  @return the center point of the view rectangle of this canvas
     */	
   public JFPoint getViewCenter(){

	double x	=0;
	double y	=0;
        double width	=0;
        double height	=0;

	DrawPane pane	=getParentDrawPane();
   	if (!pane.isHideScrollbars()){
   		JScrollPane	scrollPane	=getParentDrawPane().getScrollPane();
   		//view rectangle
   	        Rectangle	viewRect	=scrollPane.getViewport().getViewRect();
	
		x	=viewRect.getX()/m_zoomScale;
		y	=viewRect.getY()/m_zoomScale;
        	width	=viewRect.getWidth()/m_zoomScale;
        	height	=viewRect.getHeight()/m_zoomScale;
        }else{
        	Dimension	d		=getSize();
        	x	=0;
        	y	=0;
        	width	=d.getWidth()/m_zoomScale;
        	height	=d.getHeight()/m_zoomScale;
	}
        
        //actual page size
        double pageWidth	=m_page.getPageFormat().getWidth();
        double pageHeight	=m_page.getPageFormat().getHeight();
        
        //width different if the view rect exceed the actual page size.
        double widthDiff	=x+width-pageWidth*JFPageFormat.INCH_SCREEN/JFPageFormat.INCH;
        double heightDiff	=y+height-pageHeight*JFPageFormat.INCH_SCREEN/JFPageFormat.INCH; 
        
        
        if (widthDiff>0){
        	width	-=widthDiff;
        	if (width<0) width=0;
	}
	if (heightDiff>0){
		height	-=heightDiff;
		if (height<0) height=0;
	}
        
        return new JFPoint(x+width/2,y+height/2);
   }


    /** get original size
     *  @return the original size
     */	
    public Dimension getOriginalSize(){
    	return m_originalSize;
    }

    /** set original size
     *  @param originalSize A new original size.
     */	
    public void setOriginalSize(Dimension originalSize){
    	m_originalSize.setSize(originalSize);
    	setPreferredSize(new Dimension((int)(m_originalSize.getWidth() * m_zoomScale),(int)(m_originalSize.getHeight() * m_zoomScale)));
    }

    
    /** get current draw state*/	
    public DrawState getDrawState(){
    	return m_drawState;
    }

    /** set current draw state
     *  @param drawState A new draw state.
     */	
    public void setDrawState(DrawState drawState){
    	m_drawState	=new DrawState(drawState);
    }

    /** set parent draw pane
     *  @param drawPane a new parent drawPane
     */	
    public void setParentDrawPane(DrawPane drawPane){
    	m_parentDrawPane	=drawPane;
    }

    /** get parent draw pane
     *  @return the parent draw pane of this draw canvas.
     */	
    public DrawPane getParentDrawPane(){
    	return m_parentDrawPane;
    }


    /** get last mouse position on this canvas.