svgselection.java~1~

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

/*
 * Created on 7 avr. 2004
 *
 =============================================
                   GNU LESSER GENERAL PUBLIC LICENSE Version 2.1
 =============================================
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.selection;

import fr.itris.glips.svgeditor.*;
import fr.itris.glips.svgeditor.menutool.*;
import fr.itris.glips.svgeditor.undoredo.*;
import fr.itris.glips.svgeditor.canvas.*;
import fr.itris.glips.svgeditor.resources.*;
import javax.swing.*;
import org.w3c.dom.*;
import java.awt.event.*;
import java.awt.*;
import java.awt.geom.*;
import java.util.*;

/**
 * @author Jordi SUC
 * the class managing the selections over the canvas
 */
public class SVGSelection extends SVGModuleAdapter{

    /**
     * the ids of the module
     */
    final private String idselection="Selection", idselectall="SelectAll", iddeselectall="DeselectAll", idlock="Lock", 
									idunlock="UnLock", idregularmode="RegularMode", idgroupmenu="GroupMenu", idgroupenter="EnterGroup", 
									idgroupexit="ExitGroup";

    /**
     * the labels
     */
    protected String labelselection="", labelselect="", labelselectall="", labeldeselectall="", labellock="", 
								labelunlock="", labelregularmode="", labelgroup="", labelgroupenter="", labelgroupexit="";

    /**
     * the undo/redo labels
     */
    protected String undoredoselect="", undoredodeselect="", undoredodeselectall="", undoredoselectall="", 
								undoredolock="", undoredounlock="", undoredogroupenter="", undoredogroupexit="";

    /**
     * the menu items that will be inserted into the menubar
     */
    private JMenuItem selectAll, deselectAll, lock, unlock, groupEnter, groupExit;
    
    /**
     * the listeners to the menu items
     */
    private ActionListener selectAllListener, deselectAllListener, lockListener, unlockListener, groupEnterListener, groupExitListener;
    
    /**
     * the group menu
     */
    private JMenu groupMenu;

    /**
     * the tool button corresponding to a regular selection
     */
    private JToggleButton regularModeTool=null;
    
    /**
     * the listener to the regular mode tool button
     */
    private ActionListener regularModeToolListener=null;

    /**
     * a reference to the current object of this class
     */
    private final SVGSelection selection=this;
    
    /**
     * whether the selection is enabled or not
     */
    private boolean isSelectionEnabled=true;
    
    /**
     * the map associating a frame to its selection manager
     */
    private Map selectionManagers=Collections.synchronizedMap(new Hashtable());
    
    /**
     * the listeners that are registered by other modules to be notified when a selection modification occurs
     */
    private LinkedList selectionListeners=new LinkedList();

    /**
     * the color for drawing the selected area
     */
    protected final Color LINE_SELECTION_COLOR=new Color(75, 100, 200),
    									LINE_SELECTION_COLOR_HIGHLIGHT=new Color(255,255,255);
    
	/**
	 * the stroke for the selection outlines
	 */
	protected static final BasicStroke lineStroke=new BasicStroke(	1, BasicStroke.CAP_BUTT, 
	        																										BasicStroke.JOIN_BEVEL, 
	        																										0, new float[]{5, 5}, 0);
    
    /**
     * the lastly selected nodes
     */
    private final java.util.List lastSelectedNodes=Collections.synchronizedList(new LinkedList());

    /**
     * the editor
     */
    private SVGEditor editor;

    /**
     * the constructor of the class
     * @param editor the editor
     */
    public SVGSelection(SVGEditor editor){

        this.editor=editor;

        //gets the labels from the resources
        ResourceBundle bundle=SVGEditor.getBundle();

        if(bundle!=null){
            
            try{
                labelselection=bundle.getString("labelselection");
                labelselectall=bundle.getString("labelselectall");
                labeldeselectall=bundle.getString("labeldeselectall");
                labellock=bundle.getString("labellock");
                labelunlock=bundle.getString("labelunlock");
                labelgroup=bundle.getString("labelgroup");
                labelgroupenter=bundle.getString("labelgroupenter");
                labelgroupexit=bundle.getString("labelgroupexit");
                labelregularmode=bundle.getString("labelregularmode");
                undoredoselect=bundle.getString("undoredoselect");
                undoredodeselect=bundle.getString("undoredodeselect");
                undoredodeselectall=bundle.getString("undoredodeselectall");
                undoredoselectall=bundle.getString("undoredoselectall");
                undoredolock=bundle.getString("undoredolock");
                undoredounlock=bundle.getString("undoredounlock");
                undoredogroupenter=bundle.getString("undoredogroupenter");
                undoredogroupexit=bundle.getString("undoredogroupexit");
            }catch (Exception ex){}
        }

        //the icons
        final ImageIcon 	regularModeIcon=SVGResource.getIcon(idregularmode, false),
        							regularModeDisabledIcon=SVGResource.getIcon(idregularmode, true);

		//getting the icons
		ImageIcon selectAllIcon=SVGResource.getIcon("SelectAll", false),
						dselectAllIcon=SVGResource.getIcon("SelectAll", true),
						deselectAllIcon=SVGResource.getIcon("DeselectAll", false),
						ddeselectAllIcon=SVGResource.getIcon("DeselectAll", true),
						lockIcon=SVGResource.getIcon("Lock", false),
						dlockIcon=SVGResource.getIcon("Lock", true),
						unlockIcon=SVGResource.getIcon("Unlock", false),
						dunlockIcon=SVGResource.getIcon("Unlock", true),
						groupEnterIcon=SVGResource.getIcon("GroupEnter", false),
						dgroupEnterIcon=SVGResource.getIcon("GroupEnter", true),
						groupExitIcon=SVGResource.getIcon("GroupExit", false),
						dgroupExitIcon=SVGResource.getIcon("GroupExit", true);
						
        
        //creates the menu items
        selectAll=new JMenuItem(labelselectall, selectAllIcon);
        selectAll.setDisabledIcon(dselectAllIcon);
        selectAll.setAccelerator(KeyStroke.getKeyStroke("ctrl A"));
        selectAll.setEnabled(false);
        
        deselectAll=new JMenuItem(labeldeselectall, deselectAllIcon);
        deselectAll.setDisabledIcon(ddeselectAllIcon);
        deselectAll.setAccelerator(KeyStroke.getKeyStroke("ctrl D"));
        deselectAll.setEnabled(false);

        lock=new JMenuItem(labellock, lockIcon);
        lock.setDisabledIcon(dlockIcon);
        lock.setEnabled(false);
        
        unlock=new JMenuItem(labelunlock, unlockIcon);
        unlock.setDisabledIcon(dunlockIcon);
        unlock.setEnabled(false);
        
        groupEnter=new JMenuItem(labelgroupenter, groupEnterIcon);
        groupEnter.setDisabledIcon(dgroupEnterIcon);
        groupEnter.setAccelerator(KeyStroke.getKeyStroke("shift ctrl E"));
        groupEnter.setEnabled(false);
        
        groupExit=new JMenuItem(labelgroupexit, groupExitIcon);
        groupExit.setDisabledIcon(dgroupExitIcon);
        groupExit.setAccelerator(KeyStroke.getKeyStroke("shift ctrl X"));
        groupExit.setEnabled(false);
        
        //the group menu
        groupMenu=new JMenu(labelgroup);
        groupMenu.add(groupEnter);
        groupMenu.add(groupExit);

        //creates the tool items
        regularModeTool=new JToggleButton(regularModeDisabledIcon);
        regularModeTool.setEnabled(false);
        regularModeTool.setSelected(true);
        regularModeTool.setToolTipText(labelregularmode);
        
        //a listener that listens to the changes of the SVGFrames
        final ActionListener svgframeListener=new ActionListener(){

            /**
             * a listener on the selection changes
             */
            private ActionListener selectionListener=null;

            public void actionPerformed(ActionEvent e) {

            	//clears the last selection
            	lastSelectedNodes.clear();
            	
                //deals with the state of the menu items
                if(getSVGEditor().getFrameManager().getFrameNumber()>0){

                    selectAll.setEnabled(true);
                    deselectAll.setEnabled(true);
                    regularModeTool.setEnabled(true);
                    regularModeTool.setIcon(regularModeIcon);

                }else{

                    selectAll.setEnabled(false);
                    deselectAll.setEnabled(false);
                    regularModeTool.setEnabled(false);
                    regularModeTool.setIcon(regularModeDisabledIcon);
                }

                //disables the menuitems
                lock.setEnabled(false);
                unlock.setEnabled(false);
                groupEnter.setEnabled(false);
                groupExit.setEnabled(false);

                SVGSelectionManager selectionManager=null;
                Collection frames=getSVGEditor().getFrameManager().getFrames();
                
                for(Iterator it=new LinkedList(selectionManagers.values()).iterator(); it.hasNext();){
                    
                    try{selectionManager=(SVGSelectionManager)it.next();}catch (Exception ex){selectionManager=null;}

                    if(selectionManager!=null && ! frames.contains(selectionManager.getSVGFrame())){

                        selectionManagers.remove(selectionManager.getSVGFrame());
                        selectionManager.dispose();
                    }
                }

                SVGFrame frame=null;
                
                //adds the new mouse motion and key listeners
                for(Iterator it=frames.iterator(); it.hasNext();){

                    try{frame=(SVGFrame)it.next();}catch (Exception ex){frame=null;}

                    if(frame!=null && ! selectionManagers.containsKey(frame)){
                        
                        selectionManagers.put(frame, new SVGSelectionManager(selection, frame));
                    }
                }

                frame=getSVGEditor().getFrameManager().getCurrentFrame();

                if(frame!=null){

                    manageSelection();

                    //the listener to the selection changes
                    selectionListener=new ActionListener(){

                        public void actionPerformed(ActionEvent e) {

                            manageSelection();
                        }
                    };
                    
                    //adds the selection listener
                    if(selectionListener!=null){
                        
                        selection.addSelectionListener(selectionListener);
                    }
                }
            }

            /**
             * updates the selected items and the state of the menu items
             */
            protected void manageSelection(){

                SVGFrame currentFrame=getSVGEditor().getFrameManager().getCurrentFrame();
                
                //disables the menuitems
                deselectAll.setEnabled(false);
                lock.setEnabled(false);
                unlock.setEnabled(false);
                groupEnter.setEnabled(false);

                //getting the current parent node for the current frame
                Element parent=getCurrentParentElement(currentFrame);
                
                //handling the enablement of the groupExit menuItem
                if(parent!=null && parent.getNodeName().equals("g")){
                    
                    groupExit.setEnabled(true);
                    
                }else{
                    
                    groupExit.setEnabled(false);
                }

                Node current=null;
                String type="";

                //gets the currently selected nodes list
                Map selectedNodes=getSelectionMap(currentFrame);

                if(selectedNodes.size()>0){

                    lock.setEnabled(true);
                    deselectAll.setEnabled(true);
                    
                    //if the node is already locked
                    if(selectedNodes.size()==1){
                        
                        try{
                            current=(Node)selectedNodes.keySet().iterator().next();
                            type=(String)selectedNodes.get(current);
                            
                            if(type.equals("lock")){
                                
                                lock.setEnabled(false);
                                
                            }else if(current.getNodeName().equals("g")){
                                
                                groupEnter.setEnabled(true);
                            }
                        }catch (Exception ex){}
                    }

                    for(Iterator it=selectedNodes.keySet().iterator(); it.hasNext();){

                        try{current=(Node)it.next();}catch (Exception ex){current=null;}

                        if(current!=null){

                            type=(String)selectedNodes.get(current);

                            if(type!=null && type.equals("lock")){

                                unlock.setEnabled(true);
                                break;
                            }
                        }
                    }
                }
            }
        };

        //adds the SVGFrame change listener
        editor.getFrameManager().addSVGFrameChangedListener(svgframeListener);

        //adds the listener on the menu items and tool items
        regularModeToolListener=new ActionListener(){

            public void actionPerformed(ActionEvent e) {