Application: gvSIG desktop

package com.iver.cit.gvsig;

import java.awt.Component;

import java.awt.Toolkit;

import java.awt.datatransfer.DataFlavor;

import java.awt.datatransfer.StringSelection;

import java.awt.datatransfer.Transferable;

import java.awt.datatransfer.UnsupportedFlavorException;

import java.awt.event.ActionEvent;

import java.io.IOException;

import java.io.StringReader;

import java.io.StringWriter;

import java.util.ArrayList;

import javax.swing.JMenuItem;

import javax.swing.JOptionPane;

import org.exolab.castor.xml.MarshalException;

import org.exolab.castor.xml.Marshaller;

import org.exolab.castor.xml.ValidationException;

import com.hardcode.gdbms.engine.data.DataSourceFactory;

import com.iver.andami.PluginServices;

import com.iver.andami.plugins.Extension;

import com.iver.cit.gvsig.fmap.DriverException;

import com.iver.cit.gvsig.fmap.layers.CancelationException;

import com.iver.cit.gvsig.fmap.layers.FLayer;

import com.iver.cit.gvsig.fmap.layers.FLayers;

import com.iver.cit.gvsig.fmap.layers.LayerFactory;

import com.iver.cit.gvsig.fmap.layers.XMLException;

import com.iver.cit.gvsig.fmap.layers.layerOperations.AlphanumericData;

import com.iver.cit.gvsig.gui.project.OpenException;

import com.iver.cit.gvsig.gui.project.SaveException;

import com.iver.cit.gvsig.gui.toc.FPopupMenu;

import com.iver.cit.gvsig.gui.toc.TocMenuEntry;

import com.iver.cit.gvsig.project.Project;

import com.iver.cit.gvsig.project.ProjectTable;

import com.iver.utiles.XMLEntity;

import com.iver.utiles.xmlEntity.generate.XmlTag;

public class CopyPasteLayersExtension extends Extension {

        public void initialize() {

                myTocMenuEntry copy = new CopyTocMenuEntry();

                myTocMenuEntry cut = new CutTocMenuEntry();

                myTocMenuEntry paste = new PasteTocMenuEntry();

                Utiles utiles = new Utiles();

                copy.setUtiles(utiles);

                cut.setUtiles(utiles);

                paste.setUtiles(utiles);

            FPopupMenu.addEntry(copy);

            FPopupMenu.addEntry(cut);

            FPopupMenu.addEntry(paste);

        }

        public void execute(String actionCommand) {

                // TODO Auto-generated method stub

        }

        public boolean isEnabled() {

                return false;

        }

        public boolean isVisible() {

                return false;

        }

}

abstract class  myTocMenuEntry extends TocMenuEntry {        

        protected Utiles utiles;

        protected JMenuItem addMenuEntry(String title) {

                JMenuItem menuEntry = new JMenuItem(title);

                menuEntry.setFont(FPopupMenu.theFont);

                menuEntry.addActionListener(this);

                getMenu().add( menuEntry );                

                return menuEntry;

        }

        public void setUtiles(Utiles utiles) {

                this.utiles = utiles;

        }

}

class CopyTocMenuEntry extends myTocMenuEntry{

        private JMenuItem properties;

        public void initialize(FPopupMenu m) {

                super.initialize(m);

                getMenu().addSeparator();

                properties = addMenuEntry(PluginServices.getText(this, "copiar"));

                FLayer[] actives = getMapContext().getLayers().getActives();

                if (actives.length >= 1) {

                        properties.setEnabled(true);                                

                } else {

                        properties.setEnabled(false);

                }

        }

        public void actionPerformed(ActionEvent e) {

                FLayer[] actives = getMapContext().getLayers().getActives();

                XMLEntity xml = this.utiles.generateXML(actives);

                if (xml == null) {

                        //TODO: arreglar esto

                        return;

                }

                String data = this.utiles.marshallXMLEntity(xml);

                if (data == null) {

                        //TODO: arreglar esto

                        return;

                }

                /*

                System.out.println("==============================================================");

                System.out.println(data);

                System.out.println("==============================================================");

                System.out.flush();

                */

                this.utiles.putInClipboard(data);                

        }

}

class CutTocMenuEntry extends myTocMenuEntry{

        private JMenuItem properties;

        public void initialize(FPopupMenu m) {                

                super.initialize(m);                        

                properties = addMenuEntry(PluginServices.getText(this, "cortar"));

                FLayer[] actives = getMapContext().getLayers().getActives();

                if (actives.length >=1) {

                        properties.setEnabled(true);                                

                } else {

                        properties.setEnabled(false);

                }

        }

        public void actionPerformed(ActionEvent e) {

                FLayer[] actives = getMapContext().getLayers().getActives();

                if (actives.length< 1) {

                    return;

            }

                XMLEntity xml = this.utiles.generateXML(actives);

                if (xml == null) {

                        //TODO: arreglar esto

                        return;

                }

                String data = this.utiles.marshallXMLEntity(xml);

                if (data == null) {

                        //TODO: arreglar esto

                        return;

                }

                /*

                System.out.println("==============================================================");

                System.out.println(data);

                System.out.println("==============================================================");

                System.out.flush();

                */

                this.utiles.putInClipboard(data);

            int option=JOptionPane.showConfirmDialog((Component)PluginServices.getMainFrame(),PluginServices.getText(this,"desea_borrar_la_capa"));

            if (option!=JOptionPane.OK_OPTION) {

                    return;

            }

                if (this.utiles.removeLayers(actives)) {                        

                        if (getMapContext().getLayers().getLayersCount()==0) {

                                PluginServices.getMainFrame().enableControls();

                        }                                

                }

        }

}

class PasteTocMenuEntry extends myTocMenuEntry{

        private JMenuItem properties;

        private XMLEntity xml=null;

        public void initialize(FPopupMenu m) {

                super.initialize(m);                        

                properties = new JMenuItem(PluginServices.getText(this, "pegar"));

                properties.setFont(FPopupMenu.theFont);

                properties.addActionListener(this);

                getMenu().add( properties );

                //getMenu().addSeparator();

                if (isTocItemBranch()) {

                        FLayer lyr = getNodeLayer();

                        if (lyr instanceof FLayers) {

                                this.xml = this.getCheckedXMLFromClipboard();

                                properties.setEnabled((this.xml != null));                                

                        } else {

                                properties.setEnabled(false);

                        }

                } else if (isTocItemLeaf()) {

                        properties.setEnabled(false);

                }

        }

        private XMLEntity getCheckedXMLFromClipboard() {

                String sourceString = this.utiles.getFromClipboard();

                if (sourceString == null) return null;

                XMLEntity xml = this.utiles.unMarshallXMLEntity(sourceString);

                if (xml == null) return null;

                if (!this.utiles.checkXMLRootNode(xml)) return null;

                return  xml;

        }

        public void actionPerformed(ActionEvent e) {

                FLayers root;

                if (this.xml == null) return;

                if (isTocItemBranch()) {

                        root = (FLayers)getNodeLayer();

                } else {

                        root = getMapContext().getLayers();

                }

                getMapContext().beginAtomicEvent();

                if (!this.utiles.loadFromXML(this.xml,root)) return;

                getMapContext().endAtomicEvent();

        getMapContext().invalidate();

        }

}

class Utiles {

        public boolean checkXMLRootNode(XMLEntity xml) {

                if (!xml.contains("applicationName")) return false;

                if (!xml.getStringProperty("applicationName").equalsIgnoreCase("gvSIG")) return false;

                if (!xml.contains("version")) return false;

                if (!xml.getStringProperty("version").equalsIgnoreCase(Version.format())) return false;

                return true;

        }

        private void fillXMLRootNode(XMLEntity xml) {

                xml.putProperty("applicationName","gvSIG");

                xml.putProperty("version",Version.format());                

        }

        private XMLEntity getXMLEntityChildOfType(XMLEntity xml,String type) {

                int childCount = xml.getNumChild();

                XMLEntity child;

                for (int i=0; i < childCount; i++  ) {

                        child = xml.getChild(i);

                        if (child.contains("type")) {

                                if (child.getStringProperty("type").equalsIgnoreCase(type)) {

                                        return child;

                                }

                        }

                }

                return null;

        }

        public boolean loadFromXML(XMLEntity xml, FLayers root) {

                XMLEntity xmlLayers = this.getXMLEntityChildOfType(xml,"layers");

                XMLEntity xmlTables = this.getXMLEntityChildOfType(xml,"tables");

                XMLEntity xmlDataSources = this.getXMLEntityChildOfType(xml,"dataSources");

                if (xmlLayers == null ) return false;

                if (xmlDataSources != null)  {

                        if (!this.registerDataSources(xmlDataSources)) return false;

                }

                if (xmlTables != null)  {

                        if (!this.addTables(xmlTables)) return false;

                }

                if (!this.addLayers(xmlLayers,root)) return false;

                return true;

        }

        private boolean registerDataSources(XMLEntity xmlDataSources) {

                try {

                        int numDataSources = xmlDataSources.getNumChild();

                        if (numDataSources == 0) return true;

                        DataSourceFactory dsFactory = LayerFactory.getDataSourceFactory();

                        for (int i = 0; i < numDataSources; i++) {

                                XMLEntity child = xmlDataSources.getChild(i);

                                String name = child.getStringProperty("gdbmsname");

                                if (dsFactory.getDriverInfo(name) == null) {

                                        if (child.getStringProperty("type").equals("otherDriverFile")) {                                        

                                                LayerFactory.getDataSourceFactory().addFileDataSource(

                                                                child.getStringProperty("driverName"), 

                                                                name,

                                                                child.getStringProperty("file")

                                                );

                                        } else if (child.getStringProperty("type").equals("sameDriverFile")) {

                                                /*                                String layerName = child.getStringProperty("layerName");

                                                 ProjectView vista = project.getViewByName(child.getStringProperty(

                                                 "viewName"));

                                                 FLayer layer = vista.getMapContext().getLayers().getLayer(layerName);

                                                 modelo = ((AlphanumericData) layer).getRecordset();

                                                 associatedTable = (AlphanumericData) layer;

                                                 */

                                        } else if (child.getStringProperty("type").equals("db")) {

                                                LayerFactory.getDataSourceFactory().addDBDataSourceByTable(

                                                                name,

                                                                child.getStringProperty("host"),

                                                                child.getIntProperty("port"),

                                                                child.getStringProperty("user"),

                                                                child.getStringProperty("password"),

                                                                child.getStringProperty("dbName"),

                                                                child.getStringProperty("tableName"),

                                                                child.getStringProperty("driverInfo")

                                                );

                                        }

                                }

                        }

                        return true;

                } catch (Exception e) {

                        e.printStackTrace();

                        return false;

                }

        }

        private boolean addTables(XMLEntity xmlTables) {

                try {

                        int numTables = xmlTables.getNumChild();

                        if (numTables == 0) return true;

                        Project project = this.getProject();

                        for (int i = 0; i < numTables; i++) {

                                try{

                                        ProjectTable ptable = (ProjectTable) ProjectTable.createFromXML(xmlTables.getChild(i), project);

                                        project.addTable(ptable);

                                        if (ptable.getSeedViewInfo()!=null && ptable.getAndamiView()!=null) { // open the view, if it was open, and restore its dimensions

                                                PluginServices.getMDIManager().addView(ptable.getAndamiView());

                                                PluginServices.getMDIManager().changeViewInfo(ptable.getAndamiView(), ptable.getSeedViewInfo());

                                        }

                                }catch(OpenException e){

                                        e.printStackTrace();

                                        return false;

                                }

                        }

                        project.setLinkTable();

                        return true;

                } catch (Exception e) {

                        e.printStackTrace();

                        return false;                        

                }

        }

        private boolean addLayers(XMLEntity xmlLayers,FLayers root) {

                try {

                        XMLEntity child;

                        int numLayers = xmlLayers.getNumChild();

                        for (int i = 0; i < numLayers; i++) {

                                child = xmlLayers.getChild(i);

                                if (!root.addLayerFromXMLEntity(child,null)) return false;

                        }

                        return true;

                } catch (Exception e) {

                        e.printStackTrace();

                        return false;                        

                }

        }

        private Project getProject() {

                 return ((ProjectExtension)PluginServices.getExtension(ProjectExtension.class)).getProject();

        }

        public XMLEntity generateXML(FLayer[] actives) {

                FLayer lyr;

                Project project = this.getProject();

                XMLEntity xml = new XMLEntity();

                XMLEntity xmlLayers = new XMLEntity();

                XMLEntity xmlTables = new XMLEntity();

                XMLEntity xmlDataSources = new XMLEntity();

                fillXMLRootNode(xml);

                xmlLayers.putProperty("type","layers");

                xmlTables.putProperty("type","tables");

                xmlDataSources.putProperty("type","dataSources");

                for (int i=0;i < actives.length; i++) {

                        lyr = actives[i];

                        try {

                                xmlLayers.addChild(lyr.getXMLEntity());

                if (lyr instanceof AlphanumericData){

                        xmlDataSources.addChild(

                          project.getSourceInfoXMLEntity(

                                ((AlphanumericData)lyr).getRecordset().getSourceInfo()

                          )

                        );

                    ProjectTable pt = project.getTable((AlphanumericData) lyr);

                    if (pt != null) { 

                            xmlTables.addChild(pt.getXMLEntity());

                    }

                }

                        } catch (XMLException e1) {

                                // TODO Auto-generated catch block

                                e1.printStackTrace();

                                return null;

                        } catch (SaveException e) {

                                // TODO Auto-generated catch block

                                e.printStackTrace();

                                return null;

                        } catch (DriverException e) {

                                // TODO Auto-generated catch block

                                e.printStackTrace();

                                return null;

                        }

                }

                if (xmlDataSources.getNumChild() > 0) {

                        xml.addChild(xmlDataSources);

                }                

                if (xmlLayers.getNumChild() > 0) {

                        xml.addChild(xmlLayers);

                }

                if (xmlTables.getNumChild() > 0) {

                        xml.addChild(xmlTables);

                }

                return xml;

        }

        public void putInClipboard(String data) {

                StringSelection ss = new StringSelection(data);

                Toolkit.getDefaultToolkit().getSystemClipboard().setContents(ss,ss);                

        }

        public String marshallXMLEntity(XMLEntity xml) {

                StringWriter buffer = new StringWriter();

                Marshaller m;

                try {

                        m = new Marshaller(buffer);

                } catch (IOException e4) {

                        // TODO Auto-generated catch block

                        e4.printStackTrace();

                        return null;

                }

                m.setEncoding("ISO-8859-1");

                try {

                        m.marshal(xml.getXmlTag());

                        //if (i < actives.length-1) buffer.write("\n##layer-separator##\n");

                } catch (MarshalException e2) {

                        // TODO Auto-generated catch block

                        e2.printStackTrace();

                        return null;

                } catch (ValidationException e3) {

                        // TODO Auto-generated catch block

                        e3.printStackTrace();

                        return null;

                }

                return buffer.toString();

        }

        public XMLEntity unMarshallXMLEntity(String data) {

                StringReader reader = new StringReader(data);

                XmlTag tag;

                try {

                        tag = (XmlTag) XmlTag.unmarshal(reader);

                } catch (MarshalException e) {

                        return null;

                } catch (ValidationException e) {

                        return null;

                }

                XMLEntity xml=new XMLEntity(tag);

                return xml;

        }

        public String getFromClipboard() {        

                 try {

                        return (String)Toolkit.getDefaultToolkit().getSystemClipboard().getContents(null).getTransferData(DataFlavor.stringFlavor);

                } catch (UnsupportedFlavorException e) {

                        return null;

                } catch (IOException e) {

                        // TODO Auto-generated catch block

                        return null;

                }                 

        }

        public boolean removeLayers(FLayer[] actives) {

            for (int i = actives.length-1; i>=0; i--){

                try {

                                //actives[i].getParentLayer().removeLayer(actives[i]);

                                //FLayers lyrs=getMapContext().getLayers();

                                //lyrs.addLayer(actives[i]);

                                actives[i].getParentLayer().removeLayer(actives[i]);

                if (actives[i] instanceof AlphanumericData){

                    Project project = ((ProjectExtension)PluginServices.getExtension(ProjectExtension.class)).getProject();

                    ProjectTable pt = project.getTable((AlphanumericData) actives[i]);

                    ArrayList tables = project.getTables();

                    for (int j = 0; j < tables.size(); j++) {

                        if (tables.get(j) == pt){

                            project.delTable(j);

                            break;

                        }

                    }

                    PluginServices.getMDIManager().closeSingletonView(pt);

                }

                    } catch (CancelationException e1) {

                            e1.printStackTrace();

                            return false;

                    }

            }

                return true;

        }

}