| gvSIG desktop 1

/* 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.net.MalformedURLException;

import java.net.URI;

import java.net.URISyntaxException;

import java.net.URL;

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 java.util.regex.Pattern;

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.MDIManager;

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

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

import org.gvsig.app.ApplicationLocator;

import org.gvsig.app.ApplicationManager;

import org.gvsig.app.extension.ProjectExtension;

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.gui.IDocumentWindow;

import org.gvsig.app.project.documents.gui.ProjectWindow;

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.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.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);

        }

    public Document createDocument(String type) {

            logger.info("createDocument('{}')",type);

        return ProjectManager.getInstance().createDocument(type);

    }

    /**

     * 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) {

        logger.info("add('{}')", document.toString());

                document.addPropertyChangeListener(this);

                document.setProject(this);

                document.setName(this.getUniqueNameForDocument(document.getTypeName(),

                                document.getName()));

                documents.add(document);

                document.afterAdd();

                this.setModified(true);

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

        }

        /**

         * Remove a document of the project

         * 

         * @param document

         *            as IProjectDocument

         */

        public void remove(Document doc) {

        logger.info("remove('{}')", doc.toString());

                documents.remove(doc);

                this.setModified(true);

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

                doc.afterRemove();

        }

        public Iterator<Document> iterator() {

                return documents.iterator();

        }

        public boolean isEmpty() {

                return documents.isEmpty();

        }

        /**

         * 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();

                URI cwd = new File(System.getProperty("user.dir")).toURI();

                @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);

                                        }

                                } else if (field.getType() == DataTypes.URL) {

                                        try {

                                                URL value = aState.getURL(field.getName());

                                                if ("FILE".equalsIgnoreCase(value.getProtocol())) {

                                                        File file = new File(value.toURI());

                                                        file = relativizeFile(file, rootFolder);

                                                        value = new URL("file","",file.toURI().toString().substring(cwd.toString().length()));

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

                                                }

                                        } catch (PersistenceException e) {

                                                // do nothind

                                        } catch (MalformedURLException e) {

                                                // do nothind

                                        } catch (URISyntaxException e) {

                                                // do nothind

                                        }

                                }

                        }

                }

        }

        private File relativizeFile(File file, File rootFolder) {

                if (rootFolder == null) {

                        return file;

                }

                if (file == null) {

                        return null;

                }

                boolean isDir = false;

                // isDir = file.isDirectory();

                isDir = rootFolder.isDirectory();

                String basePath = rootFolder.getAbsolutePath();

                String targetPath = file.getPath();

                String pathSeparator = File.separator;

                // We need the -1 argument to split to make sure we get a trailing

                // "" token if the base ends in the path separator and is therefore

                // a directory. We require directory paths to end in the path

                // separator -- otherwise they are indistinguishable from files.

                String[] base = basePath.split(Pattern.quote(pathSeparator), -1);

                String[] target = targetPath.split(Pattern.quote(pathSeparator), 0);

                // First get all the common elements. Store them as a string,

                // and also count how many of them there are.

                String common = "";

                int commonIndex = 0;

                for (int i = 0; i < target.length && i < base.length; i++) {

                        if (target[i].equals(base[i])) {

                                common += target[i] + pathSeparator;

                                commonIndex++;

                        } else

                                break;

                }

                if (commonIndex == 0) {

                        // Whoops -- not even a single common path element. This most

                        // likely indicates differing drive letters, like C: and D:.

                        // These paths cannot be relativized. Return the target path.

                        return file;

                        // This should never happen when all absolute paths

                        // begin with / as in *nix.

                }

                String relative = "";

                if (base.length == commonIndex) {

                        // Comment this out if you prefer that a relative path not start

                        // with ./

                        relative = "." + pathSeparator;

                } else {

                        int numDirsUp = base.length - commonIndex - (isDir ? 0 : 1); /*

                                                                                                                                                 * only

                                                                                                                                                 * subtract

                                                                                                                                                 * 1 if

                                                                                                                                                 * it is

                                                                                                                                                 * a

                                                                                                                                                 * file.

                                                                                                                                                 */

                        // The number of directories we have to backtrack is the length of

                        // the base path MINUS the number of common path elements, minus

                        // one because the last element in the path isn't a directory.

                        for (int i = 1; i <= (numDirsUp); i++) {

                                relative += ".." + pathSeparator;

                        }

                }

                // if we are comparing directories then we

                if (targetPath.length() > common.length()) {

                        // it's OK, it isn't a directory

                        relative += targetPath.substring(common.length());

                }

                return new File(relative);

        }

        private void fixFiles(PersistentState state, File rootFolder) {

                PersistentContext context = state.getContext();

                URI cwd = new File(System.getProperty("user.dir")).toURI();

                @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 = fixFile(value, rootFolder);

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

                                        } catch (PersistenceException e) {

                                                LOG.warn(

                                                                "Can't fix field '" + field.getName()

                                                                                + "' for class '"

                                                                                + definition.getName() + "'.", e);

                                        }

                                } else if (field.getType() == DataTypes.URL) {

                                        try {

                                                URL value = aState.getURL(field.getName());

                                                if ("FILE".equalsIgnoreCase(value.getProtocol())) {

                                                        if (!value.getFile().startsWith("/")){

                                                                value = new URL("file","",cwd.getRawPath()+value.getFile());

                                                                File file = new File(value.toURI().getPath().substring(cwd.getPath().length()));

                                                                file = fixFile(file, rootFolder);

                                                                aState.set(field.getName(), file.toURI().toURL());

                                                        }

                                                }

                                        } catch (PersistenceException e) {

                                                // do nothing

                                        } catch (MalformedURLException e) {

                                                // do nothing

                                        } catch (URISyntaxException e) {

                                                // do nothing

                                        }

                                }

                        }

                }

        }

        private File fixFile(File file, File rootFolder) {

                if (file.isAbsolute()) {

                        return file;

                }

                return new File(rootFolder, file.getPath()).getAbsoluteFile();

        }

        public void loadState(InputStream in) {

                loadState(in, null);

        }

        public void loadState(InputStream in, File rootFolder) {

                PersistenceManager manager = ToolsLocator.getPersistenceManager();

                try {

                        PersistentState state = manager.loadState(in);

                        try {

                                if (rootFolder != null) {

                                        fixFiles(state, rootFolder);

                                }

                        } catch (Exception ex) {

                                state.getContext().addError(ex);

                        }

                        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, new File(in.getParent()));

                } 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));

                }

                List<DocumentWindowInfo> persistentWindows = (List<DocumentWindowInfo>) state.get("documentWindowsInformation");

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

                        DocumentWindowInfo persistentWindow = persistentWindows.get(i);

                        String docName = persistentWindow.getDocumentName();

                        String docType = persistentWindow.getDocumentType();

                        Document doc = this.getDocument(docName, docType);

                        IWindow win = doc.getFactory().getMainWindow(doc);

                        win.getWindowInfo().setWindowInfo(persistentWindow.getWindowInfo());

                        PluginServices.getMDIManager().addWindow(win);

                }

                if (state.hasValue("projectWindowInfo")){

                        WindowInfo projectWindowInfo = (WindowInfo)state.get("projectWindowInfo"); 

                        ProjectExtension pe = (ProjectExtension) PluginServices.getExtension(org.gvsig.app.extension.ProjectExtension.class);

                        pe.setProject(this);

                        pe.showProjectWindow(projectWindowInfo);

                }

        }

        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());

                List<DocumentWindowInfo> persistentWindows = new ArrayList<DocumentWindowInfo>();

                MDIManager mdiMan = PluginServices.getMDIManager();

                IWindow[] windows = mdiMan.getOrderedWindows();

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

                        IWindow window = windows[i];

                        if (window instanceof IDocumentWindow){

                                WindowInfo wi =  mdiMan.getWindowInfo(window);

                                DocumentWindowInfo dwi = new DocumentWindowInfo(

                                                wi,

                                                ((IDocumentWindow) window).getDocument().getTypeName(),

                                                ((IDocumentWindow) window).getDocument().getName());

                                persistentWindows.add(dwi);

                        } else if (window instanceof ProjectWindow){

                                state.set("projectWindowInfo", mdiMan.getWindowInfo(window));

                        }

                }

                state.set("documentWindowsInformation", persistentWindows);

        }

        public static class DocumentWindowInfo implements Persistent {

                public static final String PERSISTENCE_DEFINITION_NAME = "DocumentWindowInfo";

                private WindowInfo windowInfo;

                private String documentType;

                private String documentName;

                public DocumentWindowInfo(){

                }

                DocumentWindowInfo(WindowInfo wi, String docType, String docName){

                        windowInfo = wi;

                        documentType = docType;

                        documentName = docName;

                }

                public WindowInfo getWindowInfo() {

                        return windowInfo;

                }

                public String getDocumentType() {

                        return documentType;

                }

                public String getDocumentName() {

                        return documentName;

                }

                public void saveToState(PersistentState state)

                                throws PersistenceException {

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

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

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

                }

                public void loadFromState(PersistentState state)

                                throws PersistenceException {

                        this.windowInfo = (WindowInfo) state.get("windowInfo");

                        this.documentType = state.getString("documentType");

                        this.documentName = state.getString("documentName");

                }

                public static void registerPersistent() {

                        PersistenceManager manager = ToolsLocator.getPersistenceManager();

                        DynStruct definition = manager.getDefinition(PERSISTENCE_DEFINITION_NAME);

                        if ( definition == null ){

                                definition = manager.addDefinition(

                                                DocumentWindowInfo.class,

                                                PERSISTENCE_DEFINITION_NAME,

                                                "DocumentWindowInfo persistence definition",

                                                null, 

                                                null

                                );

                                definition.addDynFieldObject("windowInfo").setMandatory(true).setClassOfValue(WindowInfo.class);

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

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

                        }

                }

        }

        public static void registerPersistent() {

                AbstractDocument.registerPersistent();

                DocumentWindowInfo.registerPersistent();

                ProjectExtent.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);

                definition.addDynFieldObject("projectWindowInfo").setClassOfValue(WindowInfo.class).setMandatory(false);

                definition.addDynFieldList("documentWindowsInformation").setClassOfItems(WindowInfo.class).setMandatory(false);

        }

        /**

         * @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);

        }

        /**

         * 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() {

                ApplicationManager application = ApplicationLocator.getManager();

                Document document = null;

                IWindow[] windows = application.getUIManager().getOrderedWindows();

                IWindow window = null;

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

                    window = windows[i];

                        if (window instanceof SingletonWindow) {

                                // Cogemos no la primera ventana, si no la primera

                                // ventana de tipo documento (SingletonWindow).

                                // Y por si las mosca no es un documento, atrapamos

                                // los errores y continuamos si no puede hacer un cast

                                // del Model a Document

                                try {

                                        document = (Document) ((SingletonWindow) window).getWindowModel();

                                        return document;

                                } catch (ClassCastException e) {

                                        // Do nothing, skip this window

                                }

                        }

                }

                return null;

        } 

}