Application: gvSIG desktop

/* gvSIG. Geographic Information System of the Valencian Government

*

* Copyright (C) 2007-2009 Infrastructures and Transports Department

* of the Valencian Government (CIT)

* 

* This program is free software; you can redistribute it and/or

* modify it under the terms of the GNU General Public License

* as published by the Free Software Foundation; either version 2

* of the License, or (at your option) any later version.

* 

* This program 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 General Public License for more details.

* 

* You should have received a copy of the GNU General Public License

* along with this program; if not, write to the Free Software

* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, 

* MA  02110-1301, USA.

* 

*/

/*

* AUTHORS (In addition to CIT):

* 2004-2009 IVER TI

*   

*/

package org.gvsig.app.project;

import java.awt.Color;

import java.beans.PropertyChangeEvent;

import java.beans.PropertyChangeListener;

import java.beans.PropertyChangeSupport;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.io.InputStream;

import java.io.OutputStream;

import java.io.Serializable;

import java.text.DateFormat;

import java.text.MessageFormat;

import java.util.ArrayList;

import java.util.Collections;

import java.util.Date;

import java.util.HashMap;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import org.cresques.cts.IProjection;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.andami.PluginServices;

import org.gvsig.andami.ui.mdiManager.IWindow;

import org.gvsig.andami.ui.mdiManager.SingletonWindow;

import org.gvsig.app.extension.Version;

import org.gvsig.app.project.documents.AbstractDocument;

import org.gvsig.app.project.documents.Document;

import org.gvsig.app.project.documents.exceptions.SaveException;

import org.gvsig.app.project.documents.layout.DefaultLayoutDocument;

import org.gvsig.app.project.documents.layout.LayoutDocument;

import org.gvsig.app.project.documents.layout.LayoutManager;

import org.gvsig.app.project.documents.table.TableDocument;

import org.gvsig.app.project.documents.table.TableManager;

import org.gvsig.app.project.documents.view.BaseViewDocument;

import org.gvsig.app.project.documents.view.DefaultViewDocument;

import org.gvsig.app.project.documents.view.ViewManager;

import org.gvsig.fmap.dal.DataTypes;

import org.gvsig.fmap.mapcontext.MapContext;

import org.gvsig.fmap.mapcontext.layers.FLayer;

import org.gvsig.fmap.mapcontext.layers.FLayers;

import org.gvsig.fmap.mapcontext.layers.vectorial.FLyrVect;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynField;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.persistence.PersistenceManager;

import org.gvsig.tools.persistence.Persistent;

import org.gvsig.tools.persistence.PersistentContext;

import org.gvsig.tools.persistence.PersistentState;

import org.gvsig.tools.persistence.exception.PersistenceException;

import org.gvsig.tools.persistence.exception.PersistenceValidateExceptions;

import org.gvsig.utils.StringUtilities;

/**

 * Clase que representa un proyecto de gvSIG

 *

 * @author 2004-2005 Fernando Gonz?lez Cort?s

 * @author 2006-2009 Jose Manuel Vivo

 * @author 2005-         Vicente Caballero

 * @author 2009-         Joaquin del Cerro

 * 

 */

public class DefaultProject implements Serializable, PropertyChangeListener, Project {

        private Logger LOG = LoggerFactory.getLogger(DefaultProject.class);

        /**

         * @deprecated see ApplicationLocator.getManager().getVersion()

         */

        public static String VERSION = Version.format();

        /**

         * 

         */

        private static final long serialVersionUID = -4449622027521773178L;

        //private static final  Logger logger = LoggerFactory.getLogger(Project .class);

        private static ProjectPreferences preferences = new ProjectPreferences();

        /**

         * Index used by the generator of unique names of documents.

         */

        private Map<String, Integer> nextDocumentIndexByType = new HashMap<String, Integer>();

        private PropertyChangeSupport change;

        private boolean modified = false;

        private String name = null;

        private String creationDate = null;

        private String modificationDate = null;

        private String owner = null;

        private String comments = null;

        private Color selectionColor = null;

        private List<Document> documents = null;

        private List<ProjectExtent> extents = null;

        private IProjection projection;

        /**

         * Creates a new Project object.

         */

        DefaultProject() {

                this.change = new PropertyChangeSupport(this);

                this.clean();

        }

        protected void clean() {

                this.owner = "";

                this.comments = "";

                this.name = PluginServices.getText(this, "untitled");

                this.creationDate = DateFormat.getDateInstance().format(new Date());

                this.modificationDate = this.creationDate;

                this.documents = new ArrayList<Document>();

                this.extents = new ArrayList<ProjectExtent>();

                this.setSelectionColor(getPreferences().getDefaultSelectionColor());

                this.projection = null ; // se inicializa en el getProjection()

        }

        public static ProjectPreferences getPreferences() {

                return preferences;

        }

        public void propertyChange(PropertyChangeEvent evt) {

                change.firePropertyChange(evt);

        }

        public synchronized void addPropertyChangeListener(

                        PropertyChangeListener arg0) {

                change.addPropertyChangeListener(arg0);

        }

        /**

         * Return the creation date of the project

         *

         * @return

         */

        public String getCreationDate() {

                return creationDate;

        }

        protected void setCreationDate(String creationDate) {

                this.creationDate = creationDate ;

                change.firePropertyChange("setCreationDate", null, null);

        }

        /**

         * Return the name of the project

         *

         * @return

         */

        public String getName() {

                return name;

        }

        /**

         * Set the name of he project.

         *

         * @param string

         */

        public void setName(String name) {

                this.name = name;

                change.firePropertyChange("setName", null, null);

        }

        /**

         * Return the comments associateds with the project

         *

         * @return comments

         */

        public String getComments() {

                return comments;

        }

        /**

         * Set the comments associateds with the project

         *

         * @param comments as string

         */

        public void setComments(String string) {

                comments = string;

                change.firePropertyChange("setComments", null, null);

        }

        /**

         * Retuen the modification date of the project.

         *

         * @return modification date as string

         */

        public String getModificationDate() {

                return modificationDate;

        }

        protected void setModificationDate(String string) {

                modificationDate = string;

                change.firePropertyChange("setModificationDate", null, null);

        }

        /**

         * Return the author of the project,

         *

         * @return author as string

         */

        public String getOwner() {

                return owner;

        }

        /**

         * Sets the author of the project

         *

         * @param author name as string

         */

        public void setOwner(String owner) {

                this.owner = owner;

                change.firePropertyChange("setOwner", null, null);

        }

        /**

         * Obtiene el color de selecci?n que se usar? en el proyecto

         *

         * @return

         */

        public Color getSelectionColor() {

                if (selectionColor == null) {

                        selectionColor = getPreferences().getDefaultSelectionColor();

                }

                return selectionColor;

        }

        /**

         * Sets the selecction color

         *

         * @param selection color as string

         */

        public void setSelectionColor(String selectionColor) {

                this.setSelectionColor(StringUtilities.string2Color(selectionColor));

        }

        /**

         * Sets the selecction color

         *

         * @param selection color as Color

         */

        public void setSelectionColor(Color selectionColor) {

                this.selectionColor = selectionColor;

                MapContext.setSelectionColor(selectionColor);

                change.firePropertyChange("selectionColor", null, selectionColor);

        }

        public IProjection getProjection() {

                if (projection == null) {

                        projection =  getPreferences().getDefaultProjection();

                }

                return projection;

        }

        public void setProjection(IProjection projection) {

                this.projection = projection;

        }

        /**

         * Sets the modified state of project.

         * 

         * Can't set to not modified.

         *

         * @param modified as boolean

         */

        public void setModified(boolean modified) {

                this.modified = modified;

                if (modified==false) {

                        List<Document> documents = this.getDocuments();

                        for( int i=0 ; i<documents.size(); i++ ) {

                                documents.get(i).setModified(false);

                        }

                }

        }

         public boolean hasChanged() {

                 // we return true if the project is not empty (until we have a better method...)

                 if ((this.getDocuments().size() != 0) || modified) {

                         return true;

                 }

                 return false;

         }

                /**

                 * Return a list of documents in the project.

                 *

                 * @return documents as List of IProjectDocument

                 */

                public List<Document> getDocuments() {

                        return Collections.unmodifiableList(documents);

                }

        /**

         * Return a list with all documents of especified type.

         *

         * @param type of document

         *

         * @return List of IProjectDocument

         */

                public List<Document> getDocuments(String type) {

                        List<Document> docs = new ArrayList<Document>();

                        if( type != null ) {

                                for (Document document : this.documents) {

                                        if (type.equalsIgnoreCase(document.getTypeName())) {

                                                docs.add(document);

                                        }

                                }

                        }

                        return Collections.unmodifiableList(docs);

                }

        /**

         * Adds a document to the project

         *

         * @param document as IProjectDocument

         */

        public void add(Document document) {

                documents.add(document);

                document.addPropertyChangeListener(this);

                document.setProject(this);

        document.setName( 

                        this.getUniqueNameForDocument(

                                document.getTypeName(), 

                                document.getName()

                        )

        );

        document.afterAdd();

                this.setModified(true);

                change.firePropertyChange("addDocument",null, null);

        }

        /**

         * Remove a document of the project

         *

         * @param document as IProjectDocument

         */

        public void remove(Document doc) {

                documents.remove(doc);

                this.setModified(true);

                change.firePropertyChange("delDocument", null, null);

                doc.afterRemove();

        }

        public Iterator<Document> iterator() {

                return documents.iterator();

        }

        public boolean isEmpty() {

                return documents.isEmpty();

        }

        /**

         * Return the FeatureTableDocument associated with a layer

         *

         * @param layer

         *

         * @return FeatureTableDocument associated with the layer.

         */

        public TableDocument getTable(FLyrVect layer) {

                List<Document> tables = getDocuments(TableManager.TYPENAME);

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

                        TableDocument table = (TableDocument) tables.get(i);

                                if ( table.getStore().equals(layer.getFeatureStore())  ){

                                        return table;

                                }

                }

                return null;

        }

        /**

         * Return the view that contains the especified layer.

         *

         * @param layer

         *

         * @return name of the view that contains the layer

         *

         * @throws RuntimeException 

         *             Si la capa que se pasa como par?metro no se encuentra en

         *             ninguna vista

         */

        public String getViewName(FLayer layer) {

                List<Document> views = getDocuments(ViewManager.TYPENAME);

                for (int v = 0; v < views.size(); v++) {

                        DefaultViewDocument pView = (DefaultViewDocument) views.get(v);

                        FLayers layers = pView.getMapContext().getLayers();

                        if (isView(layers, layer)) {

                                return pView.getName();

                        }

                }

                throw new RuntimeException(MessageFormat.format("The layer '{1}' is not in a view",  layer.getName()));

        }

        private boolean isView(FLayers layers, FLayer layer) {

                for (int i = 0; i < layers.getLayersCount(); i++) {

                        if (layers.getLayer(i) instanceof FLayers) {

                                if (isView((FLayers) layers.getLayer(i), layer)){

                                        return true;

                                }

                        }

                        if (layers.getLayer(i) == layer) {

                                return true;

                        }

                }

                return false;

        }

        public void addExtent(ProjectExtent arg1) {

                extents.add(arg1);

                change.firePropertyChange("addExtent", null, null);

        }

        public ProjectExtent removeExtent(int arg0) {

                change.firePropertyChange("delExtent", null, null);

                return extents.remove(arg0);

        }

        public ProjectExtent[] getExtents() {

                return (ProjectExtent[]) extents.toArray(new ProjectExtent[0]);

        }

        /**

         * Obtiene un documento a partir de su nombre y el nombre de registro en el

         * pointExtension, este ?ltimo se puede obtener del

         * Project****Factory.registerName.

         *

         * @param name

         *            Nombre del documento

         * @param type

         *            nombre de registro en el extensionPoint

         *

         * @return Documento

         */

        public Document getDocument(String name, String type) {

                if( type != null ) {

                        for (int i = 0; i < documents.size(); i++) {

                                Document document = documents.get(i);

                                if (type.equalsIgnoreCase(document.getTypeName()) && name.equalsIgnoreCase(document.getName())) {

                                        return document;

                                }

                        }

                }

                return null;

        }

        public String getUniqueNameForDocument(String type, String name) {

                Document document = getDocument(name, type);

                if( document == null ) {

                        return name;

                }

        String newName = null;

        int num = this.getNextDocumentIndex(type);

        while( document != null ) {

            newName = name + " - " + num++;

                    document = getDocument(newName, type);                

        } 

        this.setNextDocumentIndex(type, num);

        return newName;

        }

        private int getNextDocumentIndex(String type) {

                if( nextDocumentIndexByType.get(type) == null ) {

                        nextDocumentIndexByType.put(type, new Integer(1));

                        return 1;

                }

                return nextDocumentIndexByType.get(type).intValue();

        }

        private void setNextDocumentIndex(String type, int newIndex) {

                if( nextDocumentIndexByType.get(type) == null ) {

                        nextDocumentIndexByType.put(type, new Integer(newIndex));

                } else {

                        nextDocumentIndexByType.put(type, new Integer(newIndex));

                }

        }

        public void saveState(File out) throws PersistenceException {

                FileOutputStream fout;

                try {

                        fout = new FileOutputStream(out);

                        saveState(fout, new File(out.getParent()));

                } catch (FileNotFoundException e) {

                        throw new PersistenceException(e);

                }

        }

        public void saveState(OutputStream out) throws PersistenceException {

                saveState(out, null);

        }

        public void saveState(OutputStream out, File rootFolder) throws PersistenceException {

                PersistenceManager manager = ToolsLocator.getPersistenceManager();

                PersistentState state=null;

                state = manager.getState(this,true);

                try {

                        if( rootFolder!=null ) {

                                relativizeFiles(state, rootFolder);

                        }

                } catch(Exception ex) {

                        state.getContext().addError(ex);

                }

                manager.saveState( state, out);

                if( state.getContext().getErrors() != null  ) {

                        throw state.getContext().getErrors();

                }

        }

        private void relativizeFiles(PersistentState state, File rootFolder) {

                PersistentContext context = state.getContext();

                @SuppressWarnings("unchecked")

                Iterator<PersistentState> statesIterator = context.iterator();

                while( statesIterator.hasNext() ) {

                        PersistentState aState = statesIterator.next();

                        DynStruct definition = aState.getDefinition();

                        DynField[] fields = definition.getDynFields();

                        for (DynField field : fields) {

                                if( field.getType() == DataTypes.FILE ||

                                        field.getType() == DataTypes.FOLDER ) {

                                        try {

                                                File value = aState.getFile(field.getName());

                                                value = relativizeFile(value, rootFolder);

                                                aState.set(field.getName(), value );

                                        } catch (PersistenceException e) {

                                                LOG.warn("Can't relativice field '"+field.getName()+"' for class '"+definition.getName()+"'.",e);

                                        }

                                }

                        }

                }

        }

        private File relativizeFile(File file, File rootFolder) {

                // TODO: falta por implementar.

                return file;

        }

        public void loadState(InputStream in) {

                PersistenceManager manager = ToolsLocator.getPersistenceManager();

                try {

                        PersistentState state = manager.loadState(in);

                        this.loadFromState(state);

                } catch (PersistenceException e) {

                        // TODO Auto-generated catch block

                        e.printStackTrace();

                }

        }

        public void loadState(File in) {

                FileInputStream fin;

                try {

                        fin = new FileInputStream(in);

                        loadState(fin);

                } catch (FileNotFoundException e) {

                        // TODO Auto-generated catch block

                        e.printStackTrace();

                }

        }

        @SuppressWarnings("unchecked")

        public void loadFromState(PersistentState state)

                        throws PersistenceException {

                this.clean();

                this.setComments( state.getString("comments") );

                this.setCreationDate( state.getString("creationDate") );

                this.setModificationDate( state.getString("modificationDate") );

                this.setName( state.getString("name") );

                this.setOwner( state.getString("owner") );

                this.setSelectionColor( (Color)state.get("selectionColor") );

                this.setProjection( (IProjection) state.get("projection") );

                List<ProjectExtent> extents = (List<ProjectExtent>) state.get("extents");

                for( int i=0; i<extents.size(); i++) {

                        this.addExtent( extents.get(i) );

                }

                List<AbstractDocument> documents = (List<AbstractDocument>) state.get("documents");

                for( int i=0; i<documents.size(); i++) {

                        this.add( documents.get(i) );

                }

        }

        public void saveToState(PersistentState state) throws PersistenceException {

                state.set("version", VERSION);

                state.set("comments", getComments());

                state.set("creationDate", this.getCreationDate());

                state.set("modificationDate",  this.getModificationDate());

                state.set("name", this.getName());

                state.set("owner", this.getOwner());

                state.set("selectionColor", this.getSelectionColor());

                state.set("projection",  this.getProjection());

                state.set("extents", this.extents);

                state.set("documents", this.getDocuments());

                PersistenceManager persistenceManager = ToolsLocator.getPersistenceManager();

                List<PersistentState> windowsStates = new ArrayList<PersistentState>();

                IWindow[] windows = PluginServices.getMDIManager().getOrderedWindows();

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

                        IWindow window = windows[i];

                        if( window instanceof Persistent ) {

                                try {

                                        windowsStates.add( persistenceManager.getState(windows));

                                } catch (PersistenceValidateExceptions e) {

                                        throw new PersistenceException(e);

                                }

                        }

                }

                LOG.warn("DefaultProject::saveToState, falta por persistir 'windowsInformation'");

                //state.set("windowsInformation", windowsStates);

        }

        public static void registerPersistent() {

                PersistenceManager manager = ToolsLocator.getPersistenceManager();

                DynStruct definition = manager.addDefinition(

                                DefaultProject.class,

                                "Project",

                                "Project Persistence definition",

                                null, 

                                null

                );

                definition.addDynFieldString("version").setMandatory(true);

                definition.addDynFieldString("comments").setMandatory(true);

                definition.addDynFieldString("creationDate").setMandatory(true);

                definition.addDynFieldString("modificationDate").setMandatory(true);

                definition.addDynFieldString("name").setMandatory(true);

                definition.addDynFieldString("owner").setMandatory(true);

                definition.addDynFieldObject("selectionColor").setClassOfValue(Color.class).setMandatory(true);

                definition.addDynFieldObject("projection").setClassOfValue(IProjection.class).setMandatory(true);

                definition.addDynFieldList("extents").setClassOfItems(ProjectExtent.class).setMandatory(true);

                definition.addDynFieldList("documents").setClassOfItems(Document.class).setMandatory(true);

                AbstractDocument.registerPersistent();

        }

        /**

         * @deprecated use getPreferences().setDefaultSelectionColor()

         */

        public static void setDefaultSelectionColor(Color color) {

                getPreferences().setDefaultSelectionColor(color);

        }

        /**

         * @deprecated use getPreferences().getDefaultSelectionColor()

         */

        public static Color getDefaultSelectionColor() {

                return getPreferences().getDefaultSelectionColor();

        }

        /**

         * @deprecated use getPreferences().getDefaultMapUnits()

         */

        public static int getDefaultMapUnits() {

                return getPreferences().getDefaultMapUnits();

        }

        /**

         * @deprecated use getPreferences().getDefaultDistanceUnits()

         */

        public static int getDefaultDistanceUnits() {

                return getPreferences().getDefaultDistanceUnits();

        }

        /**

         * @deprecated use getPreferences().getDefaultDistanceArea()

         */

        public static int getDefaultDistanceArea() {

                return getPreferences().getDefaultDistanceArea();

        }

        /**

         * @deprecated use getPreferences().setDefaultMapUnits()

         */

        public static void setDefaultMapUnits(int mapUnits) {

                getPreferences().setDefaultMapUnits(mapUnits);

        }

        /**

         * @deprecated use getPreferences().setDefaultDistanceUnits()

         */

        public static void setDefaultDistanceUnits(int distanceUnits) {

                getPreferences().setDefaultDistanceUnits(distanceUnits);

        }

        /**

         * @deprecated use getPreferences().setDefaultDistanceArea()

         */

        public static void setDefaultDistanceArea(int distanceArea) {

                getPreferences().setDefaultDistanceArea(distanceArea);

        }

        /**

         * @deprecated use getPreferences().setDefaultProjection()

         */

        public static void setDefaultProjection(IProjection defaultProjection) {

                getPreferences().setDefaultProjection(defaultProjection);

        }

        /**

         * @deprecated use getPreferences().getDefaultProjection()

         */

        public static IProjection getDefaultProjection() {

                return getPreferences().getDefaultProjection();

        }

        /**

         * @deprecated see {@link #setSelectionColor(String)}, to be remove in gvSIG 2.1.0

         */

        public void setColor(String color) {

                this.setSelectionColor(StringUtilities.string2Color(color));

        }

        /**

         * Return the selection color 

         *

         * @return selection color as string

         * @deprecated use {@link #getSelectionColor()}

         */

        public String getColor() {

                return StringUtilities.color2String(selectionColor);

        }

        /**

         * Devuelve a partir del nombre la tabla asociada.

         *

         * @param name

         *            Nombre.

         * @deprecated utilizar getProjectDocumentByName(...);

         * @return ProjectTable de la tabla asociada.

         */

        public TableDocument getTable(String name) {

                return (TableDocument) this.getDocument(name,TableManager.TYPENAME);

        }

        /**

         * Return the list of maps of the project

         *

         * @return tables as ArrayList of IProjectDocument

         * 

         * @deprecated see {@link #getDocumentsByType(String)}

         */

        public List<Document> getMaps() {

                return getDocuments(LayoutManager.TYPENAME);

        }

        /**

         * Add a  {@link LayoutDocument} to the project

         *

         * @deprecated see {@link #add(Document)}

         */

        public void addMap(LayoutDocument m) {

                add(m);

        }

        /**

         * Remove a  map of the project

         *

         * @param index of the map as integer

         * 

         * @deprecated see {@link #remove(Document)}

         */

        public void delMap(int i) {

                List<Document> list = getDocuments(LayoutManager.TYPENAME);

                remove(list.get(i));

        }

        /**

         * Return the list of tables of the project

         *

         * @return tables as ArrayList of ProjectDocument

         * 

         * @deprecated see {@link #getDocumentsByType(String)}

         */

        public List<Document> getTables() {

                return getDocuments(TableManager.TYPENAME);

        }

        /**

         * Add a  {@link TableDocument } to the project

         *

         * @deprecated see {@link #add(AbstractDocument)}

         */

        public void addTable(TableDocument t) {

                add(t);

        }

        /**

         * Remove a  {@link TableDocument } of the project

         *

         * @param index of the table as integer

         * 

         * @deprecated see {@link #remove(AbstractDocument)}

         */

        public void delTable(int i) {

                List<Document> list = getDocuments(TableManager.TYPENAME);

                remove(list.get(i));

        }

        /**

         * Return the list of views of the project

         *

         * @return views as ArrayList of ProjectDocument

         * 

         * @deprecated see {@link #getDocumentsByType(String)}

         */

        public List<Document> getViews() {

                return getDocuments(ViewManager.TYPENAME);

        }

        /**

         * Add a  view to the project

         *

         * @deprecated see {@link #add(AbstractDocument)}

         */

        public void addView(DefaultViewDocument v) {

                add(v);

        }

        /**

         * Remove a view of the project

         *

         * @param index of the view as integer

         * 

         * @deprecated see {@link #remove(AbstractDocument)}

         */

        public void delView(int i) {

                List<Document> list = getDocuments(ViewManager.TYPENAME);

                remove(list.get(i));

        }

        /**

         * @deprecated see {@link #getDocument(String, String)} 

         */

        public Document getProjectDocumentByName(String name, String type) {

                return this.getDocument(name, type);

        }

        /**

         * @deprecated see {@link #getDocuments(String)} 

         */

        public List<Document> getDocumentsByType(String type) {

                return this.getDocuments(type);

        }

        /**

         * @deprecated aun por decidir que API darle al copy/paste 

         */

        public String exportToXML(AbstractDocument[] selectedItems) throws SaveException {

                // FIXME jjdc:hay que decirdir que API darle al copy/paste

                throw new UnsupportedOperationException("This method is not supported");

        }

        /**

         * @deprecated aun por decidir que API darle al copy/paste 

         */

        public void importFromXML(String sourceString, String docType) {

                // FIXME jjdc:hay que decirdir que API darle al copy/paste

                throw new UnsupportedOperationException("This method is not supported");

        }

        /**

         * @deprecated aun por decidir que API darle al copy/paste 

         */

        public boolean isValidXMLForImport(String sourceString, String docType) {

                // FIXME jjdc:hay que decirdir que API darle al copy/paste

                throw new UnsupportedOperationException("This method is not supported");

        }

        public boolean canImportDocuments(String data, String doctype) {

                // TODO Auto-generated method stub

                return false;

        }

        public String exportDocumentsAsText(List<Document> documents) {

                // TODO Auto-generated method stub

                return null;

        }

        public void importDocuments(String data, String doctype) {

                // TODO Auto-generated method stub

        }

        public Document getActiveDocument() {

                try {

                        SingletonWindow window = (SingletonWindow) PluginServices.getMDIManager().getActiveWindow();

                        Document doc = (Document) window.getWindowModel();

                        return doc;

                } catch(Exception ex) {

                        return null;

                }

        }

}