svgcanvas.java~1~

完全基于java开发的svg矢量绘图工具

/*
 * Created on 23 mars 2004
 * 
 =============================================
 GNU LESSER GENERAL PUBLIC LICENSE Version 2.1
 =============================================
 GLIPS Graffiti Editor, a SVG Editor
 Copyright (C) 2003 Jordi SUC, Philippe Gil, SARL ITRIS
 
 This library is free software; you can redistribute it and/or
 modify it under the terms of the GNU Lesser General Public
 License as published by the Free Software Foundation; either
 version 2.1 of the License, or (at your option) any later version.
 
 This library is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 Lesser General Public License for more details.
 
 You should have received a copy of the GNU Lesser General Public
 License along with this library; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
 Contact : [e-mail]; [e-mail]
 
 =============================================
 */
package fr.itris.glips.svgeditor.canvas;

import java.awt.*;
import java.util.*;
import java.awt.dnd.*;
import org.w3c.dom.*;
import org.w3c.dom.svg.*;
import org.apache.batik.bridge.*;
import org.apache.batik.dom.svg.*;
import org.apache.batik.swing.*;
import org.apache.batik.gvt.*;
import org.apache.batik.gvt.event.*;
import fr.itris.glips.svgeditor.*;
import java.io.*;
import javax.swing.*;
import java.awt.geom.*;
import java.awt.image.*;

/**
 * @author Jordi SUC
 * the class of the canvas of a SVG file
 */
public class SVGCanvas extends JLayeredPane {
	
	/**
	 * the constant for the grid layer
	 */
	public static final int GRID_LAYER=0;
	
	/**
	 * the constant for the grid layer
	 */
	public static final int BOTTOM_LAYER=1;
	
	/**
	 * the constant for the grid layer
	 */
	public static final int SELECTION_LAYER=2;
	
	/**
	 * the constant for the grid layer
	 */
	public static final int DRAW_LAYER=3;
	
	/**
	 * the constant for the grid layer
	 */
	public static final int TOP_LAYER=4;
	
	/**
	 * the labels
	 */
	private static String 	documentCreatingLabel, documentLoadingLabel="", 
										buildStartedLabel="", renderingStartedLabel="";
	
	static {
		
		ResourceBundle bundle=SVGEditor.getBundle();
		
		if(bundle!=null){
			
			try{
				documentCreatingLabel=bundle.getString("canvasDocumentCreatingLabel");
				documentLoadingLabel=bundle.getString("canvasDocumentLoadingLabel");
				buildStartedLabel=bundle.getString("canvasBuildStartedLabel");
				renderingStartedLabel=bundle.getString("canvasRenderingStartedLabel");
			}catch (Exception ex){ex.printStackTrace();}
		}
	}
	
	/**
	 * whether to use the progress bar
	 */
	private boolean useMonitor=false;

	/**
	 * the canvas
	 */
	private JPanel canvas;
	
	/**
	 * the painters panel
	 */
	private JPanel paintersPanel;
	
	/**
	 * the canvas uri
	 */
	private String uri="";
	
	/**
	 * the canvas document
	 */
	private Document document;
	
	/**
	 * the user agent
	 */
	private UserAgentAdapter userAgent;
	
	/**
	 * the builder
	 */
    private GVTBuilder builder;
    
    /**
     * the bridge context
     */
    private BridgeContext ctx;
    
    /**
     * the update manager
     */
    private UpdateManager manager;
    
    /**
     * the update tracker
     */
    private CanvasGraphicsNodeChangeListener graphicsNodeChangeAdapter;
    
    /**
     * the root graphics node
     */
    private RootGraphicsNode gvtRoot;
    
    /**
     * the dirty areas to be updated
     */
    private java.util.List<Area> dirtyAreas=new LinkedList<Area>();
	
	/**
	 * the offscreen image of the canvas
	 */
	private BufferedImage canvasOffscreenImage=null;
	
	/**
	 * the rendered rectangle
	 */
	private Rectangle renderedRectangle=new Rectangle(0, 0, 1, 1), tmpRectangle=new Rectangle(0, 0, 0, 0);
	
	/**
	 * the scrollpane that contains the canvas
	 */
	private SVGScrollPane scrollpane;
	
	/**
	 * the file of the project this canvas is associated with
	 */
	private File projectFile=null;
	
	/**
	 * the map associating an id integer to the list of the paint listeners for a layer
	 */
	private final Map<Integer, Set<CanvasPaintListener>> paintListeners=Collections.synchronizedMap(new HashMap<Integer, Set<CanvasPaintListener>>());
	
	/**
	 * the boolean used by the repaint manager
	 */
	private boolean shouldRepaint=false;
	
	/**
	 * whether the svg content should be repainted or not
	 */
	private boolean shouldRepaintSVGContent=false;
	
	/**
	 * whether a part of the svg content should be updated or not
	 */
	private boolean shouldUpdateSVGContent=false;
	
	/**
	 * the boolean enabling or disabling the refresh action when a paint listener is added or removed
	 */
	private boolean repaintEnabled=true;
	
	/**
	 * the cursor that was set before the last change of the cursor
	 */	
	private Cursor lastCursor=null;
	
	/**
	 * the cursor used to show that the computer is busy and the default cursor
	 */
	private Cursor waitCursor, defaultCursor;
	
	/**
	 * the boolean enabling or disabling the wait cursor
	 */
	private boolean enableWaitCursor=true;
	
	/**
	 * whether the canvas is being disposed or not
	 */
	private boolean isDisposing=false;
	
	/**
	 * the paint manager
	 */
	private Thread paintManager=new CanvasRepaintManager();

	/**
	 * the canvas' current scale and last scale
	 */
	private double scale=1.0;
	
	/**
	 * the editor
	 */
	private SVGEditor editor=null;
	
	/**
	 * the svg frame
	 */
	private SVGFrame frame=null;
	
	/**
	 * the progress bar dialog
	 */
	private SVGProgressBarDialog progressBar=null;
	
	/**
	 * the drop target listener
	 */
	private CanvasDropTargetListener dropTargetListener=null;
	
	/**
	 * the drop target
	 */
	private DropTarget dropTarget=null;
	
	/**
	 * the constructor of the class
	 * @param editor the editor
	 * @param scrollpane the scrollpane into which the canvas will be inserted
	 */
	public SVGCanvas(SVGEditor editor, SVGScrollPane scrollpane) {

		this.editor=editor;
		this.scrollpane=scrollpane;
		this.frame=scrollpane.getSVGFrame();
		setDoubleBuffered(true);
		
		//creating the paint listeners map structure
		paintListeners.put(GRID_LAYER, Collections.synchronizedSet(new HashSet<CanvasPaintListener>()));
		paintListeners.put(BOTTOM_LAYER, Collections.synchronizedSet(new HashSet<CanvasPaintListener>()));
		paintListeners.put(SELECTION_LAYER, Collections.synchronizedSet(new HashSet<CanvasPaintListener>()));
		paintListeners.put(DRAW_LAYER, Collections.synchronizedSet(new HashSet<CanvasPaintListener>()));
		paintListeners.put(TOP_LAYER, Collections.synchronizedSet(new HashSet<CanvasPaintListener>()));
		
		//handling the cursors
		waitCursor=editor.getCursors().getCursor("wait");
		defaultCursor=editor.getCursors().getCursor("default");
	}
	
	/**
	 * initializes the canvas
	 * @param doc the document of the canvas
	 */
	protected void initializeCanvas(final Document doc){

		this.document=doc;
		
		//creating the canvas
		canvas=new JPanel(){
			
			@Override
			protected void paintComponent(Graphics g) {
				
				super.paintComponent(g);
				paintCanvas(g);
				
				//hiding the progress bar if it is not visible
				handleProgressBar(0, "", true, false);
			}
		};
		
		canvas.setBackground(Color.white);
		
		//creating the painters panel
		paintersPanel=new JPanel(){
			
			@Override
			public void paintComponent(Graphics g) {
				
				super.paintComponent(g);
				drawPainters((Graphics2D)g);
			}
		};
		
		paintersPanel.setDoubleBuffered(true);
		paintersPanel.setOpaque(false);
		
		//filling the layered pane
		add(canvas);
		setLayer(canvas, JLayeredPane.DEFAULT_LAYER, -1);
		add(paintersPanel);
		setLayer(paintersPanel, JLayeredPane.DEFAULT_LAYER, 0);
		
		if(useMonitor) {
			
			//the thread for creating the graphics node
			Thread thread=new Thread() {
				
				@Override
				public void run() {
				
					 initializeMain();
				}
			};
			
			thread.start();
			
		}else {
			
			 initializeMain();
		}
	}
	
	/**
	 * initializes the main elements
	 */
	protected void initializeMain() {
		
		//creating the graphics node
        try {
    		userAgent=new UserAgentAdapter();
    		ctx=new BridgeContext(userAgent);
            builder=new GVTBuilder();
            ctx.setDynamicState(BridgeContext.DYNAMIC);
            
        	handleProgressBar(50, buildStartedLabel, false, useMonitor);
            GraphicsNode gvt=builder.build(ctx, document);
            
            if(gvt!=null) {
            	
            	gvtRoot=gvt.getRoot();
            }
            
            if(useMonitor) {
            	
              	initializeRemaining();
                
            }else {
            	
                SwingUtilities.invokeLater(new Runnable() {
                	
                	public void run() {

                		initializeRemaining();
                	}
                });
            }
        }catch (Exception ex) {ex.printStackTrace();}
	}
	
	/**
	 * initializes the remaining elements
	 */
	protected void initializeRemaining() {

        //creating the update manager and tracker
        manager=new UpdateManager(ctx, gvtRoot, document);
        graphicsNodeChangeAdapter=new CanvasGraphicsNodeChangeListener();
        
        if(gvtRoot!=null) {
        	
        	gvtRoot.getRoot().addTreeGraphicsNodeChangeListener(graphicsNodeChangeAdapter);
        }
 
        //setting the size of the canvas
        Dimension scaledCanvasSize=getScaledCanvasSize();
        setCanvasPreferredSize(scaledCanvasSize);
		frame.displayFrame(scaledCanvasSize);
		
		//notifies that the frames contained in the frame manager has changed
		frame.getSVGEditor().getFrameManager().frameChanged();
		
		//creating the drop target listener
		dropTargetListener=new CanvasDropTargetListener(this, document);
		dropTarget=new DropTarget(this, dropTargetListener);
		dropTarget.setActive(true);
        
		frame.getStateBar().setSVGInfos("");
		
		//adds a dispose runnable
		getScrollPane().getSVGFrame().addDisposeRunnable(new Runnable(){
			
			public void run() {
				
				synchronized(SVGCanvas.this){isDisposing=true;}
				removeAll();
				
				if(projectFile!=null) {
					
					SVGEditor.getColorChooser().disposeColorsAndBlinkings(projectFile);
				}
				
		        if(gvtRoot!=null) {
		        	
		        	gvtRoot.getRoot().removeTreeGraphicsNodeChangeListener(graphicsNodeChangeAdapter);
		        }
				
				if(dropTarget!=null && dropTargetListener!=null){
					
					dropTarget.removeDropTargetListener(dropTargetListener);
					dropTarget.setActive(false);
					dropTarget.setComponent(null);
					dropTargetListener.dispose();
				}

				removeAllPaintListeners();
				paintListeners.clear();
				document=null;
				builder=null;
				
				if(ctx!=null) {
					
					ctx.dispose();
					ctx=null;
				}
				userAgent=null;
				
				if(manager!=null) {
					
					manager.interrupt();
					manager=null;
				}

				gvtRoot=null;
				canvasOffscreenImage=null;
				projectFile=null;
				
				if(progressBar!=null) {
					
					progressBar.disposeDialog();
					progressBar.dispose();
				}
			}
		});
		
        handleProgressBar(75, renderingStartedLabel, false, false);
        
		//starting the paint manager
		paintManager.start();
	}
	
	/**
	 * initialize the progress bar
	 * @param title the title
	 */
	protected void initializeProgressBar(String title) {
		
		if(useMonitor) {
			
			//creating the progress bar
	        if(SVGEditor.getParent() instanceof JFrame){
	        	
	        	progressBar=new SVGProgressBarDialog((JFrame)SVGEditor.getParent(), "");
	        	
	        }else{
	        	
	        	progressBar=new SVGProgressBarDialog(new JFrame(""), "");
	        }
	        
	        //setting the title and the cancel runnable
			progressBar.setTitle(scrollpane.getSVGFrame().getName());
			progressBar.setCancelRunnable(new Runnable(){
				
				public void run() {

					scrollpane.getSVGFrame().dispose();
				}
			});
			
			//showing the progress bar
			progressBar.setVisible(true);
		}
	}
	
	/**
	 * handles the progress bar
	 * @param value the current value
	 * @param label the label
	 * @param dispose whether the progress bar should be disposed
	 * @param useAWTThread whether to execute the action in the AWT thread explicitly
	 */
	protected void handleProgressBar(	final int value, final String label, 
																final boolean dispose, boolean useAWTThread) {
		
		if(useMonitor) {

			Runnable runnable=new Runnable() {
				
				public void run() {
					
					if(dispose) {
						
						 progressBar.setVisible(false);
						
					}else {
						
						progressBar.setProgressBarValueThreadSafe(value, 0, 100, label);
					}
				}
			};
			
			if(useAWTThread) {