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

import javax.swing.JComponent;
import javax.swing.JPanel;
import javax.swing.JSplitPane;
import javax.swing.BoxLayout;
import javax.swing.JScrollPane;
import javax.swing.BorderFactory;

import java.awt.BorderLayout;
import java.awt.Dimension;
import java.awt.Color;
import java.awt.Graphics;

import com.jfimagine.jfdraw.gui.Ruler;
import com.jfimagine.jfdraw.gui.DrawCanvas;
import com.jfimagine.jfdraw.gui.GlobalSettings;


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

import com.jfimagine.jfgraph.shape.base.ObjectList;
import com.jfimagine.jfgraph.shape.union.JFPage;
import com.jfimagine.jfgraph.shape.union.JFLayer;
import com.jfimagine.jfgraph.transfer.JFFileFilter;

import com.jfimagine.utils.log.*; 


 /**
 * Draw pane class. A main drawing pane with rulers, scrollbars and drawing canvas inside.
 *
 * @author     CookieMaker    
 *
 * @version $Revision: 1.3.0 $
 */  
 public class DrawPane extends DrawAdapter {

   	/**an internal log utility*/
   	private JFLogger m_logger=JFLogManager.getLogger(this.getClass());
   	
   		
	/** Horizontal and vertical rulers.*/
    	protected Ruler m_columnView;
    	protected Ruler m_rowView;
	
	/** Drawing Canvas*/    	
    	protected DrawCanvas   m_drawCanvas;
    	
    	/** parent draw frame */
    	protected DrawFrame    m_parentDrawFrame;

	protected JScrollPane  m_drawScrollPane;

 	
 	/** if hide rulers **/
 	protected boolean     m_hideRulers	=false;
 	
 	/** if hide scrollbars 
 	 *  Since rulers are part of this scroll panes, so hide scroll bars would also hide rulers.
 	 **/
 	protected boolean     m_hideScrollbars	=false;

 	/** A tool factory to notify object select events to ToolBar controls.
 	 * we will not create menus and buttons here by toolFactory.
 	 */
 	private ToolFactory m_toolFactory	=new ToolFactory();
 	
	/** if hide rulers now */	
	public boolean isHideRulers(){
		return m_hideRulers;
	}
	/** set if hide rulers */
	public void setHideRulers(boolean hideRulers){
		if (hideRulers!=m_hideRulers){
			if (hideRulers){
        			m_drawScrollPane.setColumnHeaderView(null);
        			m_drawScrollPane.setRowHeaderView(null);
        		}else{
        			m_drawScrollPane.setColumnHeaderView(m_columnView);
        			m_drawScrollPane.setRowHeaderView(m_rowView);
        		}
			m_hideRulers	=hideRulers;	
			validate();
		}
	}
	
	/** if hide scrollbars now */	
	public boolean isHideScrollbars(){
		return m_hideScrollbars;
	}
	/** set if hide scrollbars */
	public void setHideScrollbars(boolean hideScrollbars){
		if (hideScrollbars!=m_hideScrollbars){
			if (hideScrollbars){
				remove(m_drawScrollPane);  
				add(m_drawCanvas);
        		}else{
        			remove(m_drawCanvas);
        			add(m_drawScrollPane);
        		}
			m_hideScrollbars	=hideScrollbars;	
			validate();
		}
	}

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

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

    	/** if use page bounds to restrict drawing */	
    	public boolean isUsePageBounds(){
		return m_drawCanvas.isUsePageBounds();
    	}
    	/** set if use page bounds to restrict drawing */
    	public void setUsePageBounds(boolean usePageBounds){
    		m_drawCanvas.setUsePageBounds(usePageBounds);
    		setPageFormat(m_drawCanvas.getDrawPage().getPageFormat().getPageFormat());
    	}
    	
	/** Constructor */
    	public DrawPane() { 
        	initComponents();
    	}

	/** Constructor 
	 * @param initIt True if initiate components, false otherwise.
	 *               If you use false here to avoid initiating components when constructing,
	 *               you need to call initComponents immediately.
	 */
    	public DrawPane(boolean initIt) { 
    		if (initIt)
    			initComponents();
	}

	/**
	 *  Init all gui components of this DrawPane.
	 */        
        public void initComponents(){
		//get a global settings instance:(this get operation will make some initialization)
            	GlobalSettings settings	=GlobalSettings.getInstance();

        	setLayout(new BoxLayout(this, BoxLayout.X_AXIS));


        	//set up the column views,i.e. rulers.
        	m_columnView = new Ruler(JFRuler.HORIZONTAL, true);
        	m_rowView = new Ruler(JFRuler.VERTICAL, true);
		
		//default canvas format.
		CanvasFormat canvasFormat	=CanvasFormat.getDefaultCanvasFormat();
		canvasFormat.setIsMetric(settings.isMetric());
		Dimension d	=new Dimension((int)canvasFormat.getScreenWidth(),(int)canvasFormat.getScreenHeight());
		
            	m_columnView.setPreferredWidth((int)d.getWidth());
            	m_rowView.setPreferredHeight((int)d.getHeight());
            	
        	//Set up the main draw canvas 
        	m_drawCanvas  = newDrawCanvas();
        	m_drawCanvas.setOriginalSize(d);
        	m_drawCanvas.setParentDrawPane(this);
		
		//reset draw page parameters on rulers.
		m_columnView.setDrawPage(m_drawCanvas.getDrawPage());
		m_rowView.setDrawPage(m_drawCanvas.getDrawPage());        	
		
            	m_columnView.setIsMetric(settings.isMetric());
            	m_rowView.setIsMetric(settings.isMetric());
        	m_drawCanvas.setIsMetric(settings.isMetric());
        	
        	//set up the scroll pane.
        	m_drawScrollPane = new JScrollPane(m_drawCanvas);
        	m_drawScrollPane.setPreferredSize(d);
        	m_drawScrollPane.setViewportBorder(
                	BorderFactory.createLineBorder(Color.black));

        	m_drawScrollPane.setColumnHeaderView(m_columnView);
        	m_drawScrollPane.setRowHeaderView(m_rowView);

		//Set the corners.
        	//In theory, to support internationalization you would change
        	//UPPER_LEFT_CORNER to UPPER_LEADING_CORNER,
        	//LOWER_LEFT_CORNER to LOWER_LEADING_CORNER, and
        	//UPPER_RIGHT_CORNER to UPPER_TRAILING_CORNER.  In practice,
        	//bug #4467063 makes that impossible (in 1.4, at least).
        	m_drawScrollPane.setCorner(JScrollPane.UPPER_LEFT_CORNER,
                                    new Corner());
        	m_drawScrollPane.setCorner(JScrollPane.LOWER_LEFT_CORNER,
                                    new Corner());
        	m_drawScrollPane.setCorner(JScrollPane.UPPER_RIGHT_CORNER,
                                    new Corner());

        	//Put it in this panel.
        	add(m_drawScrollPane);
        	
        	validate();
        	
        	//setBorder(BorderFactory.createEmptyBorder(20,20,20,20));
        	
        	m_drawCanvas.requestFocus();
    	} 	
        
        /**
         *  to create a new instance of DrawCanvas class
         *  @return A new DrawCanvas object.
         */
        protected DrawCanvas newDrawCanvas(){
        	return new DrawCanvas(this,m_columnView.getIncrementDouble());
	}


	private class Corner extends JComponent {
    		protected void paintComponent(Graphics g) {
        	
        	// Fill me with light gray.
		g.setColor(getBackground());
        	g.fillRect(0, 0, getWidth(), getHeight());
    		}
	}

    	
	/** get current Drawing Canvas
	 * @return Current drawing canvas.
	 */    	
	public DrawCanvas  getDrawCanvas(){
		return  m_drawCanvas;
	}
        
        /**
         *  get current scroll pane. 
         */
	public JScrollPane  getScrollPane(){
		return m_drawScrollPane;
	}

    	/** set zoom scale
     	*  @param zoomScale A new zoom scale.
     	*/	
    	public void setZoomScale(double zoomScale){
    		m_columnView.setZoomScale(zoomScale);
    		m_rowView.setZoomScale(zoomScale);
    	}

    	/** set ruler as metric or english measurement.
     	*  @param isMetric True if is metric, false english.
     	*/	
    	public void setIsMetric(boolean isMetric){
    		
    		
            	m_columnView.setIsMetric(isMetric);
            	m_rowView.setIsMetric(isMetric);
            	m_drawCanvas.setIsMetric(isMetric);  
            	
            	//set current canvas format, then adjust all components that related to CanvasFormat.
            	getCanvasFormat().setIsMetric(isMetric);
            	setCanvasFormat(getCanvasFormat());
       }

    	/** get if ruler is a metric one.
     	*  @return True if is metric, false english.
     	*/	
    	public boolean getIsMetric(){ 
    		return m_columnView.isMetric();
    	}

   	/**
    	*   Get page format.
    	* 
    	*   @return  The page format.
    	*
    	*/ 	
   	public JFPageFormat getPageFormat(){
   		return m_drawCanvas.getPageFormat();
   	}    	

   	/**
    	*   Set page format.
    	* 
    	*   @param pageFormat A new page format.
    	*
    	*/ 	
   	public void setPageFormat(PageFormat pageFormat){  
   		m_drawCanvas.setPageFormat(pageFormat);
   	}    	

   	/**
    	*   Get canvas format.
    	* 
    	*   @return  The canvas format.
    	*
    	*/ 	
   	public CanvasFormat getCanvasFormat(){
   		return m_drawCanvas.getCanvasFormat();
   	}    	

   	/**
    	*   Set canvas format.
    	* 
    	*   @param canvasFormat A new canvas format.
    	*
    	*/ 	
   	public void setCanvasFormat(CanvasFormat canvasFormat){ 
   		Dimension d	=new Dimension((int)canvasFormat.getScreenWidth(),(int)canvasFormat.getScreenHeight());
   		
   		m_drawCanvas.setCanvasFormat(canvasFormat);
    		if (!m_drawCanvas.isUsePageBounds()){
    			m_drawCanvas.setOriginalSize(getSize());
    			m_drawCanvas.setPreferredSize(getSize());
    			m_drawCanvas.setSize(getSize());
    		}else{	
   			m_drawCanvas.setOriginalSize(d);
   			m_drawCanvas.setPreferredSize(d);
   			m_drawCanvas.setSize(d);
   		}
		m_columnView.setPreferredWidth((int)d.getWidth());
            	m_rowView.setPreferredHeight((int)d.getHeight()); 
   	}

  		

    	/** new file operation.
    	 *  This operation should generate a new drawing page.
    	 */
    	public void newFile(){
    		m_drawCanvas.getDrawPage().newPage();
    		m_drawCanvas.setFileName("");
    		m_drawCanvas.getSelection().clear();
		setLayerName(JFLayer.LAYER_NAME_DEFAULT);    		
    		m_drawCanvas.repaint();
    	}

    	/** open a specified file
    	 * @param fileName A spcified file name
    	 */
    	public boolean openFile(String fileName){ 
    		if (fileName==null || fileName.equals(""))
    			return false; 
    		
    		fileName	=fileName.trim();
    			
    		try{
			JFPage page	=m_drawCanvas.getDrawPage();

			if (fileName.endsWith(JFFileFilter.FILEEXT_DRAW)){
				page.loadFromBinary(fileName,m_drawCanvas);
			}else if (fileName.endsWith(JFFileFilter.FILEEXT_DRAW_XML)){
				page.loadFromXML(fileName,m_drawCanvas);
			}else
				return false;
			
			m_drawCanvas.setFileName(fileName); 
    			m_drawCanvas.getSelection().clear();

                        JFLayer	layer=page.getCurrentLayer();
                        if (layer!=null){
                        	setLayerName(layer.getName());
        		}
	
			setPageFormat(page.getPageFormat().getPageFormat());

						
			return true;
		
		}catch(Exception e){
			m_logger.error("openFile: "+e);
			return false;
		}
    	}


    	/** Save current page to a specified file.
    	 *  @param  fileName A file to be saved into.
    	 */
    	public boolean saveFile(String fileName){    
    		if (fileName==null || fileName.equals(""))
    			return false;
    			
                try{
			JFPage page	=m_drawCanvas.getDrawPage();
			
			if (fileName.endsWith(JFFileFilter.FILEEXT_DRAW)){
				//binary JFDraw file
				if (!page.saveToBinary(fileName))
					return false;
			}else{
				//xml JFDraw file.
				if (!page.saveToXML(fileName))
					return false;
			}
                        
                        //set global path.
    			GlobalSettings m_settings	=GlobalSettings.getInstance();
                        m_settings.setGlobalPath(fileName);
                        
			setFileName(fileName);

			return true;
               
    		} catch(Exception e) {
			m_logger.error("saveFile: "+e);
    		} 
  
  		return false;
    	}


    	/** get the file name of current opened page.
    	 *  @return the file name
    	 */
    	public String getFileName(){
    		return m_drawCanvas.getFileName();
    	}

    	/** set the file name of current opened page.
    	 *  @param  fileName A new file name
    	 */
    	public void setFileName(String fileName){ 
    		m_drawCanvas.setFileName(fileName);
    	}


    	/** Notify object selected, tell to do some changes in the drawing framework.
    	 *  
    	 *  @param  objList A new selected object list.
    	 *
    	 */
    	public void notifyObjectSelected(ObjectList objList) {
    		m_toolFactory.notifyObjectSelected(objList);
    	}
    	            	    	
 }